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