base2base.lua

local _tl_compat; if (tonumber((_VERSION or ''):match('[%d.]*$')) or 0) < 5.3 then local p, m = pcall(require, 'compat53.module'); if p then _tl_compat = m end end; local string = _tl_compat and _tl_compat.string or string; local table = _tl_compat and _tl_compat.table or table; local _tl_table_unpack = unpack or table.unpack; local fmt = string.format



local function next_power(p, base_from, base_to)
   local r = {}
   local j, t = 0, 0
   for i = 1, #p do
      j, t = i, p[i] * base_from
      while true do
         t = (r[j] or 0) + t
         r[j] = t % base_to
         t = t // base_to
         if t == 0 then break end
         j = j + 1
      end
   end
   return r
end


local function add_times(a, n, b, base)
   local j, t = 0, 0
   for i = 1, #b do
      j, t = i, n * (b[i] or 0)
      while true do
         t = (a[j] or 0) + t
         a[j] = t % base
         t = t // base
         if t == 0 then break end
         j = j + 1
      end
   end
end












local function s_to_t(self, s)
   local r, l = {}, #s
   for i = 1, l do r[i] = self.r_alpha_from[s:byte(l - i + 1)] end
   return r
end

local function t_to_s(self, t)
   local r, l = {}, #t
   for i = l, 1, -1 do r[l - i + 1] = self.alpha_to:byte(t[i] + 1) end
   return string.char(_tl_table_unpack(r))
end

local function get_power(self, n)
   return self.power[n] or next_power(
   get_power(self, n - 1), self.base_from, self.base_to)

end

local function base_convert(self, t)
   local r = {}
   for i = 1, #t do
      add_times(r, t[i], get_power(self, i - 1), self.base_to)
   end
   return r
end

local function convert(self, s)
   return t_to_s(self, base_convert(self, s_to_t(self, s)))
end

local function validate(self, s)
   for i = 1, #s do
      if not self.r_alpha_from[s:byte(i)] then
         return false
      end
   end
   return true
end

local converter_mt = {
   __index = { convert = convert, validate = validate },
   __call = convert,
}

local function new_converter(alpha_from, alpha_to)
   local self = {
      alpha_to = alpha_to,
      base_from = #alpha_from,
      base_to = #alpha_to,
   }
   local v = {}
   for i = 1, #alpha_from do v[alpha_from:byte(i)] = i - 1 end
   self.r_alpha_from = v
   self.power = { [0] = { 1 } }
   return setmetatable(self, converter_mt)
end

local letters = "abcdefghijklmnopqrstuvwxyz"
local figures = "0123456789"
local ascii = {}; for i = 1, 256 do ascii[i] = i - 1 end
local ALPHABET_B64 = letters:upper() .. letters .. figures .. "+/"
local ALPHABET_B256 = string.char(_tl_table_unpack(ascii))
local ALPHABET_B64URL = ALPHABET_B64:sub(1, 62) .. "-_"

local function _byte_to_hex(x) return fmt("%02x", x:byte()) end
local function to_hex(s) return (s:gsub("(.)", _byte_to_hex)) end
local function _byte_from_hex(x) return string.char(tonumber(x, 16)) end
local function from_hex(s) return (s:gsub("(..)", _byte_from_hex)) end

local function is_hex(s) return not not s:match("^[0-9a-f]*$") end

local function _from_b64(alphabet)
   local c = new_converter(alphabet, ALPHABET_B256)
   return function(s)
      local n = 0
      if s:sub(-2, -1) == "==" then
         n = 2
         s = s:sub(1, -3) .. "00"
      elseif s:sub(-1) == "=" then
         n = 1
         s = s:sub(1, -2) .. "0"
      end
      return c(s):sub(1, -(n + 1))
   end
end

local function _to_b64(alphabet)
   local c = new_converter(ALPHABET_B256, alphabet)
   return function(s)
      local l, n = #s, 0
      if l % 3 == 1 then
         n = 2
         s = s .. "\0\0"
      elseif l % 3 == 2 then
         n = 1
         s = s .. "\0"
      end
      local r = c(s)
      if n == 2 then
         return r:sub(1, -3) .. "=="
      elseif n == 1 then
         return r:sub(1, -2) .. "="
      else return r end
   end
end


local ALPHABET_B62 = figures .. letters .. letters:upper()
local ALPHABET_B36 = ALPHABET_B62:sub(1, 36)
local from_b36 = new_converter(ALPHABET_B36, ALPHABET_B256)

local M = {
   converter = new_converter,
   ALPHABET_B36 = ALPHABET_B36,
   ALPHABET_B62 = ALPHABET_B62,
   ALPHABET_B64 = ALPHABET_B64,
   ALPHABET_B64URL = ALPHABET_B64URL,
   ALPHABET_B256 = ALPHABET_B256,
   to_hex = to_hex, from_hex = from_hex, is_hex = is_hex,
   to_b64 = _to_b64(ALPHABET_B64),
   from_b64 = _from_b64(ALPHABET_B64),
   to_b64url = _to_b64(ALPHABET_B64URL),
   from_b64url = _from_b64(ALPHABET_B64URL),
   to_b36 = new_converter(ALPHABET_B256, ALPHABET_B36),
   from_b36 = from_b36,
   is_b36 = function(s) return from_b36:validate(s) end,
}

return M