跳转到内容

模組:EncoderUtil

添加链接
本页使用了标题或全文手工转换
被永久保护的模块
维基百科，自由的百科全书

local p={}
local lib_arg={}
local yaml = require("Module:EncoderUtil/yaml")
local function _safejson_number(obj, flat_out)
	if type(obj) == type(0) then
  		if not not tostring(obj):lower():find('inf') then return tostring(obj) end
    	if not not tostring(obj):lower():find('nan') then return flat_out and tostring(obj) or '\127null\127'end
		return flat_out and tostring(obj) or obj
	else
		return obj
	end
end
local q={}
function q._safejson_clone(obj, deep)
	if type(obj) == type({'table'}) then
		local new_table = {}
		for key,val in pairs(obj) do
			if type(val) == type({'table'}) then
				if deep < 10 then
					new_table[key] = q._safejson_clone(val, deep + 1)
				else
					if xpcall(function()new_table[key] = mw.text.jsonDecode(mw.text.jsonEncode(val))end,function()end) then else new_table[key] = key end
				end
			elseif type(val) == type(function()end) then new_table[key] = key
			elseif type(val) == type(nil) then 
			elseif type(val) == type(0) then new_table[key] = _safejson_number(val)
			else new_table[key] = mw.clone(val) end
		end
		return new_table
	else
		return obj
	end
end
local function _check_table(obj)
	if type(obj) == type({'table'}) then
		local new_table = {}
		for key,val in pairs(obj) do
			if type(val) == type({'table'}) then new_table[key] = q._safejson_clone(val,0)
			elseif type(val) == type(function()end) then new_table[key] = key
			elseif type(val) == type(nil) then new_table[key] = '\127null\127'
			elseif type(val) == type(0) then new_table[key] = _safejson_number(val)
			else new_table[key] = mw.clone(val) end
		end
		return new_table
	else
		return obj
	end
end
local function _jsonEncode(obj)
	local result = ''
	if type(obj) == type({'table'}) then
		result = mw.text.jsonEncode(_check_table(obj))
	elseif type(obj) == type(function()end) then result = 'function'
	elseif type(obj) == type(nil) then result = 'null'
	elseif type(obj) == type(0) then 
		local can_encode = false
		can_encode,result = xpcall(function()return mw.text.jsonEncode(obj)end,function()end)
		if can_encode==false then result=_safejson_number(obj,true)end
	else result = mw.text.jsonEncode(obj) end
	return result
end
function p.yamlDecode(str)
	local input_str = str
	if type(str) == type({"table"}) then
		input_str = (str.args or {})[1] or str[1] or ''
	elseif type(str) ~= type("string") then
		input_str = tostring(str)
	end
	local result = yaml.eval(input_str)
	if str == mw.getCurrentFrame() or type(str.getParent)==type(function()end) then
		return yaml.to_string(result) or ''
	end
	return result
end
function p.yaml2json(str)
	local input_str = str
	if type(str) == type({"table"}) then
		input_str = (str.args or {})[1] or str[1] or ''
	elseif type(str) ~= type("string") then
		input_str = tostring(str)
	end
	local result = yaml.eval(input_str)
	return _jsonEncode(result)
end
function p._get_string_length( str )
	if type(str)==type("str")and str~='' then
		return #str
	elseif type(str)==type(nil)or str=='' then return 0
	elseif type(str)==type(0) then return #(''..str)
	else return #str
	end
	return 0
end

-- Return the binary representation of the number x with the width of `digits`.
function p._toBinary(x,digits)
	  local s=string.format("%o",x)
	  local a={["0"]="000",["1"]="001", ["2"]="010",["3"]="011",
			   ["4"]="100",["5"]="101", ["6"]="110",["7"]="111"}
	  s=string.gsub(s,"(.)",function (d) return a[d] end)
	  -- remove leading 0s
	  s = string.gsub(s,"^0*(.*)$","%1")
	  local fmtstring = string.format("%%%ds",digits)
	  local ret = string.format(fmtstring,s)
	  return string.gsub(ret," ","0")
end

function p._binaryEncode(str)
	local s = tostring(str)
	local bin = ''
	for i=1,s:len() do bin = bin .. p._toBinary(s:byte(i, i), 8) end
	return bin
end

function p._hexadecimalEncode(str)
	local s = tostring(str)
	local hex = ''
	for i=1,s:len() do hex = hex .. ("%%%ds"):format(2):format(("%x"):format(s:byte(i, i))):gsub(' ','0')end
	return hex
end

function p._binaryDecode(str)
	local s, result = tostring(str), ''
	local s_len = s:len()
	local lose = s_len % 8
	if lose > 0 then lose = 8 - lose end
	s_len = (s_len + lose) / 8
	s = ('0'):rep(lose)..s
	for i=0,s_len-1 do result = result .. string.char(tonumber(s:sub(i*8+1, i*8+8),2)) end
	return result
end

function p._hexadecimalDecode(str)
	local s, result = tostring(str), ''
	local s_len = s:len()
	local lose = s_len % 2
	if lose > 0 then lose = 2 - lose end
	s_len = (s_len + lose) / 2
	s = ('0'):rep(lose)..s
	for i=0,s_len-1 do result = result .. string.char(tonumber(s:sub(i*2+1, i*2+2),16)) end
	return result
end

function p.binaryEncode(str)
	local input_str = str
	if type(str) == type({"table"}) then
		input_str = (str.args or {})[1] or str[1] or ''
	elseif type(str) ~= type("string") then
		input_str = tostring(str)
	end
	return p._binaryEncode(input_str)
end

function p.hexadecimalEncode(str)
	local input_str = str
	if type(str) == type({"table"}) then
		input_str = (str.args or {})[1] or str[1] or ''
	elseif type(str) ~= type("string") then
		input_str = tostring(str)
	end
	return p._hexadecimalEncode(input_str)
end

function p.binaryDecode(str)
	local input_str = str
	if type(str) == type({"table"}) then
		input_str = (str.args or {})[1] or str[1] or ''
	elseif type(str) ~= type("string") then
		input_str = tostring(str)
	end
	return p._binaryDecode(input_str)
end

function p.hexadecimalDecode(str)
	local input_str = str
	if type(str) == type({"table"}) then
		input_str = (str.args or {})[1] or str[1] or ''
	elseif type(str) ~= type("string") then
		input_str = tostring(str)
	end
	return p._hexadecimalDecode(input_str)
end

function p._get_bytes( str,... )
		if #{...}<1 then return 0 end
		local result={}
		
		if type(str)==type("str")and str~='' then
			return str:byte(...)
		elseif type(str)==type(nil)or type(str)==type(0)or str=='' then 
			for i=1,#{...}do result[#result+1]=0 end
		elseif #{...}>2 or #{...}==1 then
			for key,value in pairs{...}do result[#result+1]=str[tonumber(value)or-1] end
		else
			local start,end_=unpack{...}
			for i=start,end_,(end_>=start and 1 or-1)do result[#result+1]=str[i] end
		end
		for i=1,#result do
			result[i] = (tonumber(result[i])or 0)%256
		end
		if #result > 0 then return unpack(result) end
		return 0
end

local function init_qrcode_library()
	local license =[[
	 The qrcode library is licensed under the 3-clause BSD license (aka "new BSD")
	 Copyright (c) 2012-2020, Patrick Gundlach and contributors, see https://github.com/speedata/luaqrcode , All rights reserved.

	 Redistribution and use in source and binary forms, with or without
	 modification, are permitted provided that the following conditions are met:
		 * Redistributions of source code must retain the above copyright
		   notice, this list of conditions and the following disclaimer.
		 * Redistributions in binary form must reproduce the above copyright
		   notice, this list of conditions and the following disclaimer in the
		   documentation and/or other materials provided with the distribution.
		 * Neither the name of the <organization> nor the
		   names of its contributors may be used to endorse or promote products
		   derived from this software without specific prior written permission.

	 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
	 ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
	 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
	 DISCLAIMED. IN NO EVENT SHALL <COPYRIGHT HOLDER> BE LIABLE FOR ANY
	 DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
	 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
	 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
	 ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
	 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
	 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
	]]
	-- To calculate xor we need to do that bitwise. This helper table speeds up the num-to-bit
	-- part a bit (no pun intended)
	local cclxvi = {[0] = {0,0,0,0,0,0,0,0}, {1,0,0,0,0,0,0,0}, {0,1,0,0,0,0,0,0}, {1,1,0,0,0,0,0,0},
	{0,0,1,0,0,0,0,0}, {1,0,1,0,0,0,0,0}, {0,1,1,0,0,0,0,0}, {1,1,1,0,0,0,0,0},
	{0,0,0,1,0,0,0,0}, {1,0,0,1,0,0,0,0}, {0,1,0,1,0,0,0,0}, {1,1,0,1,0,0,0,0},
	{0,0,1,1,0,0,0,0}, {1,0,1,1,0,0,0,0}, {0,1,1,1,0,0,0,0}, {1,1,1,1,0,0,0,0},
	{0,0,0,0,1,0,0,0}, {1,0,0,0,1,0,0,0}, {0,1,0,0,1,0,0,0}, {1,1,0,0,1,0,0,0},
	{0,0,1,0,1,0,0,0}, {1,0,1,0,1,0,0,0}, {0,1,1,0,1,0,0,0}, {1,1,1,0,1,0,0,0},
	{0,0,0,1,1,0,0,0}, {1,0,0,1,1,0,0,0}, {0,1,0,1,1,0,0,0}, {1,1,0,1,1,0,0,0},
	{0,0,1,1,1,0,0,0}, {1,0,1,1,1,0,0,0}, {0,1,1,1,1,0,0,0}, {1,1,1,1,1,0,0,0},
	{0,0,0,0,0,1,0,0}, {1,0,0,0,0,1,0,0}, {0,1,0,0,0,1,0,0}, {1,1,0,0,0,1,0,0},
	{0,0,1,0,0,1,0,0}, {1,0,1,0,0,1,0,0}, {0,1,1,0,0,1,0,0}, {1,1,1,0,0,1,0,0},
	{0,0,0,1,0,1,0,0}, {1,0,0,1,0,1,0,0}, {0,1,0,1,0,1,0,0}, {1,1,0,1,0,1,0,0},
	{0,0,1,1,0,1,0,0}, {1,0,1,1,0,1,0,0}, {0,1,1,1,0,1,0,0}, {1,1,1,1,0,1,0,0},
	{0,0,0,0,1,1,0,0}, {1,0,0,0,1,1,0,0}, {0,1,0,0,1,1,0,0}, {1,1,0,0,1,1,0,0},
	{0,0,1,0,1,1,0,0}, {1,0,1,0,1,1,0,0}, {0,1,1,0,1,1,0,0}, {1,1,1,0,1,1,0,0},
	{0,0,0,1,1,1,0,0}, {1,0,0,1,1,1,0,0}, {0,1,0,1,1,1,0,0}, {1,1,0,1,1,1,0,0},
	{0,0,1,1,1,1,0,0}, {1,0,1,1,1,1,0,0}, {0,1,1,1,1,1,0,0}, {1,1,1,1,1,1,0,0},
	{0,0,0,0,0,0,1,0}, {1,0,0,0,0,0,1,0}, {0,1,0,0,0,0,1,0}, {1,1,0,0,0,0,1,0},
	{0,0,1,0,0,0,1,0}, {1,0,1,0,0,0,1,0}, {0,1,1,0,0,0,1,0}, {1,1,1,0,0,0,1,0},
	{0,0,0,1,0,0,1,0}, {1,0,0,1,0,0,1,0}, {0,1,0,1,0,0,1,0}, {1,1,0,1,0,0,1,0},
	{0,0,1,1,0,0,1,0}, {1,0,1,1,0,0,1,0}, {0,1,1,1,0,0,1,0}, {1,1,1,1,0,0,1,0},
	{0,0,0,0,1,0,1,0}, {1,0,0,0,1,0,1,0}, {0,1,0,0,1,0,1,0}, {1,1,0,0,1,0,1,0},
	{0,0,1,0,1,0,1,0}, {1,0,1,0,1,0,1,0}, {0,1,1,0,1,0,1,0}, {1,1,1,0,1,0,1,0},
	{0,0,0,1,1,0,1,0}, {1,0,0,1,1,0,1,0}, {0,1,0,1,1,0,1,0}, {1,1,0,1,1,0,1,0},
	{0,0,1,1,1,0,1,0}, {1,0,1,1,1,0,1,0}, {0,1,1,1,1,0,1,0}, {1,1,1,1,1,0,1,0},
	{0,0,0,0,0,1,1,0}, {1,0,0,0,0,1,1,0}, {0,1,0,0,0,1,1,0}, {1,1,0,0,0,1,1,0},
	{0,0,1,0,0,1,1,0}, {1,0,1,0,0,1,1,0}, {0,1,1,0,0,1,1,0}, {1,1,1,0,0,1,1,0},
	{0,0,0,1,0,1,1,0}, {1,0,0,1,0,1,1,0}, {0,1,0,1,0,1,1,0}, {1,1,0,1,0,1,1,0},
	{0,0,1,1,0,1,1,0}, {1,0,1,1,0,1,1,0}, {0,1,1,1,0,1,1,0}, {1,1,1,1,0,1,1,0},
	{0,0,0,0,1,1,1,0}, {1,0,0,0,1,1,1,0}, {0,1,0,0,1,1,1,0}, {1,1,0,0,1,1,1,0},
	{0,0,1,0,1,1,1,0}, {1,0,1,0,1,1,1,0}, {0,1,1,0,1,1,1,0}, {1,1,1,0,1,1,1,0},
	{0,0,0,1,1,1,1,0}, {1,0,0,1,1,1,1,0}, {0,1,0,1,1,1,1,0}, {1,1,0,1,1,1,1,0},
	{0,0,1,1,1,1,1,0}, {1,0,1,1,1,1,1,0}, {0,1,1,1,1,1,1,0}, {1,1,1,1,1,1,1,0},
	{0,0,0,0,0,0,0,1}, {1,0,0,0,0,0,0,1}, {0,1,0,0,0,0,0,1}, {1,1,0,0,0,0,0,1},
	{0,0,1,0,0,0,0,1}, {1,0,1,0,0,0,0,1}, {0,1,1,0,0,0,0,1}, {1,1,1,0,0,0,0,1},
	{0,0,0,1,0,0,0,1}, {1,0,0,1,0,0,0,1}, {0,1,0,1,0,0,0,1}, {1,1,0,1,0,0,0,1},
	{0,0,1,1,0,0,0,1}, {1,0,1,1,0,0,0,1}, {0,1,1,1,0,0,0,1}, {1,1,1,1,0,0,0,1},
	{0,0,0,0,1,0,0,1}, {1,0,0,0,1,0,0,1}, {0,1,0,0,1,0,0,1}, {1,1,0,0,1,0,0,1},
	{0,0,1,0,1,0,0,1}, {1,0,1,0,1,0,0,1}, {0,1,1,0,1,0,0,1}, {1,1,1,0,1,0,0,1},
	{0,0,0,1,1,0,0,1}, {1,0,0,1,1,0,0,1}, {0,1,0,1,1,0,0,1}, {1,1,0,1,1,0,0,1},
	{0,0,1,1,1,0,0,1}, {1,0,1,1,1,0,0,1}, {0,1,1,1,1,0,0,1}, {1,1,1,1,1,0,0,1},
	{0,0,0,0,0,1,0,1}, {1,0,0,0,0,1,0,1}, {0,1,0,0,0,1,0,1}, {1,1,0,0,0,1,0,1},
	{0,0,1,0,0,1,0,1}, {1,0,1,0,0,1,0,1}, {0,1,1,0,0,1,0,1}, {1,1,1,0,0,1,0,1},
	{0,0,0,1,0,1,0,1}, {1,0,0,1,0,1,0,1}, {0,1,0,1,0,1,0,1}, {1,1,0,1,0,1,0,1},
	{0,0,1,1,0,1,0,1}, {1,0,1,1,0,1,0,1}, {0,1,1,1,0,1,0,1}, {1,1,1,1,0,1,0,1},
	{0,0,0,0,1,1,0,1}, {1,0,0,0,1,1,0,1}, {0,1,0,0,1,1,0,1}, {1,1,0,0,1,1,0,1},
	{0,0,1,0,1,1,0,1}, {1,0,1,0,1,1,0,1}, {0,1,1,0,1,1,0,1}, {1,1,1,0,1,1,0,1},
	{0,0,0,1,1,1,0,1}, {1,0,0,1,1,1,0,1}, {0,1,0,1,1,1,0,1}, {1,1,0,1,1,1,0,1},
	{0,0,1,1,1,1,0,1}, {1,0,1,1,1,1,0,1}, {0,1,1,1,1,1,0,1}, {1,1,1,1,1,1,0,1},
	{0,0,0,0,0,0,1,1}, {1,0,0,0,0,0,1,1}, {0,1,0,0,0,0,1,1}, {1,1,0,0,0,0,1,1},
	{0,0,1,0,0,0,1,1}, {1,0,1,0,0,0,1,1}, {0,1,1,0,0,0,1,1}, {1,1,1,0,0,0,1,1},
	{0,0,0,1,0,0,1,1}, {1,0,0,1,0,0,1,1}, {0,1,0,1,0,0,1,1}, {1,1,0,1,0,0,1,1},
	{0,0,1,1,0,0,1,1}, {1,0,1,1,0,0,1,1}, {0,1,1,1,0,0,1,1}, {1,1,1,1,0,0,1,1},
	{0,0,0,0,1,0,1,1}, {1,0,0,0,1,0,1,1}, {0,1,0,0,1,0,1,1}, {1,1,0,0,1,0,1,1},
	{0,0,1,0,1,0,1,1}, {1,0,1,0,1,0,1,1}, {0,1,1,0,1,0,1,1}, {1,1,1,0,1,0,1,1},
	{0,0,0,1,1,0,1,1}, {1,0,0,1,1,0,1,1}, {0,1,0,1,1,0,1,1}, {1,1,0,1,1,0,1,1},
	{0,0,1,1,1,0,1,1}, {1,0,1,1,1,0,1,1}, {0,1,1,1,1,0,1,1}, {1,1,1,1,1,0,1,1},
	{0,0,0,0,0,1,1,1}, {1,0,0,0,0,1,1,1}, {0,1,0,0,0,1,1,1}, {1,1,0,0,0,1,1,1},
	{0,0,1,0,0,1,1,1}, {1,0,1,0,0,1,1,1}, {0,1,1,0,0,1,1,1}, {1,1,1,0,0,1,1,1},
	{0,0,0,1,0,1,1,1}, {1,0,0,1,0,1,1,1}, {0,1,0,1,0,1,1,1}, {1,1,0,1,0,1,1,1},
	{0,0,1,1,0,1,1,1}, {1,0,1,1,0,1,1,1}, {0,1,1,1,0,1,1,1}, {1,1,1,1,0,1,1,1},
	{0,0,0,0,1,1,1,1}, {1,0,0,0,1,1,1,1}, {0,1,0,0,1,1,1,1}, {1,1,0,0,1,1,1,1},
	{0,0,1,0,1,1,1,1}, {1,0,1,0,1,1,1,1}, {0,1,1,0,1,1,1,1}, {1,1,1,0,1,1,1,1},
	{0,0,0,1,1,1,1,1}, {1,0,0,1,1,1,1,1}, {0,1,0,1,1,1,1,1}, {1,1,0,1,1,1,1,1},
	{0,0,1,1,1,1,1,1}, {1,0,1,1,1,1,1,1}, {0,1,1,1,1,1,1,1}, {1,1,1,1,1,1,1,1}}

	-- Return a number that is the result of interpreting the table tbl (msb first)
	local function tbl_to_number(tbl)
		local n, rslt, power = #tbl, 0, 1
		for i = 1, n do
			rslt = rslt + tbl[i]*power
			power = power*2
		end
		return rslt
	end

	-- Calculate bitwise xor of bytes m and n. 0 <= m,n <= 256.
	local function bit_xor(m, n)
		local tbl_m = cclxvi[m]
		local tbl_n = cclxvi[n]
		local tbl = {}
		for i = 1, 8 do
			if(tbl_m[i] ~= tbl_n[i]) then
				tbl[i] = 1
			else
				tbl[i] = 0
			end
		end
		return tbl_to_number(tbl)
	end

	local fill_matrix_position = function(matrix,bitstring,x,y) matrix[x][y] = (bitstring == "1") and 2 or -2 end

	-- Return the mode for the given string `str`.
	-- See table 2 of the spec. We only support mode 1, 2 and 4.
	-- That is: numeric, alaphnumeric and binary.
	local function get_mode( str )
		local mode
		if type(str)==type("str")and str~='' then
			if string.match(str,"^[0-9]+$") then
				return 1
			elseif string.match(str,"^[0-9A-Z $%%*./:+-]+$") then
				return 2
			else
				return 4
			end
		elseif type(str)==type(nil)or str=='' then return 4
		elseif type(str)==type(0) then return 1
		else return 4
		end
		assert(false,"never reached")
		return nil
	end


	-- The capacity (number of codewords) of each version (1-40) for error correction levels 1-4 (LMQH).
	-- The higher the ec level, the lower the capacity of the version. Taken from spec, tables 7-11.
	local capacity = {
	  {  19,   16,   13,	9},{  34,   28,   22,   16},{  55,   44,   34,   26},{  80,   64,   48,   36},
	  { 108,   86,   62,   46},{ 136,  108,   76,   60},{ 156,  124,   88,   66},{ 194,  154,  110,   86},
	  { 232,  182,  132,  100},{ 274,  216,  154,  122},{ 324,  254,  180,  140},{ 370,  290,  206,  158},
	  { 428,  334,  244,  180},{ 461,  365,  261,  197},{ 523,  415,  295,  223},{ 589,  453,  325,  253},
	  { 647,  507,  367,  283},{ 721,  563,  397,  313},{ 795,  627,  445,  341},{ 861,  669,  485,  385},
	  { 932,  714,  512,  406},{1006,  782,  568,  442},{1094,  860,  614,  464},{1174,  914,  664,  514},
	  {1276, 1000,  718,  538},{1370, 1062,  754,  596},{1468, 1128,  808,  628},{1531, 1193,  871,  661},
	  {1631, 1267,  911,  701},{1735, 1373,  985,  745},{1843, 1455, 1033,  793},{1955, 1541, 1115,  845},
	  {2071, 1631, 1171,  901},{2191, 1725, 1231,  961},{2306, 1812, 1286,  986},{2434, 1914, 1354, 1054},
	  {2566, 1992, 1426, 1096},{2702, 2102, 1502, 1142},{2812, 2216, 1582, 1222},{2956, 2334, 1666, 1276}}
	  
	-- mode = 1,2,4,8
	local function get_version_eclevel(len,mode,requested_ec_level)
		local local_mode = mode
		if mode == 4 then
			local_mode = 3
		elseif mode == 8 then
			local_mode = 4
		end
		assert( local_mode <= 4 )

		local bytes, bits, digits, modebits, c
		local tab = { {10,9,8,8},{12,11,16,10},{14,13,16,12} }
		local minversion = 40
		local maxec_level = requested_ec_level or 1
		local min,max = 1, 4
		if requested_ec_level and requested_ec_level >= 1 and requested_ec_level <= 4 then
			min = requested_ec_level
			max = requested_ec_level
		end
		for ec_level=min,max do
			for version=1,#capacity do
				bits = capacity[version][ec_level] * 8
				bits = bits - 4 -- the mode indicator
				if version < 10 then
					digits = tab[1][local_mode]
				elseif version < 27 then
					digits = tab[2][local_mode]
				elseif version <= 40 then
					digits = tab[3][local_mode]
				end
				modebits = bits - digits
				if local_mode == 1 then -- numeric
					c = math.floor(modebits * 3 / 10)
				elseif local_mode == 2 then -- alphanumeric
					c = math.floor(modebits * 2 / 11)
				elseif local_mode == 3 then -- binary
					c = math.floor(modebits * 1 / 8)
				else
					c = math.floor(modebits * 1 / 13)
				end
				if c >= len then
					if version <= minversion then
						minversion = version
						maxec_level = ec_level
					end
					break
				end
			end
		end
		return minversion, maxec_level
	end

	-- Return a bit string of 0s and 1s that includes the length of the code string.
	-- The modes are numeric = 1, alphanumeric = 2, binary = 4, and japanese = 8
	local function get_length(str,version,mode)
		local i = mode
		if mode == 4 then
			i = 3
		elseif mode == 8 then
			i = 4
		end
		assert( i <= 4 )
		local tab = { {10,9,8,8},{12,11,16,10},{14,13,16,12} }
		local digits
		if version < 10 then
			digits = tab[1][i]
		elseif version < 27 then
			digits = tab[2][i]
		elseif version <= 40 then
			digits = tab[3][i]
		else
			assert(false, "get_length, version > 40 not supported")
		end
		local len = p._toBinary(p._get_string_length(str),digits)
		return len
	end

	local function get_version_eclevel_mode_bistringlength(str,requested_ec_level,mode)
		local local_mode
		if mode then
			assert(false,"not implemented")
			-- check if the mode is OK for the string
			local_mode = mode
		else
			local_mode = get_mode(str)
		end
		local version, ec_level
		version, ec_level = get_version_eclevel(p._get_string_length(str),local_mode,requested_ec_level)
		local length_string = get_length(str,version,local_mode)
		return version,ec_level,p._toBinary((type(str)==type(nil))and 0 or local_mode,4),local_mode,length_string
	end

	local asciitbl = {
			-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  -- 0x01-0x0f
		-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,  -- 0x10-0x1f
		36, -1, -1, -1, 37, 38, -1, -1, -1, -1, 39, 40, -1, 41, 42, 43,  -- 0x20-0x2f
		 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 44, -1, -1, -1, -1, -1,  -- 0x30-0x3f
		-1, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,  -- 0x40-0x4f
		25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, -1, -1, -1, -1, -1,  -- 0x50-0x5f
	  }

	-- Return a binary representation of the numeric string `str`. This must contain only digits 0-9.
	local function encode_string_numeric(str)
		local bitstring = ""
		local int
		string.gsub(str,"..?.?",function(a)
			int = tonumber(a)
			if #a == 3 then
				bitstring = bitstring .. p._toBinary(int,10)
			elseif #a == 2 then
				bitstring = bitstring .. p._toBinary(int,7)
			else
				bitstring = bitstring .. p._toBinary(int,4)
			end
		end)
		return bitstring
	end

	-- Return a binary representation of the alphanumeric string `str`. This must contain only
	-- digits 0-9, uppercase letters A-Z, space and the following chars: $%*./:+-.
	local function encode_string_ascii(str)
		local bitstring = ""
		local int
		local b1, b2
		string.gsub(str,"..?",function(a)
			if #a == 2 then
				b1 = asciitbl[string.byte(string.sub(a,1,1))]
				b2 = asciitbl[string.byte(string.sub(a,2,2))]
				int = b1 * 45 + b2
				bitstring = bitstring .. p._toBinary(int,11)
			else
				int = asciitbl[string.byte(a)]
				bitstring = bitstring .. p._toBinary(int,6)
			end
		  end)
		return bitstring
	end

	-- Return a bitstring representing string str in binary mode.
	-- We don't handle UTF-8 in any special way because we assume the
	-- scanner recognizes UTF-8 and displays it correctly.
	local function encode_string_binary(str)
		local ret = {}
		if type(str)==type("str")and str~='' then
			string.gsub(str,".",function(x)
				ret[#ret + 1] = p._toBinary(string.byte(x),8)
			end)
		elseif type(str)==type(nil)or str==''then
			return ''
		else
			for it=1,#str do
				assert((type(str[it])==type('0'))or(type(str[it])==type(0)),"data not support")
				local bytedata = tonumber(str[it])or 0
				assert(bytedata<=255 and bytedata>=0,"data overflow")
				bytedata=bytedata%255
				ret[#ret + 1] = p._toBinary(bytedata,8)
			end
		end
		return table.concat(ret)
	end

	-- Return a bitstring representing string str in the given mode.
	local function encode_data(str,mode)
		if mode == 1 then
			return encode_string_numeric(str)
		elseif mode == 2 then
			return encode_string_ascii(str)
		elseif mode == 4 then
			return encode_string_binary(str)
		else
			assert(false,"not implemented yet")
		end
	end

	-- Encoding the codeword is not enough. We need to make sure that
	-- the length of the binary string is equal to the number of codewords of the version.
	local function add_pad_data(version,ec_level,data)
		local count_to_pad, missing_digits
		local cpty = capacity[version][ec_level] * 8
		count_to_pad = math.min(4,cpty - #data)
		if count_to_pad > 0 then
			data = data .. string.rep("0",count_to_pad)
		end
		if math.fmod(#data,8) ~= 0 then
			missing_digits = 8 - math.fmod(#data,8)
			data = data .. string.rep("0",missing_digits)
		end
		assert(math.fmod(#data,8) == 0)
		-- add "11101100" and "00010001" until enough data
		while #data < cpty do
			data = data .. "11101100"
			if #data < cpty then
				data = data .. "00010001"
			end
		end
		return data
	end

	-- https://codyplanteen.com/assets/rs/gf256_log_antilog.pdf
	local alpha_int = {
		[0] = 1,
		  2,   4,   8,  16,  32,  64, 128,  29,  58, 116, 232, 205, 135,  19,  38,  76,
		152,  45,  90, 180, 117, 234, 201, 143,   3,   6,  12,  24,  48,  96, 192, 157,
		 39,  78, 156,  37,  74, 148,  53, 106, 212, 181, 119, 238, 193, 159,  35,  70,
		140,   5,  10,  20,  40,  80, 160,  93, 186, 105, 210, 185, 111, 222, 161,  95,
		190,  97, 194, 153,  47,  94, 188, 101, 202, 137,  15,  30,  60, 120, 240, 253,
		231, 211, 187, 107, 214, 177, 127, 254, 225, 223, 163,  91, 182, 113, 226, 217,
		175,  67, 134,  17,  34,  68, 136,  13,  26,  52, 104, 208, 189, 103, 206, 129,
		 31,  62, 124, 248, 237, 199, 147,  59, 118, 236, 197, 151,  51, 102, 204, 133,
		 23,  46,  92, 184, 109, 218, 169,  79, 158,  33,  66, 132,  21,  42,  84, 168,
		 77, 154,  41,  82, 164,  85, 170,  73, 146,  57, 114, 228, 213, 183, 115, 230,
		209, 191,  99, 198, 145,  63, 126, 252, 229, 215, 179, 123, 246, 241, 255, 227,
		219, 171,  75, 150,  49,  98, 196, 149,  55, 110, 220, 165,  87, 174,  65, 130,
		 25,  50, 100, 200, 141,   7,  14,  28,  56, 112, 224, 221, 167,  83, 166,  81,
		162,  89, 178, 121, 242, 249, 239, 195, 155,  43,  86, 172,  69, 138,   9,  18,
		 36,  72, 144,  61, 122, 244, 245, 247, 243, 251, 235, 203, 139,  11,  22,  44,
		 88, 176, 125, 250, 233, 207, 131,  27,  54, 108, 216, 173,  71, 142,   0,   0
	}

	local int_alpha = {
		[0] = 256, -- special value
		0,   1,  25,   2,  50,  26, 198,   3, 223,  51, 238,  27, 104, 199,  75,   4,
		100, 224,  14,  52, 141, 239, 129,  28, 193, 105, 248, 200,   8,  76, 113,   5,
		138, 101,  47, 225,  36,  15,  33,  53, 147, 142, 218, 240,  18, 130,  69,  29,
		181, 194, 125, 106,  39, 249, 185, 201, 154,   9, 120,  77, 228, 114, 166,   6,
		191, 139,  98, 102, 221,  48, 253, 226, 152,  37, 179,  16, 145,  34, 136,  54,
		208, 148, 206, 143, 150, 219, 189, 241, 210,  19,  92, 131,  56,  70,  64,  30,
		 66, 182, 163, 195,  72, 126, 110, 107,  58,  40,  84, 250, 133, 186,  61, 202,
		 94, 155, 159,  10,  21, 121,  43,  78, 212, 229, 172, 115, 243, 167,  87,   7,
		112, 192, 247, 140, 128,  99,  13, 103,  74, 222, 237,  49, 197, 254,  24, 227,
		165, 153, 119,  38, 184, 180, 124,  17,  68, 146, 217,  35,  32, 137,  46,  55,
		 63, 209,  91, 149, 188, 207, 205, 144, 135, 151, 178, 220, 252, 190,  97, 242,
		 86, 211, 171,  20,  42,  93, 158, 132,  60,  57,  83,  71, 109,  65, 162,  31,
		 45,  67, 216, 183, 123, 164, 118, 196,  23,  73, 236, 127,  12, 111, 246, 108,
		161,  59,  82,  41, 157,  85, 170, 251,  96, 134, 177, 187, 204,  62,  90, 203,
		 89,  95, 176, 156, 169, 160,  81,  11, 245,  22, 235, 122, 117,  44, 215,  79,
		174, 213, 233, 230, 231, 173, 232, 116, 214, 244, 234, 168,  80,  88, 175
	}

	-- We only need the polynomial generators for block sizes 7, 10, 13, 15, 16, 17, 18, 20, 22, 24, 26, 28, and 30. Version
	-- 2 of the qr codes don't need larger ones (as opposed to version 1). The table has the format x^1*ɑ^21 + x^2*a^102 ...
	local generator_polynomial = {
		 [7] = { 21, 102, 238, 149, 146, 229,  87,   0},
		[10] = { 45,  32,  94,  64,  70, 118,  61,  46,  67, 251,   0 },
		[13] = { 78, 140, 206, 218, 130, 104, 106, 100,  86, 100, 176, 152,  74,   0 },
		[15] = {105,  99,   5, 124, 140, 237,  58,  58,  51,  37, 202,  91,  61, 183,   8,   0},
		[16] = {120, 225, 194, 182, 169, 147, 191,  91,   3,  76, 161, 102, 109, 107, 104, 120,   0},
		[17] = {136, 163, 243,  39, 150,  99,  24, 147, 214, 206, 123, 239,  43,  78, 206, 139,  43,   0},
		[18] = {153,  96,  98,   5, 179, 252, 148, 152, 187,  79, 170, 118,  97, 184,  94, 158, 234, 215,   0},
		[20] = {190, 188, 212, 212, 164, 156, 239,  83, 225, 221, 180, 202, 187,  26, 163,  61,  50,  79,  60,  17,   0},
		[22] = {231, 165, 105, 160, 134, 219,  80,  98, 172,   8,  74, 200,  53, 221, 109,  14, 230,  93, 242, 247, 171, 210,   0},
		[24] = { 21, 227,  96,  87, 232, 117,   0, 111, 218, 228, 226, 192, 152, 169, 180, 159, 126, 251, 117, 211,  48, 135, 121, 229,   0},
		[26] = { 70, 218, 145, 153, 227,  48, 102,  13, 142, 245,  21, 161,  53, 165,  28, 111, 201, 145,  17, 118, 182, 103,   2, 158, 125, 173,   0},
		[28] = {123,   9,  37, 242, 119, 212, 195,  42,  87, 245,  43,  21, 201, 232,  27, 205, 147, 195, 190, 110, 180, 108, 234, 224, 104, 200, 223, 168,   0},
		[30] = {180, 192,  40, 238, 216, 251,  37, 156, 130, 224, 193, 226, 173,  42, 125, 222,  96, 239,  86, 110,  48,  50, 182, 179,  31, 216, 152, 145, 173, 41, 0}}


	-- Turn a binary string of length 8*x into a table size x of numbers.
	local function convert_bitstring_to_bytes(data)
		local msg = {}
		local tab = string.gsub(data,"(........)",function(x)
			msg[#msg+1] = tonumber(x,2)
			end)
		return msg
	end

	-- Return a table that has 0's in the first entries and then the alpha
	-- representation of the generator polynominal
	local function get_generator_polynominal_adjusted(num_ec_codewords,highest_exponent)
		local gp_alpha = {[0]=0}
		for i=0,highest_exponent - num_ec_codewords - 1 do
			gp_alpha[i] = 0
		end
		local gp = generator_polynomial[num_ec_codewords]
		for i=1,num_ec_codewords + 1 do
			gp_alpha[highest_exponent - num_ec_codewords + i - 1] = gp[i]
		end
		return gp_alpha
	end

	-- Convert polynominal in int notation to alpha notation.
	local function convert_to_alpha( tab )
		local new_tab = {}
		for i=0,#tab do
			new_tab[i] = int_alpha[tab[i]]
		end
		return new_tab
	end

	-- Convert polynominal in alpha notation to int notation.
	local function convert_to_int(tab,len_message)
		local new_tab = {}
		for i=0,#tab do
			new_tab[i] = alpha_int[tab[i]]
		end
		return new_tab
	end

	-- That's the heart of the error correction calculation.
	local function calculate_error_correction(data,num_ec_codewords)
		local mp
		if type(data)=="string" then
			mp = convert_bitstring_to_bytes(data)
		elseif type(data)=="table" then
			mp = data
		else
			assert(false,"Unknown type for data: %s",type(data))
		end
		local len_message = #mp

		local highest_exponent = len_message + num_ec_codewords - 1
		local gp_alpha,tmp
		local he
		local gp_int = {}
		local mp_int,mp_alpha = {},{}
		-- create message shifted to left (highest exponent)
		for i=1,len_message do
			mp_int[highest_exponent - i + 1] = mp[i]
		end
		for i=1,highest_exponent - len_message do
			mp_int[i] = 0
		end
		mp_int[0] = 0

		mp_alpha = convert_to_alpha(mp_int)

		while highest_exponent >= num_ec_codewords do
			gp_alpha = get_generator_polynominal_adjusted(num_ec_codewords,highest_exponent)

			-- Multiply generator polynomial by first coefficient of the above polynomial

			-- take the highest exponent from the message polynom (alpha) and add
			-- it to the generator polynom
			local exp = mp_alpha[highest_exponent]
			for i=highest_exponent,highest_exponent - num_ec_codewords,-1 do
				if exp ~= 256 then
					if gp_alpha[i] + exp >= 255 then
						gp_alpha[i] = math.fmod(gp_alpha[i] + exp,255)
					else
						gp_alpha[i] = gp_alpha[i] + exp
					end
				else
					gp_alpha[i] = 256
				end
			end
			for i=highest_exponent - num_ec_codewords - 1,0,-1 do
				gp_alpha[i] = 256
			end

			gp_int = convert_to_int(gp_alpha)
			mp_int = convert_to_int(mp_alpha)

			tmp = {}
			for i=highest_exponent,0,-1 do
				tmp[i] = bit_xor(gp_int[i],mp_int[i])
			end
			-- remove leading 0's
			he = highest_exponent
			for i=he,0,-1 do
				-- We need to stop if the length of the codeword is matched
				if i < num_ec_codewords then break end
				if tmp[i] == 0 then
					tmp[i] = nil
					highest_exponent = highest_exponent - 1
				else
					break
				end
			end
			mp_int = tmp
			mp_alpha = convert_to_alpha(mp_int)
		end
		local ret = {}

		-- reverse data
		for i=#mp_int,0,-1 do
			ret[#ret + 1] = mp_int[i]
		end
		return ret
	end

	local ecblocks = {
	  {{  1,{ 26, 19, 2}                 },   {  1,{26,16, 4}},                  {  1,{26,13, 6}},                  {  1, {26, 9, 8}               }},
	  {{  1,{ 44, 34, 4}                 },   {  1,{44,28, 8}},                  {  1,{44,22,11}},                  {  1, {44,16,14}               }},
	  {{  1,{ 70, 55, 7}                 },   {  1,{70,44,13}},                  {  2,{35,17, 9}},                  {  2, {35,13,11}               }},
	  {{  1,{100, 80,10}                 },   {  2,{50,32, 9}},                  {  2,{50,24,13}},                  {  4, {25, 9, 8}               }},
	  {{  1,{134,108,13}                 },   {  2,{67,43,12}},                  {  2,{33,15, 9},  2,{34,16, 9}},   {  2, {33,11,11},  2,{34,12,11}}},
	  {{  2,{ 86, 68, 9}                 },   {  4,{43,27, 8}},                  {  4,{43,19,12}},                  {  4, {43,15,14}               }},
	  {{  2,{ 98, 78,10}                 },   {  4,{49,31, 9}},                  {  2,{32,14, 9},  4,{33,15, 9}},   {  4, {39,13,13},  1,{40,14,13}}},
	  {{  2,{121, 97,12}                 },   {  2,{60,38,11},  2,{61,39,11}},   {  4,{40,18,11},  2,{41,19,11}},   {  4, {40,14,13},  2,{41,15,13}}},
	  {{  2,{146,116,15}                 },   {  3,{58,36,11},  2,{59,37,11}},   {  4,{36,16,10},  4,{37,17,10}},   {  4, {36,12,12},  4,{37,13,12}}},
	  {{  2,{ 86, 68, 9},  2,{ 87, 69, 9}},   {  4,{69,43,13},  1,{70,44,13}},   {  6,{43,19,12},  2,{44,20,12}},   {  6, {43,15,14},  2,{44,16,14}}},
	  {{  4,{101, 81,10}                 },   {  1,{80,50,15},  4,{81,51,15}},   {  4,{50,22,14},  4,{51,23,14}},   {  3, {36,12,12},  8,{37,13,12}}},
	  {{  2,{116, 92,12},  2,{117, 93,12}},   {  6,{58,36,11},  2,{59,37,11}},   {  4,{46,20,13},  6,{47,21,13}},   {  7, {42,14,14},  4,{43,15,14}}},
	  {{  4,{133,107,13}                 },   {  8,{59,37,11},  1,{60,38,11}},   {  8,{44,20,12},  4,{45,21,12}},   { 12, {33,11,11},  4,{34,12,11}}},
	  {{  3,{145,115,15},  1,{146,116,15}},   {  4,{64,40,12},  5,{65,41,12}},   { 11,{36,16,10},  5,{37,17,10}},   { 11, {36,12,12},  5,{37,13,12}}},
	  {{  5,{109, 87,11},  1,{110, 88,11}},   {  5,{65,41,12},  5,{66,42,12}},   {  5,{54,24,15},  7,{55,25,15}},   { 11, {36,12,12},  7,{37,13,12}}},
	  {{  5,{122, 98,12},  1,{123, 99,12}},   {  7,{73,45,14},  3,{74,46,14}},   { 15,{43,19,12},  2,{44,20,12}},   {  3, {45,15,15}, 13,{46,16,15}}},
	  {{  1,{135,107,14},  5,{136,108,14}},   { 10,{74,46,14},  1,{75,47,14}},   {  1,{50,22,14}, 15,{51,23,14}},   {  2, {42,14,14}, 17,{43,15,14}}},
	  {{  5,{150,120,15},  1,{151,121,15}},   {  9,{69,43,13},  4,{70,44,13}},   { 17,{50,22,14},  1,{51,23,14}},   {  2, {42,14,14}, 19,{43,15,14}}},
	  {{  3,{141,113,14},  4,{142,114,14}},   {  3,{70,44,13}, 11,{71,45,13}},   { 17,{47,21,13},  4,{48,22,13}},   {  9, {39,13,13}, 16,{40,14,13}}},
	  {{  3,{135,107,14},  5,{136,108,14}},   {  3,{67,41,13}, 13,{68,42,13}},   { 15,{54,24,15},  5,{55,25,15}},   { 15, {43,15,14}, 10,{44,16,14}}},
	  {{  4,{144,116,14},  4,{145,117,14}},   { 17,{68,42,13}},                  { 17,{50,22,14},  6,{51,23,14}},   { 19, {46,16,15},  6,{47,17,15}}},
	  {{  2,{139,111,14},  7,{140,112,14}},   { 17,{74,46,14}},                  {  7,{54,24,15}, 16,{55,25,15}},   { 34, {37,13,12}               }},
	  {{  4,{151,121,15},  5,{152,122,15}},   {  4,{75,47,14}, 14,{76,48,14}},   { 11,{54,24,15}, 14,{55,25,15}},   { 16, {45,15,15}, 14,{46,16,15}}},
	  {{  6,{147,117,15},  4,{148,118,15}},   {  6,{73,45,14}, 14,{74,46,14}},   { 11,{54,24,15}, 16,{55,25,15}},   { 30, {46,16,15},  2,{47,17,15}}},
	  {{  8,{132,106,13},  4,{133,107,13}},   {  8,{75,47,14}, 13,{76,48,14}},   {  7,{54,24,15}, 22,{55,25,15}},   { 22, {45,15,15}, 13,{46,16,15}}},
	  {{ 10,{142,114,14},  2,{143,115,14}},   { 19,{74,46,14},  4,{75,47,14}},   { 28,{50,22,14},  6,{51,23,14}},   { 33, {46,16,15},  4,{47,17,15}}},
	  {{  8,{152,122,15},  4,{153,123,15}},   { 22,{73,45,14},  3,{74,46,14}},   {  8,{53,23,15}, 26,{54,24,15}},   { 12, {45,15,15}, 28,{46,16,15}}},
	  {{  3,{147,117,15}, 10,{148,118,15}},   {  3,{73,45,14}, 23,{74,46,14}},   {  4,{54,24,15}, 31,{55,25,15}},   { 11, {45,15,15}, 31,{46,16,15}}},
	  {{  7,{146,116,15},  7,{147,117,15}},   { 21,{73,45,14},  7,{74,46,14}},   {  1,{53,23,15}, 37,{54,24,15}},   { 19, {45,15,15}, 26,{46,16,15}}},
	  {{  5,{145,115,15}, 10,{146,116,15}},   { 19,{75,47,14}, 10,{76,48,14}},   { 15,{54,24,15}, 25,{55,25,15}},   { 23, {45,15,15}, 25,{46,16,15}}},
	  {{ 13,{145,115,15},  3,{146,116,15}},   {  2,{74,46,14}, 29,{75,47,14}},   { 42,{54,24,15},  1,{55,25,15}},   { 23, {45,15,15}, 28,{46,16,15}}},
	  {{ 17,{145,115,15}            	 },   { 10,{74,46,14}, 23,{75,47,14}},   { 10,{54,24,15}, 35,{55,25,15}},   { 19, {45,15,15}, 35,{46,16,15}}},
	  {{ 17,{145,115,15},  1,{146,116,15}},   { 14,{74,46,14}, 21,{75,47,14}},   { 29,{54,24,15}, 19,{55,25,15}},   { 11, {45,15,15}, 46,{46,16,15}}},
	  {{ 13,{145,115,15},  6,{146,116,15}},   { 14,{74,46,14}, 23,{75,47,14}},   { 44,{54,24,15},  7,{55,25,15}},   { 59, {46,16,15},  1,{47,17,15}}},
	  {{ 12,{151,121,15},  7,{152,122,15}},   { 12,{75,47,14}, 26,{76,48,14}},   { 39,{54,24,15}, 14,{55,25,15}},   { 22, {45,15,15}, 41,{46,16,15}}},
	  {{  6,{151,121,15}, 14,{152,122,15}},   {  6,{75,47,14}, 34,{76,48,14}},   { 46,{54,24,15}, 10,{55,25,15}},   {  2, {45,15,15}, 64,{46,16,15}}},
	  {{ 17,{152,122,15},  4,{153,123,15}},   { 29,{74,46,14}, 14,{75,47,14}},   { 49,{54,24,15}, 10,{55,25,15}},   { 24, {45,15,15}, 46,{46,16,15}}},
	  {{  4,{152,122,15}, 18,{153,123,15}},   { 13,{74,46,14}, 32,{75,47,14}},   { 48,{54,24,15}, 14,{55,25,15}},   { 42, {45,15,15}, 32,{46,16,15}}},
	  {{ 20,{147,117,15},  4,{148,118,15}},   { 40,{75,47,14},  7,{76,48,14}},   { 43,{54,24,15}, 22,{55,25,15}},   { 10, {45,15,15}, 67,{46,16,15}}},
	  {{ 19,{148,118,15},  6,{149,119,15}},   { 18,{75,47,14}, 31,{76,48,14}},   { 34,{54,24,15}, 34,{55,25,15}},   { 20, {45,15,15}, 61,{46,16,15}}}
	}

	-- The bits that must be 0 if the version does fill the complete matrix.
	-- Example: for version 1, no bits need to be added after arranging the data, for version 2 we need to add 7 bits at the end.
	local remainder = {0, 7, 7, 7, 7, 7, 0, 0, 0, 0, 0, 0, 0, 3, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 3, 0, 0, 0, 0, 0, 0}

	-- This is the formula for table 1 in the spec:
	-- function get_capacity_remainder( version )
	-- 	local len = version * 4 + 17
	-- 	local size = len^2
	-- 	local function_pattern_modules = 192 + 2 * len - 32 -- Position Adjustment pattern + timing pattern
	-- 	local count_alignemnt_pattern = #alignment_pattern[version]
	-- 	if count_alignemnt_pattern > 0 then
	-- 		-- add 25 for each aligment pattern
	-- 		function_pattern_modules = function_pattern_modules + 25 * ( count_alignemnt_pattern^2 - 3 )
	-- 		-- but substract the timing pattern occupied by the aligment pattern on the top and left
	-- 		function_pattern_modules = function_pattern_modules - ( count_alignemnt_pattern - 2) * 10
	-- 	end
	-- 	size = size - function_pattern_modules
	-- 	if version > 6 then
	-- 		size = size - 67
	-- 	else
	-- 		size = size - 31
	-- 	end
	-- 	return math.floor(size/8),math.fmod(size,8)
	-- end

	-- The given data can be a string of 0's and 1' (with #string mod 8 == 0).
	-- Alternatively the data can be a table of codewords. The number of codewords
	-- must match the capacity of the qr code.
	local function arrange_codewords_and_calculate_ec( version,ec_level,data )
		if type(data)=="table" then
			local tmp = ""
			for i=1,#data do
				tmp = tmp .. p._toBinary(data[i],8)
			end
			data = tmp
		end
		-- If the size of the data is not enough for the codeword, we add 0's and two special bytes until finished.
		local blocks = ecblocks[version][ec_level]
		local size_datablock_bytes, size_ecblock_bytes
		local datablocks = {}
		local ecblocks = {}
		local count = 1
		local pos = 0
		local cpty_ec_bits = 0
		for i=1,#blocks/2 do
			for j=1,blocks[2*i - 1] do
				size_datablock_bytes = blocks[2*i][2]
				size_ecblock_bytes   = blocks[2*i][1] - blocks[2*i][2]
				cpty_ec_bits = cpty_ec_bits + size_ecblock_bytes * 8
				datablocks[#datablocks + 1] = string.sub(data, pos * 8 + 1,( pos + size_datablock_bytes)*8)
				tmp_tab = calculate_error_correction(datablocks[#datablocks],size_ecblock_bytes)
				tmp_str = ""
				for x=1,#tmp_tab do
					tmp_str = tmp_str .. p._toBinary(tmp_tab[x],8)
				end
				ecblocks[#ecblocks + 1] = tmp_str
				pos = pos + size_datablock_bytes
				count = count + 1
			end
		end
		local arranged_data = ""
		pos = 1
		repeat
			for i=1,#datablocks do
				if pos < #datablocks[i] then
					arranged_data = arranged_data .. string.sub(datablocks[i],pos, pos + 7)
				end
			end
			pos = pos + 8
		until #arranged_data == #data
		-- ec
		local arranged_ec = ""
		pos = 1
		repeat
			for i=1,#ecblocks do
				if pos < #ecblocks[i] then
					arranged_ec = arranged_ec .. string.sub(ecblocks[i],pos, pos + 7)
				end
			end
			pos = pos + 8
		until #arranged_ec == cpty_ec_bits
		return arranged_data .. arranged_ec
	end

	local function add_position_detection_patterns(tab_x)
		local size = #tab_x
		-- allocate quite zone in the matrix area
		for i=1,8 do
			for j=1,8 do
				tab_x[i][j] = -2
				tab_x[size - 8 + i][j] = -2
				tab_x[i][size - 8 + j] = -2
			end
		end
		-- draw the detection pattern (outer)
		for i=1,7 do
			-- top left
			tab_x[1][i]=2
			tab_x[7][i]=2
			tab_x[i][1]=2
			tab_x[i][7]=2

			-- top right
			tab_x[size][i]=2
			tab_x[size - 6][i]=2
			tab_x[size - i + 1][1]=2
			tab_x[size - i + 1][7]=2

			-- bottom left
			tab_x[1][size - i + 1]=2
			tab_x[7][size - i + 1]=2
			tab_x[i][size - 6]=2
			tab_x[i][size]=2
		end
		-- draw the detection pattern (inner)
		for i=1,3 do
			for j=1,3 do
				-- top left
				tab_x[2+j][i+2]=2
				-- top right
				tab_x[size - j - 1][i+2]=2
				-- bottom left
				tab_x[2 + j][size - i - 1]=2
			end
		end
	end

	-- The timing patterns (two) are the dashed lines between two adjacent positioning patterns on row/column 7.
	local function add_timing_pattern(tab_x)
		local line,col
		line = 7
		col = 9
		for i=col,#tab_x - 8 do
			if math.fmod(i,2) == 1 then
				tab_x[i][line] = 2
			else
				tab_x[i][line] = -2
			end
		end
		for i=col,#tab_x - 8 do
			if math.fmod(i,2) == 1 then
				tab_x[line][i] = 2
			else
				tab_x[line][i] = -2
			end
		end
	end

	-- For each version, where should we place the alignment patterns? See table E.1 of the spec
	local alignment_pattern = {
	  {},{6,18},{6,22},{6,26},{6,30},{6,34}, -- 1-6
	  {6,22,38},{6,24,42},{6,26,46},{6,28,50},{6,30,54},{6,32,58},{6,34,62}, -- 7-13
	  {6,26,46,66},{6,26,48,70},{6,26,50,74},{6,30,54,78},{6,30,56,82},{6,30,58,86},{6,34,62,90}, -- 14-20
	  {6,28,50,72,94},{6,26,50,74,98},{6,30,54,78,102},{6,28,54,80,106},{6,32,58,84,110},{6,30,58,86,114},{6,34,62,90,118}, -- 21-27
	  {6,26,50,74,98 ,122},{6,30,54,78,102,126},{6,26,52,78,104,130},{6,30,56,82,108,134},{6,34,60,86,112,138},{6,30,58,86,114,142},{6,34,62,90,118,146}, -- 28-34
	  {6,30,54,78,102,126,150}, {6,24,50,76,102,128,154},{6,28,54,80,106,132,158},{6,32,58,84,110,136,162},{6,26,54,82,110,138,166},{6,30,58,86,114,142,170} -- 35 - 40
	}

	local function add_alignment_pattern( tab_x )
		local version = (#tab_x - 17) / 4
		local ap = alignment_pattern[version]
		local pos_x, pos_y
		for x=1,#ap do
			for y=1,#ap do
				-- we must not put an alignment pattern on top of the positioning pattern
				if not (x == 1 and y == 1 or x == #ap and y == 1 or x == 1 and y == #ap ) then
					pos_x = ap[x] + 1
					pos_y = ap[y] + 1
					tab_x[pos_x][pos_y] = 2
					tab_x[pos_x+1][pos_y] = -2
					tab_x[pos_x-1][pos_y] = -2
					tab_x[pos_x+2][pos_y] =  2
					tab_x[pos_x-2][pos_y] =  2
					tab_x[pos_x  ][pos_y - 2] = 2
					tab_x[pos_x+1][pos_y - 2] = 2
					tab_x[pos_x-1][pos_y - 2] = 2
					tab_x[pos_x+2][pos_y - 2] = 2
					tab_x[pos_x-2][pos_y - 2] = 2
					tab_x[pos_x  ][pos_y + 2] = 2
					tab_x[pos_x+1][pos_y + 2] = 2
					tab_x[pos_x-1][pos_y + 2] = 2
					tab_x[pos_x+2][pos_y + 2] = 2
					tab_x[pos_x-2][pos_y + 2] = 2

					tab_x[pos_x  ][pos_y - 1] = -2
					tab_x[pos_x+1][pos_y - 1] = -2
					tab_x[pos_x-1][pos_y - 1] = -2
					tab_x[pos_x+2][pos_y - 1] =  2
					tab_x[pos_x-2][pos_y - 1] =  2
					tab_x[pos_x  ][pos_y + 1] = -2
					tab_x[pos_x+1][pos_y + 1] = -2
					tab_x[pos_x-1][pos_y + 1] = -2
					tab_x[pos_x+2][pos_y + 1] =  2
					tab_x[pos_x-2][pos_y + 1] =  2
				end
			end
		end
	end

	local typeinfo = {
		{ [-1]= "111111111111111", [0] = "111011111000100", "111001011110011", "111110110101010", "111100010011101", "110011000101111", "110001100011000", "110110001000001", "110100101110110" },
		{ [-1]= "111111111111111", [0] = "101010000010010", "101000100100101", "101111001111100", "101101101001011", "100010111111001", "100000011001110", "100111110010111", "100101010100000" },
		{ [-1]= "111111111111111", [0] = "011010101011111", "011000001101000", "011111100110001", "011101000000110", "010010010110100", "010000110000011", "010111011011010", "010101111101101" },
		{ [-1]= "111111111111111", [0] = "001011010001001", "001001110111110", "001110011100111", "001100111010000", "000011101100010", "000001001010101", "000110100001100", "000100000111011" }
	}

	local function add_typeinfo_to_matrix( matrix,ec_level,mask )
		local ec_mask_type = typeinfo[ec_level][mask]

		local bit
		-- vertical from bottom to top
		for i=1,7 do
			bit = string.sub(ec_mask_type,i,i)
			fill_matrix_position(matrix, bit, 9, #matrix - i + 1)
		end
		for i=8,9 do
			bit = string.sub(ec_mask_type,i,i)
			fill_matrix_position(matrix,bit,9,17-i)
		end
		for i=10,15 do
			bit = string.sub(ec_mask_type,i,i)
			fill_matrix_position(matrix,bit,9,16 - i)
		end
		-- horizontal, left to right
		for i=1,6 do
			bit = string.sub(ec_mask_type,i,i)
			fill_matrix_position(matrix,bit,i,9)
		end
		bit = string.sub(ec_mask_type,7,7)
		fill_matrix_position(matrix,bit,8,9)
		for i=8,15 do
			bit = string.sub(ec_mask_type,i,i)
			fill_matrix_position(matrix,bit,#matrix - 15 + i,9)
		end
	end

	-- Bits for version information 7-40
	-- The reversed strings from https://www.thonky.com/qr-code-tutorial/format-version-tables
	local version_information = {"001010010011111000", "001111011010000100", "100110010101100100", "110010110010010100",
	  "011011111101110100", "010001101110001100", "111000100001101100", "101100000110011100", "000101001001111100",
	  "000111101101000010", "101110100010100010", "111010000101010010", "010011001010110010", "011001011001001010",
	  "110000010110101010", "100100110001011010", "001101111110111010", "001000110111000110", "100001111000100110",
	  "110101011111010110", "011100010000110110", "010110000011001110", "111111001100101110", "101011101011011110",
	  "000010100100111110", "101010111001000001", "000011110110100001", "010111010001010001", "111110011110110001",
	  "110100001101001001", "011101000010101001", "001001100101011001", "100000101010111001", "100101100011000101" }

	-- Versions 7 and above need two bitfields with version information added to the code
	local function add_version_information(matrix,version)
		if version < 7 then return end
		local size = #matrix
		local bitstring = version_information[version - 6]
		local x,y, bit
		local start_x, start_y
		-- first top right
		start_x = #matrix - 10
		start_y = 1
		for i=1,#bitstring do
			bit = string.sub(bitstring,i,i)
			x = start_x + math.fmod(i - 1,3)
			y = start_y + math.floor( (i - 1) / 3 )
			fill_matrix_position(matrix,bit,x,y)
		end

		-- now bottom left
		start_x = 1
		start_y = #matrix - 10
		for i=1,#bitstring do
			bit = string.sub(bitstring,i,i)
			x = start_x + math.floor( (i - 1) / 3 )
			y = start_y + math.fmod(i - 1,3)
			fill_matrix_position(matrix,bit,x,y)
		end
	end

	local function prepare_matrix_with_mask( version,ec_level, mask )
		local size
		local tab_x = {}

		size = version * 4 + 17
		for i=1,size do
			tab_x[i]={}
			for j=1,size do
				tab_x[i][j] = 0
			end
		end
		add_position_detection_patterns(tab_x)
		add_timing_pattern(tab_x)
		add_version_information(tab_x,version)

		-- black pixel above lower left position detection pattern
		tab_x[9][size - 7] = 2
		add_alignment_pattern(tab_x)
		add_typeinfo_to_matrix(tab_x,ec_level, mask)
		return tab_x
	end

	-- Return 1 (black) or -1 (blank) depending on the mask, value and position.
	-- Parameter mask is 0-7 (-1 for 'no mask'). x and y are 1-based coordinates,
	-- 1,1 = upper left. tonumber(value) must be 0 or 1.
	local function get_pixel_with_mask( mask, x,y,value )
		x = x - 1
		y = y - 1
		local invert = false
		-- test purpose only:
		if mask == -1 then
			-- ignore, no masking applied
		elseif mask == 0 then
			if math.fmod(x + y,2) == 0 then invert = true end
		elseif mask == 1 then
			if math.fmod(y,2) == 0 then invert = true end
		elseif mask == 2 then
			if math.fmod(x,3) == 0 then invert = true end
		elseif mask == 3 then
			if math.fmod(x + y,3) == 0 then invert = true end
		elseif mask == 4 then
			if math.fmod(math.floor(y / 2) + math.floor(x / 3),2) == 0 then invert = true end
		elseif mask == 5 then
			if math.fmod(x * y,2) + math.fmod(x * y,3) == 0 then invert = true end
		elseif mask == 6 then
			if math.fmod(math.fmod(x * y,2) + math.fmod(x * y,3),2) == 0 then invert = true end
		elseif mask == 7 then
			if math.fmod(math.fmod(x * y,3) + math.fmod(x + y,2),2) == 0 then invert = true end
		else
			assert(false,"This can't happen (mask must be <= 7)")
		end
		if invert then
			-- value = 1? -> -1, value = 0? -> 1
			return 1 - 2 * tonumber(value)
		else
			-- value = 1? -> 1, value = 0? -> -1
			return -1 + 2*tonumber(value)
		end
	end

	-- We need up to 8 positions in the matrix. Only the last few bits may be less then 8.
	-- The function returns a table of (up to) 8 entries with subtables where
	-- the x coordinate is the first and the y coordinate is the second entry.
	local function get_next_free_positions(matrix,x,y,dir,byte)
		local ret = {}
		local count = 1
		local mode = "right"
		while count <= #byte do
			if mode == "right" and matrix[x][y] == 0 then
				ret[#ret + 1] = {x,y}
				mode = "left"
				count = count + 1
			elseif mode == "left" and matrix[x-1][y] == 0 then
				ret[#ret + 1] = {x-1,y}
				mode = "right"
				count = count + 1
				if dir == "up" then
					y = y - 1
				else
					y = y + 1
				end
			elseif mode == "right" and matrix[x-1][y] == 0 then
				ret[#ret + 1] = {x-1,y}
				count = count + 1
				if dir == "up" then
					y = y - 1
				else
					y = y + 1
				end
			else
				if dir == "up" then
					y = y - 1
				else
					y = y + 1
				end
			end
			if y < 1 or y > #matrix then
				x = x - 2
				-- don't overwrite the timing pattern
				if x == 7 then x = 6 end
				if dir == "up" then
					dir = "down"
					y = 1
				else
					dir = "up"
					y = #matrix
				end
			end
		end
		return ret,x,y,dir
	end

	-- Add the data string (0's and 1's) to the matrix for the given mask.
	local function add_data_to_matrix(matrix,data,mask)
		size = #matrix
		local x,y,positions
		local _x,_y,m
		local dir = "up"
		local byte_number = 0
		x,y = size,size
		string.gsub(data,".?.?.?.?.?.?.?.?",function ( byte )
			byte_number = byte_number + 1
			positions,x,y,dir = get_next_free_positions(matrix,x,y,dir,byte,mask)
			for i=1,#byte do
				_x = positions[i][1]
				_y = positions[i][2]
				m = get_pixel_with_mask(mask,_x,_y,string.sub(byte,i,i))
				if debugging then
					matrix[_x][_y] = m * (i + 10)
				else
					matrix[_x][_y] = m
				end
			end
		end)
	end

	-- Return the penalty for the given matrix
	local function calculate_penalty(matrix)
		local penalty1, penalty2, penalty3, penalty4 = 0,0,0,0
		local size = #matrix
		-- this is for penalty 4
		local number_of_dark_cells = 0

		-- 1: Adjacent modules in row/column in same color
		-- --------------------------------------------
		-- No. of modules = (5+i)  -> 3 + i
		local last_bit_blank -- < 0:  blank, > 0: black
		local is_blank
		local number_of_consecutive_bits
		-- first: vertical
		for x=1,size do
			number_of_consecutive_bits = 0
			last_bit_blank = nil
			for y = 1,size do
				if matrix[x][y] > 0 then
					-- small optimization: this is for penalty 4
					number_of_dark_cells = number_of_dark_cells + 1
					is_blank = false
				else
					is_blank = true
				end
				is_blank = matrix[x][y] < 0
				if last_bit_blank == is_blank then
					number_of_consecutive_bits = number_of_consecutive_bits + 1
				else
					if number_of_consecutive_bits >= 5 then
						penalty1 = penalty1 + number_of_consecutive_bits - 2
					end
					number_of_consecutive_bits = 1
				end
				last_bit_blank = is_blank
			end
			if number_of_consecutive_bits >= 5 then
				penalty1 = penalty1 + number_of_consecutive_bits - 2
			end
		end
		-- now horizontal
		for y=1,size do
			number_of_consecutive_bits = 0
			last_bit_blank = nil
			for x = 1,size do
				is_blank = matrix[x][y] < 0
				if last_bit_blank == is_blank then
					number_of_consecutive_bits = number_of_consecutive_bits + 1
				else
					if number_of_consecutive_bits >= 5 then
						penalty1 = penalty1 + number_of_consecutive_bits - 2
					end
					number_of_consecutive_bits = 1
				end
				last_bit_blank = is_blank
			end
			if number_of_consecutive_bits >= 5 then
				penalty1 = penalty1 + number_of_consecutive_bits - 2
			end
		end
		for x=1,size do
			for y=1,size do
				-- 2: Block of modules in same color
				-- -----------------------------------
				-- Blocksize = m × n  -> 3 × (m-1) × (n-1)
				if (y < size - 1) and ( x < size - 1) and ( (matrix[x][y] < 0 and matrix[x+1][y] < 0 and matrix[x][y+1] < 0 and matrix[x+1][y+1] < 0) or (matrix[x][y] > 0 and matrix[x+1][y] > 0 and matrix[x][y+1] > 0 and matrix[x+1][y+1] > 0) ) then
					penalty2 = penalty2 + 3
				end

				-- 3: 1:1:3:1:1 ratio (dark:light:dark:light:dark) pattern in row/column
				-- ------------------------------------------------------------------
				-- Gives 40 points each
				--
				-- I have no idea why we need the extra 0000 on left or right side. The spec doesn't mention it,
				-- other sources do mention it. This is heavily inspired by zxing.
				if (y + 6 < size and
					matrix[x][y] > 0 and
					matrix[x][y +  1] < 0 and
					matrix[x][y +  2] > 0 and
					matrix[x][y +  3] > 0 and
					matrix[x][y +  4] > 0 and
					matrix[x][y +  5] < 0 and
					matrix[x][y +  6] > 0 and
					((y + 10 < size and
						matrix[x][y +  7] < 0 and
						matrix[x][y +  8] < 0 and
						matrix[x][y +  9] < 0 and
						matrix[x][y + 10] < 0) or
					 (y - 4 >= 1 and
						matrix[x][y -  1] < 0 and
						matrix[x][y -  2] < 0 and
						matrix[x][y -  3] < 0 and
						matrix[x][y -  4] < 0))) then penalty3 = penalty3 + 40 end
				if (x + 6 <= size and
					matrix[x][y] > 0 and
					matrix[x +  1][y] < 0 and
					matrix[x +  2][y] > 0 and
					matrix[x +  3][y] > 0 and
					matrix[x +  4][y] > 0 and
					matrix[x +  5][y] < 0 and
					matrix[x +  6][y] > 0 and
					((x + 10 <= size and
						matrix[x +  7][y] < 0 and
						matrix[x +  8][y] < 0 and
						matrix[x +  9][y] < 0 and
						matrix[x + 10][y] < 0) or
					 (x - 4 >= 1 and
						matrix[x -  1][y] < 0 and
						matrix[x -  2][y] < 0 and
						matrix[x -  3][y] < 0 and
						matrix[x -  4][y] < 0))) then penalty3 = penalty3 + 40 end
			end
		end
		-- 4: Proportion of dark modules in entire symbol
		-- ----------------------------------------------
		-- 50 ± (5 × k)% to 50 ± (5 × (k + 1))% -> 10 × k
		local dark_ratio = number_of_dark_cells / ( size * size )
		penalty4 = math.floor(math.abs(dark_ratio * 100 - 50)) * 2
		return penalty1 + penalty2 + penalty3 + penalty4
	end

	-- Create a matrix for the given parameters and calculate the penalty score.
	-- Return both (matrix and penalty)
	local function get_matrix_and_penalty(version,ec_level,data,mask)
		local tab = prepare_matrix_with_mask(version,ec_level,mask)
		add_data_to_matrix(tab,data,mask)
		local penalty = calculate_penalty(tab)
		return tab, penalty
	end

	-- Return the matrix with the smallest penalty. To to this
	-- we try out the matrix for all 8 masks and determine the
	-- penalty (score) each.
	local function get_matrix_with_lowest_penalty(version,ec_level,data)
		local tab, penalty
		local tab_min_penalty, min_penalty

		-- try masks 0-7
		tab_min_penalty, min_penalty = get_matrix_and_penalty(version,ec_level,data,0)
		for i=1,7 do
			tab, penalty = get_matrix_and_penalty(version,ec_level,data,i)
			if penalty < min_penalty then
				tab_min_penalty = tab
				min_penalty = penalty
			end
		end
		return tab_min_penalty
	end

	-- If ec_level or mode is given, use the ones for generating the qrcode. (mode is not implemented yet)
	local function qrcode( str, ec_level, mode, version_input )
		local arranged_data, version, data_raw, mode, len_bitstring
		version, ec_level, data_raw, mode, len_bitstring = get_version_eclevel_mode_bistringlength(str,ec_level)
		version_in = tonumber(version_input or version)
		if version_in and version_in<version then mw.addWarning('資料'..mw.dumpObject(str)..'無法置入version為'..version_in..'的QR碼中。')end
		version = (version_in<40 and version_in>=version)and version_in or version
		data_raw = data_raw .. len_bitstring
		data_raw = data_raw .. encode_data(str,mode)
		data_raw = add_pad_data(version,ec_level,data_raw)
		arranged_data = arrange_codewords_and_calculate_ec(version,ec_level,data_raw)
		if math.fmod(#arranged_data,8) ~= 0 then
			return false, string.format("Arranged data %% 8 != 0: data length = %d, mod 8 = %d",#arranged_data, math.fmod(#arranged_data,8))
		end
		arranged_data = arranged_data .. string.rep("0",remainder[version])
		local tab = get_matrix_with_lowest_penalty(version,ec_level,arranged_data)
		return true, tab
	end

	return {
		license = license,
		encode_string_numeric = encode_string_numeric,
		encode_string_ascii = encode_string_ascii,
		encode_string_binary = encode_string_binary,
		encode_data = encode_data,
		qrcode = qrcode,
		get_mode = get_mode,
		get_length = get_length,
		add_pad_data = add_pad_data,
		get_generator_polynominal_adjusted = get_generator_polynominal_adjusted,
		get_pixel_with_mask = get_pixel_with_mask,
		get_version_eclevel_mode_bistringlength = get_version_eclevel_mode_bistringlength,
		get_version_eclevel = get_version_eclevel,
		remainder = remainder,
		--get_capacity_remainder = get_capacity_remainder,
		arrange_codewords_and_calculate_ec = arrange_codewords_and_calculate_ec,
		calculate_error_correction = calculate_error_correction,
		convert_bitstring_to_bytes = convert_bitstring_to_bytes,
		get_matrix_and_penalty = get_matrix_and_penalty,
		get_matrix_with_lowest_penalty=get_matrix_with_lowest_penalty,
		bit_xor = bit_xor,
	}
end
function p._get_libbase64()local a,b,c,d,e,f,g,h={},require('bit32').extract,'makeencoder','makedecoder',0x10000,0x40000,'[^%%w%%%s%%%s%%=]',p._get_string_length;a[c]=function(s62,s63,spad)local l={}for m,n in pairs{[0]='A','B','C','D','E','F','G','H','I','J','K','L','M','N','O','P','Q','R','S','T','U','V','W','X','Y','Z','a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z','0','1','2','3','4','5','6','7','8','9',s62 or'+',s63 or'/',spad or'='}do l[m]=n:byte()end;return l end;a[d]=function(s62,s63,spad)local o={}for m,q in pairs(a[c](s62,s63,spad))do o[q]=m end;return o end;local r=a[c]()local s=a[d]()local n,t,u=string.char,table.concat,p._get_bytes;function a.encode(v,l,w)l=l or r;local x,y,z={},1,h(v)local A=z%3;local B={}for C=1,z-A,3 do local D,E,F=u(v,C,C+2)local G=D*e+E*0x100+F;local H;if w then H=B[G]if not H then H=n(l[b(G,18,6)],l[b(G,12,6)],l[b(G,6,6)],l[b(G,0,6)])B[G]=H end else H=n(l[b(G,18,6)],l[b(G,12,6)],l[b(G,6,6)],l[b(G,0,6)])end;x[y]=H;y=y+1 end;if A==2 then local D,E=u(v,z-1,z)local G=D*e+E*0x100;x[y]=n(l[b(G,18,6)],l[b(G,12,6)],l[b(G,6,6)],l[64])elseif A==1 then local G=u(v,z)*e;x[y]=n(l[b(G,18,6)],l[b(G,12,6)],l[64],l[64])end;return t(x)end;function a.decode(I,o,w,J)o=o or s;local K='[^%w%+%/%=]'if o then local i,j;for q,m in pairs(o)do if m==62 then i=q elseif m==63 then j=q end end;K=g:format(n(i),n(j))end;I=I:gsub(K,'')local B=w and{}local x,y={},1;local z=#I;local L=I:sub(-2)=='=='and 2 or I:sub(-1)=='='and 1 or 0;for C=1,L>0 and z-4 or z,4 do local D,E,F,M=I:byte(C,C+3)local H;if w then local N=D*0x1000000+E*e+F*0x100+M;H=B[N]if not H then local G=o[D]*f+o[E]*0x1000+o[F]*0x40+o[M]H=n(b(G,16,8),b(G,8,8),b(G,0,8))B[N]=H end else local G=o[D]*f+o[E]*0x1000+o[F]*0x40+o[M]H=n(b(G,16,8),b(G,8,8),b(G,0,8))end;x[y]=H;y=y+1 end;if L==1 then local D,E,F=I:byte(z-3,z-1)local G=o[D]*f+o[E]*0x1000+o[F]*0x40;x[y]=n(b(G,16,8),b(G,8,8))elseif L==2 then local D,E=I:byte(z-3,z-2)local G=o[D]*f+o[E]*0x1000;x[y]=n(b(G,16,8))end;if J==true then local O={}for C=1,#x do for P=1,#x[C]do O[#O+1]=x[C]:byte(P)end end;return O end;return t(x)end;return a end
function p.jsonEncode(obj)
	local args, working_frame
    if obj == mw.getCurrentFrame() then
        -- We're being called via #invoke. The args are passed through to the module
        -- from the template page, so use the args that were passed into the template.
        if lib_arg.getArgs == nil then lib_arg = require('Module:Arguments') end
        args = lib_arg.getArgs(obj, {
        	parentFirst=true,
        	trim = false,
			removeBlanks = false
        })
        working_frame = obj
    else
        -- We're being called from another module or from the debug console, so assume
        -- the args are passed in directly.
        args = obj
        working_frame = mw.getCurrentFrame()
        if type(args) ~= type({}) then args = {obj} end
    end
    return _jsonEncode(args)
end
function p.jsonDecode(obj)
	local args, working_frame
    if obj == mw.getCurrentFrame() then
        -- We're being called via #invoke. The args are passed through to the module
        -- from the template page, so use the args that were passed into the template.
        if lib_arg.getArgs == nil then lib_arg = require('Module:Arguments') end
        args = lib_arg.getArgs(obj, {
        	parentFirst=true,
        	trim = false,
			removeBlanks = false
        })
        working_frame = obj
    else
        -- We're being called from another module or from the debug console, so assume
        -- the args are passed in directly.
        args = obj
        working_frame = mw.getCurrentFrame()
        if type(args) ~= type({}) then args = {obj} end
    end
    local var = args[1] or args['1']
    if type(var) ~= type({"table"}) then
    	if type(var) == type(nil) then return nil end
    	if type(var) ~= type("string") then return var end
    	return mw.text.jsonDecode(tostring(var))
    end
    return var
end
function p.jsonGet(obj)
	local args, working_frame
    if obj == mw.getCurrentFrame() then
        -- We're being called via #invoke. The args are passed through to the module
        -- from the template page, so use the args that were passed into the template.
        if lib_arg.getArgs == nil then lib_arg = require('Module:Arguments') end
        args = lib_arg.getArgs(obj, {
        	parentFirst=true,
        	trim = false,
			removeBlanks = false
        })
        working_frame = obj
    else
        -- We're being called from another module or from the debug console, so assume
        -- the args are passed in directly.
        args = obj
        working_frame = mw.getCurrentFrame()
        if type(args) ~= type({}) then args = {obj} end
    end
    local json = p.jsonDecode(obj)
    local key = args[2] or args["2"]
    if type(json) == type(0) or type(json) == type(true) then return nil end
    return (json or {})[key]
end
local yesno=require("Module:Yesno")
function p.base64Encode(obj)
	local args, working_frame
    if obj == mw.getCurrentFrame() then
        -- We're being called via #invoke. The args are passed through to the module
        -- from the template page, so use the args that were passed into the template.
        if lib_arg.getArgs == nil then lib_arg = require('Module:Arguments') end
        args = lib_arg.getArgs(obj, {
        	parentFirst=true,
        	trim = false,
			removeBlanks = false
        })
        working_frame = obj
    else
        -- We're being called from another module or from the debug console, so assume
        -- the args are passed in directly.
        args = obj
        working_frame = mw.getCurrentFrame()
        if type(args) ~= type({}) then args = {obj} end
    end
    local text = args[1]or args['1'] or args.text
    local bitstream = args.bitstream and mw.text.split(args.bitstream,',')
    if not(text or bitstream) then return '' end
    return p._get_libbase64().encode(text or bitstream)
end
function p.base64Decode(obj)
	local args, working_frame
    if obj == mw.getCurrentFrame() then
        -- We're being called via #invoke. The args are passed through to the module
        -- from the template page, so use the args that were passed into the template.
        if lib_arg.getArgs == nil then lib_arg = require('Module:Arguments') end
        args = lib_arg.getArgs(obj, {
        	parentFirst=true,
        	trim = false,
			removeBlanks = false
        })
        working_frame = obj
    else
        -- We're being called from another module or from the debug console, so assume
        -- the args are passed in directly.
        args = obj
        working_frame = mw.getCurrentFrame()
        if type(args) ~= type({}) then args = {obj} end
    end
    local text = args[1]or args['1'] or args.text
    local bitstream = yesno(args.bitstream or false)
    local body = p._get_libbase64().decode(text,nil,nil,bitstream)
    if type(body)==type({})then body=table.concat(body,',')end
    return body
end
p._jsonEncode=_jsonEncode
p._get_libqrcode=function()return init_qrcode_library()end
return p
检索自“https://wiki.gdrain.workers.dev/w/index.php?title=Module:EncoderUtil&oldid=80540519”