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
-- 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