Module:Punycode

Documentation for this module may be created at Module:Punycode/doc

-- Module:Punycode
-- Implements RFC3492 (Punycode) encoding and decoding; requires mw.ustring for proper Unicode support

local punycode = {}

-- Cache for frequently processed strings (persists during a single page render)
local encodeCache = {}
local decodeCache = {}

--------------------------
-- Configuration Constants
--------------------------
local base         = 36
local tmin         = 1
local tmax         = 26
local skew         = 38
local damp         = 700
local initial_bias = 72
local initial_n    = 128   -- 0x80
local delimiter    = '-'   -- ASCII hyphen

--------------------------
-- Helper functions for Unicode handling.
--------------------------
-- Converts a UTF-8 string to an array of Unicode code points.
local function toCodePoints(s)
    if not s or s == "" then
        return {}
    end
    
    -- Estimate the number of characters (may not be exact for multi-byte chars)
    local len = mw.ustring.len(s)
    local cps = {}
    
    -- Pre-allocate the table with an index counter for direct assignment
    local i = 1
    for char in mw.ustring.gmatch(s, ".") do
        cps[i] = mw.ustring.codepoint(char)
        i = i + 1
    end
    
    return cps
end

-- Converts an array of Unicode code points to a UTF-8 string.
local function fromCodePoints(cps)
    if not cps or #cps == 0 then
        return ""
    end
    
    -- Pre-allocate the table with the exact size needed
    local chars = {}
    for i = 1, #cps do
        chars[i] = mw.ustring.char(cps[i])
    end
    
    return table.concat(chars)
end

--------------------------
-- Digit conversion functions
--------------------------
local function digitToBasic(digit)
    if digit < 26 then
        return string.char(digit + string.byte('a'))
    else
        return string.char(digit - 26 + string.byte('0'))
    end
end

local function basicToDigit(cp)
    if cp >= string.byte('0') and cp <= string.byte('9') then
        return cp - string.byte('0') + 26
    elseif cp >= string.byte('A') and cp <= string.byte('Z') then
        return cp - string.byte('A')
    elseif cp >= string.byte('a') and cp <= string.byte('z') then
        return cp - string.byte('a')
    else
        return base
    end
end

--------------------------
-- Bias adaptation (RFC3492, Section 3.4)
--------------------------
local function adapt(delta, numpoints, first)
    if first then
        delta = math.floor(delta / damp)
    else
        delta = math.floor(delta / 2)
    end
    delta = delta + math.floor(delta / numpoints)
    local k = 0
    while delta > ((base - tmin) * tmax) / 2 do
        delta = math.floor(delta / (base - tmin))
        k = k + base
    end
    return k + math.floor(((base - tmin + 1) * delta) / (delta + skew))
end

--------------------------
-- Punycode Encoding Function
--------------------------
function punycode.encode(input)
    -- Input validation and cache check
    if not input or input == "" then
        return ""
    end
    
    input = mw.ustring.lower(input)
    -- Check cache first for previously encoded strings
    if encodeCache[input] then
        return encodeCache[input]
    end
    
    local output = {}
    local cp_array = toCodePoints(input)
    local n = initial_n
    local delta = 0
    local bias = initial_bias
    local basic_count = 0

    -- Copy basic code points (ASCII < 128)
    for _, cp in ipairs(cp_array) do
        if cp < 128 then
            table.insert(output, mw.ustring.char(cp))
            basic_count = basic_count + 1
        end
    end

    local h = basic_count
    if basic_count > 0 then
        table.insert(output, delimiter)
    end

    while h < #cp_array do
        local m = 0x7FFFFFFF
        for _, cp in ipairs(cp_array) do
            if cp >= n and cp < m then
                m = cp
            end
        end

        delta = delta + (m - n) * (h + 1)
        n = m
        for _, cp in ipairs(cp_array) do
            if cp < n then
                delta = delta + 1
            elseif cp == n then
                local q = delta
                local k = base
                while true do
                    local t
                    if k <= bias then
                        t = tmin
                    elseif k >= bias + tmax then
                        t = tmax
                    else
                        t = k - bias
                    end
                    if q < t then break end
                    local code = t + ((q - t) % (base - t))
                    table.insert(output, digitToBasic(code))
                    q = math.floor((q - t) / (base - t))
                    k = k + base
                end
                table.insert(output, digitToBasic(q))
                bias = adapt(delta, h + 1, h == basic_count)
                delta = 0
                h = h + 1
            end
        end
        delta = delta + 1
        n = n + 1
    end

    local result = table.concat(output)
    
    -- Cache the result before returning
    encodeCache[input] = result
    return result
end

--------------------------
-- Punycode Decoding Function
--------------------------
function punycode.decode(input)
    -- Input validation and cache check
    if not input or input == "" then
        return ""
    end
    
    -- Check cache first for previously decoded strings
    if decodeCache[input] then
        return decodeCache[input]
    end
    
    local cp_array = {}
    local d = input:find(delimiter, 1, true)
    local b = 0
    if d then
        for i = 1, d - 1 do
            local cp = input:byte(i)
            table.insert(cp_array, cp)
            b = b + 1
        end
    else
        d = 0
    end

    local n = initial_n
    local bias = initial_bias
    local i = 0
    local index = d + 1
    local input_len = #input

    while index <= input_len do
        local oldi = i
        local w = 1
        local k = base
        while true do
            if index > input_len then
                error("Invalid input: punycode decode incomplete")
            end
            local digit = basicToDigit(input:byte(index))
            index = index + 1
            i = i + digit * w
            local t
            if k <= bias then
                t = tmin
            elseif k >= bias + tmax then
                t = tmax
            else
                t = k - bias
            end
            if digit < t then break end
            w = w * (base - t)
            k = k + base
        end
        bias = adapt(i - oldi, #cp_array + 1, oldi == 0)
        n = n + math.floor(i / (#cp_array + 1))
        i = i % (#cp_array + 1)
        table.insert(cp_array, i + 1, n)
        i = i + 1
    end

    local result = fromCodePoints(cp_array)
    
    -- Cache the result before returning
    decodeCache[input] = result
    return result
end

return punycode

American Standard Code for Information Interchange