ICANNWiki

Module:Punycode: Difference between revisions

← Older edit
MarkWD (talk | contribs)
Bureaucrats, Check users, Interface administrators, Administrators (Semantic MediaWiki), Curators (Semantic MediaWiki), Editors (Semantic MediaWiki), steward, Suppressors, Administrators, Temporary account IP viewers
25,069 edits
// via Wikitext Extension for VSCode
Tag: Reverted
// via Wikitext Extension for VSCode
 
(2 intermediate revisions by the same user not shown)
Line 1: Line 1:
--[[
* Name: Punycode
* Author: Mark W. Datysgeld
* Description: RFC3492 Punycode implementation for IDN support with caching
* Notes: encode/decode for single labels (no dots); toASCII/toUnicode for full domains (handles dots, xn-- prefixes); UTF-8 compatible with mw.ustring fallback; includes caching for performance
]]
local punycode = {}
----------------------------------------------------------------
----------------------------------------------------------------
-- Module:Punycode – pure Lua 5.1 RFC-3492 implementation
-- Caches (persist only for a single page render)
-- Public API
--  punycode.encode(label)       -> "4dbrk0ce"
--  punycode.decode(label)      -> "ישראל"
--  punycode.toASCII(domain)    -> "xn--4dbrk0ce"
--  punycode.toUnicode(domain)  -> "ישראל"
----------------------------------------------------------------
----------------------------------------------------------------
local punycode = {}
local encodeCache, decodeCache = {}, {}


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


----------------------------------------------------------------
----------------------------------------------------------------
-- UTF-8 helpers (pure Lua 5.1)
-- UTF-8 helpers (mw.ustring exists in Scribunto; falls back otherwise)
----------------------------------------------------------------
----------------------------------------------------------------
local us = mw and mw.ustring
local function toCodePoints(s)
local function toCodePoints(s)
    if s == "" then return {} end
    if us then
        local cps, i = {}, 1
        for ch in us.gmatch(s, ".") do
            cps[i] = us.codepoint(ch)
            i = i + 1
        end
        return cps
    end
    -- plain Lua 5.1 fallback (minimal; good enough for Punycode paths)
     local cps, i, len = {}, 1, #s
     local cps, i, len = {}, 1, #s
     while i <= len do
     while i <= len do
         local b1 = s:byte(i)
         local b1 = s:byte(i)
         if b1 < 0x80 then                       -- 1-byte sequence
         if b1 < 0x80 then
             cps[#cps + 1], i = b1, i + 1
             cps[#cps + 1], i = b1, i + 1
         elseif b1 < 0xE0 then                   -- 2-byte sequence
         elseif b1 < 0xE0 then
             local b2 = s:byte(i + 1)
             local b2 = s:byte(i + 1)
             cps[#cps + 1] = (b1 - 0xC0) * 0x40 + (b2 - 0x80)
             cps[#cps + 1] = (b1 - 0xC0) * 0x40 + (b2 - 0x80)
             i = i + 2
             i = i + 2
         elseif b1 < 0xF0 then                   -- 3-byte sequence
         elseif b1 < 0xF0 then
             local b2, b3 = s:byte(i + 1, i + 2)
             local b2, b3 = s:byte(i + 1, i + 2)
             cps[#cps + 1] =
             cps[#cps + 1] =
Line 38: Line 52:
                 + (b3 - 0x80)
                 + (b3 - 0x80)
             i = i + 3
             i = i + 3
         else                                   -- 4-byte sequence
         else
             local b2, b3, b4 = s:byte(i + 1, i + 3)
             local b2, b3, b4 = s:byte(i + 1, i + 3)
             cps[#cps + 1] =
             cps[#cps + 1] =
Line 51: Line 65:
end
end


local function cpToUtf8(cp)
local function fromCodePoints(cps)
     if cp < 0x80  then return string.char(cp) end
     if us then
    if cp < 0x800  then
        local out = {}
         return string.char(
        for i = 1, #cps do out[i] = us.char(cps[i]) end
            0xC0 + math.floor(cp / 0x40),
         return table.concat(out)
            0x80 + (cp % 0x40)
        )
     end
     end
     if cp < 0x10000 then
     local function cp2utf8(cp)
        if cp < 0x80  then return string.char(cp) end
        if cp < 0x800  then
            return string.char(
                0xC0 + math.floor(cp / 0x40),
                0x80 + (cp % 0x40)
            )
        end
        if cp < 0x10000 then
            return string.char(
                0xE0 + math.floor(cp / 0x1000),
                0x80 + (math.floor(cp / 0x40) % 0x40),
                0x80 + (cp % 0x40)
            )
        end
         return string.char(
         return string.char(
             0xE0 + math.floor(cp / 0x1000),
             0xF0 + math.floor(cp / 0x40000),
             0x80 + (math.floor(cp / 0x40) % 0x40),
            0x80 + (math.floor(cp / 0x1000) % 0x40),
             0x80 + (math.floor(cp / 0x40)   % 0x40),
             0x80 + (cp % 0x40)
             0x80 + (cp % 0x40)
         )
         )
     end
     end
    return string.char(
        0xF0 + math.floor(cp / 0x40000),
        0x80 + (math.floor(cp / 0x1000) % 0x40),
        0x80 + (math.floor(cp / 0x40)  % 0x40),
        0x80 + (cp % 0x40)
    )
end
local function fromCodePoints(cps)
     local out = {}
     local out = {}
     for i = 1, #cps do out[i] = cpToUtf8(cps[i]) end
     for i = 1, #cps do out[i] = cp2utf8(cps[i]) end
     return table.concat(out)
     return table.concat(out)
end
end


----------------------------------------------------------------
----------------------------------------------------------------
-- Punycode helpers
-- RFC 3492 helpers
----------------------------------------------------------------
----------------------------------------------------------------
local function digitToBasic(d)
local function digitToBasic(d)
Line 88: Line 106:


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


Line 106: Line 124:


----------------------------------------------------------------
----------------------------------------------------------------
-- Encode / decode a single label
-- Single-label Punycode encode / decode
----------------------------------------------------------------
----------------------------------------------------------------
local encodeCache, decodeCache = {}, {}
local function isASCII(str)
    for i = 1, #str do if str:byte(i) > 127 then return false end end
    return true
end


function punycode.encode(label)
function punycode.encode(label)
     if label == ""         then return "" end
     if not label or label == "" then return "" end
     if encodeCache[label]  then return encodeCache[label] end
     label = label:gsub("%.$", "")              -- strip *trailing* dot
     if label:find("%.")     then error("punycode.encode: single label expected") end
     if label:find("%.") then
        error("punycode.encode: one label at a time (no dots)")
    end
    label = (us and us.lower or string.lower)(label)
    if encodeCache[label] then return encodeCache[label] end


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


     -- copy basic ASCII code points
     -- copy ASCII code points
     for _, cp in ipairs(cps) do
     for _, cp in ipairs(cp_arr) do
         if cp < 0x80 then
         if cp < 128 then
             out[#out + 1] = string.char(cp)
             out[#out + 1] = string.char(cp)
             basic = basic + 1
             basic = basic + 1
         end
         end
     end
     end
    -- delimiter only if mixture of basic + non-basic
     if basic > 0 and basic < #cp_arr then out[#out + 1] = delimiter end
     if basic > 0 and basic < #cps then out[#out + 1] = delim end


     local h = basic
     local h = basic
     while h < #cps do
     while h < #cp_arr do
         local m = 0x7FFFFFFF
         local m = 0x7FFFFFFF
         for _, cp in ipairs(cps) do
         for _, cp in ipairs(cp_arr) do
             if cp >= n and cp < m then m = cp end
             if cp >= n and cp < m then m = cp end
         end
         end
         delta = delta + (m - n) * (h + 1)
         delta = delta + (m - n) * (h + 1)
         n = m
         n = m
 
         for _, cp in ipairs(cp_arr) do
         for _, cp in ipairs(cps) do
             if cp < n then
             if cp < n then
                 delta = delta + 1
                 delta = delta + 1
Line 149: Line 168:
                 while true do
                 while true do
                     local t
                     local t
                     if    k <= bias         then t = tmin
                     if    k <= bias         then t = tmin
                     elseif k >= bias + tmax   then t = tmax
                     elseif k >= bias + tmax then t = tmax
                     else                         t = k - bias end
                     else                         t = k - bias end
                     if q < t then break end
                     if q < t then break end
                     out[#out + 1] = digitToBasic(t + (q - t) % (base - t))
                     out[#out + 1] = digitToBasic(t + (q - t) % (base - t))
                     q = math.floor((q - t) / (base - t))
                     q = math.floor((q - t) / (base - t))
                     k = k + base
                     k = k + base
                 end
                 end
                 out[#out + 1] = digitToBasic(q)
                 out[#out + 1] = digitToBasic(q)
Line 167: Line 186:
     end
     end


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


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


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


Line 185: Line 204:
         local oldi, w, k = i_val, 1, base
         local oldi, w, k = i_val, 1, base
         while true do
         while true do
            if pos > len then error("punycode.decode: bad input") end
             local digit = basicToDigit(label:byte(pos))
             local digit = basicToDigit(label:byte(pos))
             pos   = pos + 1
             pos = pos + 1
             i_val = i_val + digit * w
             i_val = i_val + digit * w
             local t
             local t
             if    k <= bias         then t = tmin
             if    k <= bias         then t = tmin
             elseif k >= bias + tmax   then t = tmax
             elseif k >= bias + tmax then t = tmax
             else                         t = k - bias end
             else                         t = k - bias end
             if digit < t then break end
             if digit < t then break end
             w = w * (base - t)
             w = w * (base - t)
Line 204: Line 222:
     end
     end


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


----------------------------------------------------------------
----------------------------------------------------------------
-- Domain-level helpers
-- Domain-level helpers (the requested FIX)
----------------------------------------------------------------
----------------------------------------------------------------
local function stripTrailingDot(s)
local function splitLabels(domain)
     return (s:sub(-1) == "." and s:sub(1, -2) or s),
     local labels, i = {}, 1
          (s:sub(-1) == ".")
    for label in domain:gmatch("([^%.]+)") do
        labels[i], i = label, i + 1
    end
    return labels
end
end


-- quick ASCII-only test: letters, digits, hyphen
local function stripTrailingDot(s)
local function isPureASCII(label)
     return (s:sub(-1) == '.' and s:sub(1, -2) or s),
     return label:match("^[%a%d%-]+$") ~= nil
          (s:sub(-1) == '.')
end
end


-- Unicode → ASCII/IDNA (strips dot *before* encoding, encodes each label separately)
function punycode.toASCII(domain)
function punycode.toASCII(domain)
     if domain == "" then return "" end
     if not domain or domain == "" then return "" end
     local trailing
     local trailing
     domain, trailing = stripTrailingDot(domain)
     domain, trailing = stripTrailingDot(domain)


     local out = {}
     local ascii = {}
     for label in domain:gmatch("([^%.]+)") do
     for _, lbl in ipairs(splitLabels(domain)) do
         if isPureASCII(label) then
         ascii[#ascii + 1] = isASCII(lbl) and lbl
            out[#out + 1] = label
                        or ("xn--" .. punycode.encode(lbl))
        else
            out[#out + 1] = "xn--" .. punycode.encode(label)
        end
     end
     end
     local res = table.concat(out, ".")
     local res = table.concat(ascii, ".")
     return trailing and (res .. ".") or res
     return trailing and (res .. ".") or res
end
end


-- ASCII/IDNA → Unicode (each label separately)
function punycode.toUnicode(domain)
function punycode.toUnicode(domain)
     if domain == "" then return "" end
     if not domain or domain == "" then return "" end
     local trailing
     local trailing
     domain, trailing = stripTrailingDot(domain)
     domain, trailing = stripTrailingDot(domain)


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


return punycode
return punycode
Retrieved from "https://staging.icannwiki.org/Module:Punycode"