Module:Punycode

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

-- Module:Punycode  –  pure Lua 5.1 implementation of RFC 3492
-- Provides:
--   punycode.encode(label)   – encode one DNS label (no dots) to Punycode
--   punycode.decode(label)   – decode one Punycode label
--   punycode.toASCII(domain) – Unicode → IDNA (handles dots, adds xn--)
--   punycode.toUnicode(domain) – IDNA → Unicode
-- No external dependencies; works in stock Lua 5.1 and MediaWiki Scribunto.

local punycode = {}

------------------------------------------------------------
--  RFC 3492 constants
------------------------------------------------------------
local base, tmin, tmax = 36, 1, 26
local skew, damp       = 38, 700
local initial_bias     = 72
local initial_n        = 128        -- 0x80
local delim            = '-'        -- ASCII hyphen

------------------------------------------------------------
--  UTF-8 helpers (pure Lua 5.1 – no bit32 / utf8 libs)
------------------------------------------------------------
local function toCodePoints(s)
    local cps, i, len = {}, 1, #s
    while i <= len do
        local b1 = s:byte(i)
        if b1 < 0x80 then
            cps[#cps + 1] = b1
            i = i + 1
        elseif b1 < 0xE0 then -- 2-byte
            local b2 = s:byte(i + 1)
            cps[#cps + 1] = (b1 - 0xC0) * 0x40 + (b2 - 0x80)
            i = i + 2
        elseif b1 < 0xF0 then -- 3-byte
            local b2, b3 = s:byte(i + 1, i + 2)
            cps[#cps + 1] = (b1 - 0xE0) * 0x1000 + (b2 - 0x80) * 0x40 + (b3 - 0x80)
            i = i + 3
        else                  -- 4-byte
            local b2, b3, b4 = s:byte(i + 1, i + 3)
            cps[#cps + 1] =
                (b1 - 0xF0) * 0x40000 +
                (b2 - 0x80) * 0x1000  +
                (b3 - 0x80) * 0x40    +
                (b4 - 0x80)
            i = i + 4
        end
    end
    return cps
end

local function cpToUtf8(cp)
    if cp < 0x80 then
        return string.char(cp)
    elseif cp < 0x800 then
        return string.char(
            0xC0 + math.floor(cp / 0x40),
            0x80 + (cp % 0x40)
        )
    elseif cp < 0x10000 then
        return string.char(
            0xE0 + math.floor(cp / 0x1000),
            0x80 + (math.floor(cp / 0x40) % 0x40),
            0x80 + (cp % 0x40)
        )
    else
        return string.char(
            0xF0 + math.floor(cp / 0x40000),
            0x80 + (math.floor(cp / 0x1000) % 0x40),
            0x80 + (math.floor(cp / 0x40)   % 0x40),
            0x80 + (cp % 0x40)
        )
    end
end

local function fromCodePoints(cps)
    local out = {}
    for i = 1, #cps do
        out[i] = cpToUtf8(cps[i])
    end
    return table.concat(out)
end

------------------------------------------------------------
--  Punycode helpers
------------------------------------------------------------
local function digitToBasic(d)
    return string.char(d < 26 and (d + 97) or (d - 26 + 48)) -- a-z / 0-9
end

local function basicToDigit(cp)
    if cp >= 48 and cp <= 57  then return cp - 22 end -- '0'-'9' → 26-35
    if cp >= 65 and cp <= 90  then return cp - 65 end -- 'A'-'Z'
    if cp >= 97 and cp <= 122 then return cp - 97 end -- 'a'-'z'
    return base                                         -- invalid
end

local function adapt(delta, numpoints, first)
    delta = first and math.floor(delta / damp) or math.floor(delta / 2)
    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

------------------------------------------------------------
--  Encode / decode a single label
------------------------------------------------------------
local encodeCache, decodeCache = {}, {}

function punycode.encode(label)
    if label == ""        then return "" end
    if encodeCache[label] then return encodeCache[label] end
    if label:find("%.")   then error("punycode.encode: single label expected") end

    label = string.lower(label)           -- IDNA case-insensitive
    local cps  = toCodePoints(label)
    local out  = {}
    local n    = initial_n
    local bias = initial_bias
    local delta, basic = 0, 0

    -- copy ASCII
    for _, cp in ipairs(cps) do
        if cp < 0x80 then
            out[#out + 1] = string.char(cp)
            basic = basic + 1
        end
    end
    if basic > 0 then out[#out + 1] = delim end

    local h = basic
    while h < #cps do
        -- find next smallest code point ≥ n
        local m = 0x7fffffff
        for _, cp in ipairs(cps) do
            if cp >= n and cp < m then m = cp end
        end
        delta = delta + (m - n) * (h + 1)
        n = m

        for _, cp in ipairs(cps) do
            if cp < n then
                delta = delta + 1
            elseif cp == n then
                local q, k = delta, 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
                    out[#out + 1] = digitToBasic(t + (q - t) % (base - t))
                    q = math.floor((q - t) / (base - t))
                    k = k + base
                end
                out[#out + 1] = digitToBasic(q)
                bias  = adapt(delta, h + 1, h == basic)
                delta = 0
                h     = h + 1
            end
        end
        delta = delta + 1
        n     = n + 1
    end

    local result = table.concat(out)
    encodeCache[label] = result
    return result
end

function punycode.decode(label)
    if label == ""        then return "" end
    if decodeCache[label] then return decodeCache[label] end

    local cps, d = {}, (label:find(delim, 1, true) or 0)
    for i = 1, d - 1 do cps[#cps + 1] = label:byte(i) end

    local n, i_val, bias = initial_n, 0, initial_bias
    local pos, len       = (d > 0) and (d + 1) or 1, #label

    while pos <= len do
        local oldi, w, k = i_val, 1, base
        while true do
            if pos > len then error("punycode.decode: bad input") end
            local digit = basicToDigit(label:byte(pos))
            pos   = pos + 1
            i_val = i_val + 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_val - oldi, #cps + 1, oldi == 0)
        n    = n + math.floor(i_val / (#cps + 1))
        i_val = i_val % (#cps + 1)
        table.insert(cps, i_val + 1, n)
        i_val = i_val + 1
    end

    local result = fromCodePoints(cps)
    decodeCache[label] = result
    return result
end

------------------------------------------------------------
--  Domain-level helpers (dot handling)
------------------------------------------------------------
local function stripTrailingDot(s)
    return (s:sub(-1) == '.' and s:sub(1, -2) or s), (s:sub(-1) == '.')
end

function punycode.toASCII(domain)
    if domain == "" then return "" end
    domain, trailing = stripTrailingDot(domain)
    local out = {}
    for label in domain:gmatch("([^%.]+)") do
        if label:find("[^\x00-\x7F]") then
            out[#out + 1] = "xn--" .. punycode.encode(label)
        else
            out[#out + 1] = label
        end
    end
    local res = table.concat(out, ".")
    return trailing and (res .. ".") or res
end

function punycode.toUnicode(domain)
    if domain == "" then return "" end
    domain, trailing = stripTrailingDot(domain)
    local out = {}
    for label in domain:gmatch("([^%.]+)") do
        if label:sub(1, 4):lower() == "xn--" then
            out[#out + 1] = punycode.decode(label:sub(5))
        else
            out[#out + 1] = label
        end
    end
    local res = table.concat(out, ".")
    return trailing and (res .. ".") or res
end

return punycode

Request For Comments. Archival series dedicated to documenting Internet technical specifications, including general contributions from the Internet research and engineering community as well as standards documents (RFC Editor Model, Version 3).

American Standard Code for Information Interchange