Module:Punycode

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

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

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 libraries)
----------------------------------------------------------------
local function toCodePoints(s)
    local cps, i, len = {}, 1, #s
    while i <= len do
        local b1 = s:byte(i)
        if b1 < 0x80 then                        -- 1-byte
            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 buf = {}
    for i = 1, #cps do
        buf[i] = cpToUtf8(cps[i])
    end
    return table.concat(buf)
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(byte)
    if byte >= 48 and byte <= 57  then return byte - 22 end  -- '0'-'9' → 26-35
    if byte >= 65 and byte <= 90  then return byte - 65 end  -- 'A'-'Z'
    if byte >= 97 and byte <= 122 then return byte - 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 is case-insensitive
    local cps  = toCodePoints(label)
    local out  = {}
    local n, bias = initial_n, initial_bias
    local delta, basic = 0, 0

    -- copy ASCII code points
    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
        -- smallest cp ≥ 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 (handle dots; call encode/decode per label)
----------------------------------------------------------------
local function stripTrailingDot(s)
    return (s:sub(-1) == '.' and s:sub(1, -2) or s), (s:sub(-1) == '.')
end

-- Unicode → ASCII/IDNA
function punycode.toASCII(domain)
    if domain == "" then return "" end
    local trailing
    domain, trailing = stripTrailingDot(domain)

    local out = {}
    for label in domain:gmatch("([^%.]+)") do
        -- any non-ASCII byte (128–255)?
        if label:find("[\128-\255]") 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

-- ASCII/IDNA → Unicode
function punycode.toUnicode(domain)
    if domain == "" then return "" end
    local trailing
    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).

Application Programming Interface is a set of rules or protocols that enables software applications to communicate with each other to exchange data, features and functionality (IBM).

American Standard Code for Information Interchange