:Module:Unicode chart

local mArguments = require('Module:Arguments')

local mTableTools = require('Module:TableTools')

local mUnicode = require('Module:Unicode data')

local mAge = require('Module:Unicode data/age')

local mAliases = require('Module:Unicode data/aliases')

local mBlocks = require('Module:Unicode data/blocks')

local mCategory = require('Module:Unicode data/category')

local mControl = require('Module:Unicode data/control')

local mScripts = require('Module:Unicode data/scripts')

local mVersion = require('Module:Unicode data/version')

local mEntities = require('Module:Unicode chart/entities')

local mDisplay = require('Module:Unicode chart/display')

local mSubsets = require('Module:Unicode chart/subsets')

local p = {}

local args = {}

local config = {

useFontCss = true,

showRefs = true,

infoMode = false,

}

local refGrammar = {

order = { "white", "combining", "control", "format", "reserved", "nonchar", "skip" },

white = {

format = 'White area%s within light green cell%s show%s %s of %sotherwise invisible whitespace character%s.',

singular = { , , 's', 'the size', 'an ', '' },

plural = { 's', 's', , 'sizes', , 's' },

count = 0,

},

combining = {

format = 'Yellow cell%s with dotted circle%s (◌) indicate%s %scombining character%s.',

singular = { , , 's', 'a ', '' },

plural = { 's', 's', , ,'s' },

count = 0,

},

control = {

format = 'Light blue cell%s indicate%s %snon-printable control character%s.',

singular = { , 's', 'a ', },

plural = { 's', , , 's' },

count = 0,

},

format = {

format = 'Pink cell%s indicate%s %sformat character%s.',

singular = { , 's', 'a ', },

plural = { 's', , , 's' },

count = 0,

},

reserved = {

format = 'Gray cell%s indicate%s %sunassigned (reserved) code point%s.',

singular = { , 's', 'an ', },

plural = { 's', , , 's' },

count = 0,

},

nonchar = {

format = 'Black cell%s indicate%s %snoncharacter%s (code point%s that %s guaranteed never to be assigned as %sencoded character%s in the Unicode Standard).',

singular = { ,'s','a ', , , 'is','an ', },

plural = { 's',, ,'s','s','are', '','s' },

count = 0,

},

skip = {

format = 'Black horizontal line%s indicate%s non-consecutive rows.',

singular = { '', 's' },

plural = { 's', '' },

count = 0,

},

}

local infoTable = {}

local err = {

format = function(...) return error(string.format(...), 0) end,

blockName = 'Unrecognized block name "%s" does not match those defined in Module:Unicode data/blocks',

refGarbage = 'Refs contain non-ref content: "%s"',

badRange = 'Invalid range "%s" specified. Ranges must match regular expression ^[0-9A-F]+(?:[-–][0-9A-F]+)?$',

noRange = 'Please specify a valid block name, range of code points, or named subset',

badSubset = 'Invalid subset "%s" specified',

}

function debug(...)

local a = {...}

if type(a[1]) ~= "string" then mw.log(a[1]) return end

local _,c = string.gsub(string.gsub(a[1], "%%%%", ""), "%%", "")

for i = 1,math.max(#a, c+1) do

if (type(a[i]) == "nil" or type(a[i]) == "boolean") then a[i] = tostring(a[i]) end

end

return mw.log(string.format(unpack(a)))

end

table.concat2 = function(t1,t2) for i=1,#t2 do t1[#t1+1] = t2[i] end return t1 end

table.last = function(t) if t then return t[#t] else return nil end end

string.formatAll = function(fmt, t)

for i=1,#t do t[i] = string.format(fmt, t[i]) end

return t

end

function getUtf8(n)

local t = {}

for b in mw.ustring.char(n):gmatch('.') do table.insert(t, b:byte()) end

return t

end

function getUtf16(n)

if(n < 0 or n > 0x10FFFF) then return nil end

if(n >= 0xD800 and n <= 0xDFFF) then return nil end

if(n < 0x10000) then return { n } end

local u = (n - 0x10000)

local low = (u % 0x400)

local high = (u - low) / 0x400

return { 0xD800 + high, 0xDC00 + low }

end

function getUtf16toStr(n)

t = getUtf16(n)

for i=1,#t do t[i] = string.format("0x%04X", t[i]) end

return t

end

function getUtf8toStr(n) return string.formatAll("0x%02X", getUtf8(n) ) end

function getUtf16toStr(n) return string.formatAll("0x%04X", getUtf16(n)) end

function makeRange(a,b)

if(b) then return {first=math.min(a,b),last=math.max(a,b)} else return {first=a,last=a} end

end

function rangeContains(r, n) return (n >= r.first and n <= r.last) end

function rangeCombine(r1,r2) return {first=math.min(r1.first,r2.first), last=math.max(r1.last,r2.last)} end

function rangesMergeable(r1,r2)

if not r1 or not r2 then return false end

return rangeContains(r1, r2.first-1) or rangeContains(r1, r2.last+1) or

rangeContains(r2, r1.first-1) or rangeContains(r2, r1.last+1)

end

function rangeSort(r1,r2)

if r1 and not r2 then return true end

if not r1 then return false end

if r1.first == r2.first then return r1.last < r2.last end

return r1.first < r2.first

end

function parseHex(s) if s then return tonumber(s,16) else return nil end end

function parseRanges(str)

local r = {}

str = str:upper():gsub("AND", ",") --avoid parsing A and D as single control chars in row U+000x, whoops

for x in mw.ustring.gmatch(str, "[%dA-FUX%+%-]+") do

local a,b = mw.ustring.match(x, "^[UX0%+%-]*([%dA-F]+)[-–][UX0%+%-]*([%dA-F]+)$")

if(a and b) then

table.insert(r, makeRange(parseHex(a),parseHex(b)))

else

local c = mw.ustring.match(x, "^[UX0%+%-]*([%dA-F]+)$")

if c then

table.insert(r, makeRange(parseHex(c)))

else

err.format(err.badRange, x)

end

end

end

for i = #r,2,-1 do for j = i-1,1,-1 do if rangesMergeable(r[i], r[j]) then

r[j] = rangeCombine(r[i], r[j]) r[i] = nil

end end end

r2 = {}

for k,v in pairs(r) do table.insert(r2,v) end

table.sort(r2, rangeSort)

return r2

end

-- Official way to match property values that are strings (including block names):

-- Ignore case, whitespace, underscore ('_'), hyphens, and any initial prefix string "is".

-- http://www.unicode.org/reports/tr44/#UAX44-LM3

local function propertyValueKey(val)

return val:lower():gsub('^is', ):gsub('[-_%s]+', )

end

function getDefaultRange(blockName)

if not blockName then return nil end

blockName = propertyValueKey(blockName)

for i,b in ipairs(mBlocks) do

if blockName == propertyValueKey(b[3]) then return makeRange(b[1],b[2]) end

end

end

function getAge(n)

local a = mAge.singles[n]

if(a) then return a end

for k,v in pairs(mAge.ranges) do

if n >= v[1] and n <= v[2] then return v[3] end

end

return nil

end

function getCategory(n)

local cc = mUnicode.lookup_category(n)

local cat = mCategory.long_names[cc]

if cat then return string.gsub(string.lower(cat), "_", " ") else return nil end

end

function getControlAbbrs(n) return getAliasValues(n, "abbreviation") end

function getControlAliases(n) return table.concat2(getAliasValues(n, "control"), getAliasValues(n, "figment")) end

function getAliasValues(n, key)

local b,r = mAliases[n], {}

if b then for i,t in ipairs(b) do

if(not key or t[1] == key) then table.insert(r, t[2]) end

end end

return r

end

function getAnchorId(n) return string.format("info-%04X", n) end

function getTarget(n)

if(config.infoMode) then return "#"..getAnchorId(n) end

local t = getParamNx("link", n, true)

if(t=="yes") then t = char end

--"ifexist" is a deleted feature, now recognized equal to "no" to avoid linking to the article Ifexist, which incidentally doesn't exist.

if(t=="no" or t=="ifexist") then t = nil end

if(t=="wikt") then t = ":wikt:"..mw.ustring.char(n) end

return t

end

function getNamedEntity(n)

local e = mEntities[n]

if e then return string.gsub(e, "&", "&") else return nil end

end

function getEntities(n)

local entH = getNamedEntity(n)

local entN = string.format('&#%d;', n)

local entXN = string.format('&#x%X;', n)

local t = {}

if(entH) then table.insert(t, entH) end

table.insert(t, entN)

table.insert(t, entXN)

return t

end

function isControl(n) return mUnicode.lookup_control(n) == "control" end

function isFormat(n) return mUnicode.lookup_control(n) == "format" end

function isBadTitle(str)

if str == nil then return true end

if type(str) == "number" then str = mw.ustring.char(str) end

if not mUnicode.is_valid_pagename(str) then return true end

if mw.ustring.match(str, "[\<\>]") then return true end

if #str == 1 and mw.ustring.match(str, "[\/\.\:\_̸]") then return true end

return false

end

function makeVersionRef()

if(not config.showRefs or mVersion == nil or mVersion == ) then return

else return string.format('As of Unicode version %s.', mw.text.nowiki(mVersion)) end

end

function makeAutoRefs()

if not config.showRefs then return '' end

local refs = {}

for i,refType in ipairs(refGrammar.order) do

local g = refGrammar[refType]

local refText = nil

if(g.count == 1) then refText = string.format(g.format, unpack(g.singular)) end

if(g.count >= 2) then refText = string.format(g.format, unpack(g.plural)) end

if(refText) then

table.insert(refs, string.format('%s', refType, refText))

end

end

return table.concat(refs)

end

--TODO: remove any garbage around/between refs and downgrade this to a warning

function sanitizeUserRefs(refTxt)

if not config.showRefs then return '' end

local trim1 = mw.text.killMarkers(refTxt)

local trim2 = mw.ustring.gsub(trim1, '%s', '')

if string.len(trim2) > 0 then err.format(err.refGarbage, mw.text.nowiki(trim1))

else return refTxt end

end

function makeSpan(str, title, repl)

local c,t = ,

if title then t = string.format(' title="%s"', title) end

if repl then

local s,x = mw.ustring.gsub(str, '%s+', '\n')

if x > 0 then c = string.format(' class="small-%s"', x) str = s end

end

return string.format('%s', c, t, str)

end

function makeLink(a, b)

if not a or (isBadTitle(a) and not config.infoMode) then return (b or '') end

if not b then b = a end

return string.format("%s",a,b)

end

function makeAliasList(n)

if not mAliases[n] then return '' end

local t = {}

table.insert(t, '

')

return table.concat(t)

end

function makeDivUl(t, class) return makeDiv(makeUl(t), class) end

function makeUl(t, class)

if not t then return '' end

if class then class = string.format(' class="%s"', class) else class = '' end

return string.format('

%s

', class, table.concat(t, '

'))

end

function makeDiv(s, class)

if not s or string.len(s) == 0 then return '' end

if class then class = string.format(' class="%s"', class) else class = '' end

return string.format('%s