Modul:ISO15924

 local ISO15924 = { suite = "ISO15924",
 serial = "2020年03月10日",
 item = 71584769,
 statics = "codes" }
 --[=[
 ISO 15924 support for scripting systems
 * fetch()
 * getLanguageScript()
 * getScripts()
 * isCJK()
 * isRTL()
 * isScript()
 * isTrans()
 * scriptName()
 * showScript()
 * showScripts()
 * testScripts()
 * failsafe()
 ]=]
 local Failsafe = ISO15924
 local GlobalMod = ISO15924
 local Unicode



 ISO15924.Text = { }
 ISO15924.Unicode = { }
 Unicode = ISO15924.Unicode
 Unicode.RomanN = { bef = { [ 32 ] = true,
 [ 160 ] = true,
 [ 8239 ] = true,
 [ 40 ] = true,
 [ 45 ] = true,
 [ 91 ] = true
 },
 dig = { [ 73 ] = true, -- I
 [ 86 ] = true, -- V
 [ 88 ] = true, -- X
 [ 76 ] = true, -- L
 [ 67 ] = true, -- C
 [ 68 ] = true, -- D
 [ 77 ] = true -- M
 },
 fol = { [ 32 ] = true,
 [ 160 ] = true,
 [ 8239 ] = true,
 [ 41 ] = true,
 [ 44 ] = true,
 [ 46 ] = true,
 [ 93 ] = true
 } }
 ISO15924.Commons = { "cjk",
 "iso639script",
 "reverse",
 "rtl",
 "trans",
 "unicodes" }



 local foreignModule = function ( access, advanced, append, alt, alert )
 -- Fetch global module
 -- Precondition:
 -- access -- string, with name of base module
 -- advanced -- true, for require(); else mw.loadData()
 -- append -- string, with subpage part, if any; or false
 -- alt -- number, of wikidata item of root; or false
 -- alert -- true, for throwing error on data problem
 -- Postcondition:
 -- Returns whatever, probably table
 -- 2019年10月29日
 local storage = access
 local finer = function ()
 if append then
 storage = string.format( "%s/%s",
 storage,
 append )
 end
 end
 local fun, lucky, r, suited
 if advanced then
 fun = require
 else
 fun = mw.loadData
 end
 GlobalMod.globalModules = GlobalMod.globalModules or { }
 suited = GlobalMod.globalModules[ access ]
 if not suited then
 finer()
 lucky, r = pcall( fun, "Module:" .. storage )
 end
 if not lucky then
 if not suited and
 type( alt ) == "number" and
 alt > 0 then
 suited = string.format( "Q%d", alt )
 suited = mw.wikibase.getSitelink( suited )
 GlobalMod.globalModules[ access ] = suited or true
 end
 if type( suited ) == "string" then
 storage = suited
 finer()
 lucky, r = pcall( fun, storage )
 end
 if not lucky and alert then
 error( "Missing or invalid page: " .. storage, 0 )
 end
 end
 return r
 end -- foreignModule()



 local function fill( accumulate, assign, append )
 -- Copy external sequence into local collection
 -- Precondition:
 -- accumulate -- table, with relevant definitions
 -- assign -- table, with assigned definitions
 -- append -- table, if code names to be appended to entries
 if type( assign ) == "table" then
 local e
 for k, v in pairs( assign ) do
 if type( v ) == "table" then
 e = { }
 for kk, vv in pairs( v ) do
 table.insert( e, vv )
 end -- for kk, vv
 if append then
 for i = 1, #append do
 table.insert( e, append[ i ] )
 end -- for i
 end
 table.insert( accumulate, e )
 end
 end -- for k, v
 end
 end -- fill()



 local function fulfil( ask, attribute )
 -- Check whether script has a certain attribute
 -- Precondition:
 -- ask -- string, with language or script code
 -- attribute -- string, with "cjk" or "rtl"
 -- Returns true, if matchin
 local got = ISO15924.fetch( attribute )
 local r
 if type( got ) == "table" then
 local n = #ask
 local script
 if n == 4 then
 script = ask
 elseif n < 4 then
 script = ISO15924.getLanguageScript( ask )
 else
 script = ask:match( "^%a%a%a?%-(%a%a%a%a)$" )
 if not script then
 script = ask:match( "^(%a%a%a?)%-%a%a$" )
 script = ISO15924.getLanguageScript( script )
 end
 end
 if script then
 script = script:sub( 1, 1 ):upper() ..
 script:sub( 2 ):lower()
 r = got[ script ]
 end
 end
 return r or false
 end -- fulfil()



 ISO15924.Text.scriptName = function ( assigned, alien, add )
 -- Retrieve script name, hopefully linked
 -- Precondition:
 -- assigned -- string, with script code
 -- alien -- string, with language code, or not
 -- add -- arbitrary additional information
 -- Returns string
 local r, trsl
 if type( assigned ) == "string" and
 assigned:match( "^%u%l%l%l$" ) then
 trsl = ISO15924.fetch( "translate" )
 r = assigned
 else
 r = ""
 end
 if type( trsl ) == "table" then
 local slang
 if type( alien ) == "string" and
 alien:match( "^%l%l%l?%-?" ) then
 slang = alien:lower()
 end
 if not slang then
 if not ISO15924.Text.sublang then
 local title = mw.title.getCurrentTitle()
 ISO15924.Text.sublang = title.text:match( "/%l%l%l?$" )
 ISO15924.Text.sublang = ISO15924.Text.sublang or true
 end
 if type( ISO15924.Text.sublang ) == "string" and
 type( trsl[ ISO15924.Text.sublang ] ) == "table" then
 slang = ISO15924.Text.sublang
 end
 end
 if not slang then
 if not ISO15924.Text.sitelang then
 local contLang = mw.language.getContentLanguage()
 ISO15924.Text.sitelang = contLang:getCode():lower()
 end
 slang = ISO15924.Text.sitelang
 end
 if type( trsl[ slang ] ) == "table" then
 trsl = trsl[ slang ]
 elseif type( trsl.en ) == "table" then
 trsl = trsl.en
 slang = "en"
 else
 trsl = false
 end
 if trsl then
 local pages = ISO15924.fetch( "pages" )
 trsl = trsl[ assigned ]
 if type( trsl ) == "string" then
 r = trsl
 elseif type( trsl ) == "table" then
 if type( trsl[ 1 ] ) == "string" then
 r = trsl[ 1 ]
 if add and slang == "de" then
 if tonumber( add ) == 2 and
 type( trsl[ 2 ] ) == "string" then
 r = trsl[ 2 ]
 end
 end
 end
 end
 if type( pages ) == "table" then
 local p
 for k, v in pairs( pages ) do
 if type( v ) == "table" and v.lang == slang then
 p = v
 break -- for k, v
 end
 end -- for k, v
 if p and type( p.targets ) == "table" then
 p = p.targets[ assigned ]
 if type( p ) == "string" then
 -- different server issues --
 if mw.ustring.upper( mw.ustring.sub( p, 1, 1 ) )
 ~=
 mw.ustring.upper( mw.ustring.sub( r, 1, 1 ) )
 or mw.ustring.sub( p, 2 ) ~=
 mw.ustring.sub( r, 2 ) then
 r = string.format( "%s|%s", p, r )
 end
 r = string.format( "[[%s]]", r )
 end
 end
 end
 if add and slang == "de" then
 if tonumber( add ) == 2 then
 local s = "in "
 if type( trsl ) == "table" and
 type( trsl[ 3 ] ) == "string" then
 s = trsl[ 3 ] .. " "
 end
 r = s .. r
 end
 end
 end
 end
 return r
 end -- ISO15924.Text.scriptName()



 Unicode.flat = function ( analyse )
 -- Remove markup and syntax from wikitext
 -- Precondition:
 -- analyse -- string, with wikitext
 -- Returns string, with cleaned content plain text
 local r = analyse
 if r:find( "&", 1, true ) then
 r = mw.text.decode( r, true )
 end
 r = mw.text.trim( mw.text.unstrip( r ) )
 if r:find( "<", 1, true ) and
 r:find( ">", 1, true ) then
 r = r:gsub( "(</?%l[^>]*>)", "" )
 end
 if r:find( "[", 1, true ) and
 ( ( r:find( "[[", 1, true ) and
 r:find( "]]", 1, true ) ) or
 r:find( "[http", 1, true ) or
 r:find( "[//", 1, true ) ) then
 local lucky, WLink = pcall( require, "Module:WLink" )
 if type( WLink ) == "table" then
 r = WLink.WLink().getPlain( r )
 end
 end
 return r
 end -- Unicode.flat()



 Unicode.getRanges = function ()
 -- Retrieve collection of Unicode ranges
 -- Returns table, with all relations codepoint / scripts
 if type( Unicode.ranges ) ~= "table" then
 local e, unique
 Unicode.ranges = { }
 unique = ISO15924.fetch( "reverse" )
 for k, range in pairs( unique ) do
 e = { }
 for j, v in pairs( range ) do
 table.insert( e, v )
 end -- for j, v
 table.insert( Unicode.ranges, e )
 end -- for k, range
 end
 return Unicode.ranges
 end -- Unicode.getRanges()



 Unicode.getScripts = function ( allow, analyse, assume )
 -- Check all chars for expected script code ranges
 -- Precondition:
 -- allow -- table, with permitted unspecific ranges
 -- analyse -- string or number or table, with text
 -- assume -- string, or nil, with ID of expected script
 -- Returns table, with all relations codepoint / scripts
 local uc = Unicode.getRanges()
 local cp = type( analyse )
 local r = { }
 local e, n, p, s, v
 if cp == "string" then
 e = Unicode.flat( analyse )
 cp = { }
 n = mw.ustring.len( e )
 for i = 1, n do
 table.insert( cp, mw.ustring.codepoint( e, i, i ) )
 end -- for i
 elseif cp == "table" then
 cp = analyse
 elseif cp == "number" then
 cp = { analyse }
 end
 for i = 1, #cp do
 n = cp[ i ]
 p = { n, false }
 for k = 1, #uc do
 e = uc[ k ]
 if n <= e[ 2 ] then
 if n >= e[ 1 ] then
 v = e[ 3 ]
 if type( v ) == "table" then
 s = v[ 1 ]
 if assume then
 for j = 2, #v do
 if v[ j ] == assume then
 s = v[ j ]
 break -- for j
 end
 end -- for j
 end
 else
 s = "???"
 end
 p[ 2 ] = s
 n = false
 end
 break -- for k
 elseif n < e[ 1 ] then
 break -- for k
 end
 end -- for k
 if n then
 for j = 1, #allow do
 e = allow[ j ]
 if n <= e[ 2 ] then
 if n >= e[ 1 ] then
 p[ 2 ] = true
 end
 break -- for j
 elseif n < e[ 1 ] then
 break -- for j
 end
 end -- for j
 end
 table.insert( r, p )
 end -- for i
 return r
 end -- Unicode.getScripts()



 Unicode.isScript = function ( all, ask, analyse )
 -- Check all chars for expected script code ranges
 -- Precondition:
 -- all -- table, with all definitions
 -- ask -- string, with supposed script code
 -- analyse -- string or number or table, with text
 -- Returns
 -- 1. true, if all chars within
 -- 2. table, with analyse text
 local f = function ( array, amount, a )
 local k = a
 local e
 for i = 1, amount do
 e = array[ i ]
 if k >= e[ 1 ] then
 if k <= e[ 2 ] then
 k = false
 break -- for i
 end
 else
 break -- for i
 end
 end -- for i
 return k
 end
 local s = analyse
 local cp = type( s )
 local uc = { }
 local xx = { }
 local r = true
 local m, na, nu, nx
 if cp == "string" then
 s = Unicode.flat( s )
 cp = { }
 na = mw.ustring.len( s )
 for i = 1, na do
 table.insert( cp, mw.ustring.codepoint( s, i, i ) )
 end -- for i
 elseif cp == "table" then
 cp = s
 elseif cp == "number" then
 cp = { s }
 else
 cp = { }
 end
 Unicode.merge( uc, all, ask )
 Unicode.merge( xx, all, "*" )
 na = #cp
 nu = #uc
 nx = #xx
 for j = 1, na do
 m = f( uc, nu, cp[ j ] )
 if m then
 m = f( xx, nx, m )
 if m then
 r = false
 break -- for j
 end
 end
 end -- for j
 return r, cp
 end -- Unicode.isScript()



 Unicode.merge = function ( accumulate, all, ask, append )
 -- Ensure single list of items
 -- Precondition:
 -- accumulate -- table, with collection to be extended
 -- all -- table, with all definitions
 -- ask -- string, with requested script code
 -- append -- true, if code names to be appended to entries
 -- The accumulate table may have been extended
 local g = all[ ask ]
 if type( g ) == "table" then
 local codes, s
 for k, v in pairs( g ) do
 s = type( v )
 break -- for k, v
 end -- for k, v
 if s == "string" then
 for k, v in pairs( g ) do
 if append then
 codes = { ask, v }
 table.sort( codes )
 end
 fill( accumulate, all[ v ], codes )
 end -- for k, v
 Unicode.sort( accumulate )
 elseif s == "table" then
 if append then
 codes = { ask }
 end
 fill( accumulate, g, codes )
 end
 end
 end -- Unicode.merge()



 Unicode.romanNumbers = function ( array, at )
 -- Check for possible roman numbers
 -- Precondition:
 -- array -- table, with elements as sequence tables
 -- all -- number, with position within array
 -- Returns number, which is identical or greater than at, to proceed
 local r = at
 local e = array[ r ]
 if Unicode.RomanN.dig[ e[ 1 ] ] and
 r > 1 and
 Unicode.RomanN.bef[ array[ r - 1 ][ 1 ] ] then
 local j = r
 while j < #array do
 e = array[ j + 1 ]
 if Unicode.RomanN.dig[ e[ 1 ] ] then
 j = j + 1
 else
 break -- while j
 end
 end -- while j
 if j == #array or
 Unicode.RomanN.fol[ e[ 1 ] ] then
 r = j + 1
 end
 end
 return r
 end -- Unicode.romanNumbers()



 Unicode.showScripts = function ( analysed )
 -- Retrieve codepoints and assigned script codes for string
 -- Precondition:
 -- analysed -- table, as returned by Unicode.getScripts()
 -- Returns string, with every codepoint-script identified
 local r = ""
 local c, d, k, s
 for i = 1, #analysed do
 c = analysed[ i ]
 k = c[ 1 ]
 s = string.format( "%X", k )
 d = c[ 2 ]
 if d then
 if type( d ) == "string" then
 s = string.format( "%s-%s-%s",
 s,
 mw.ustring.char( k ),
 d )
 end
 else
 s = s .. "-????"
 end
 r = string.format( "%s %s", r, s )
 end -- for i
 return r
 end -- Unicode.showScripts()



 Unicode.sort = function ( apply )
 -- Sort code ranges
 -- apply -- table, with request
 local function f( a1, a2 )
 return a1[ 1 ] < a2[ 1 ]
 end
 table.sort( apply, f )
 end -- Unicode.sort()



 Unicode.testScripts = function ( assume, analyse )
 -- Check whether all chars match script
 -- Precondition:
 -- assume -- string, with expected script code
 -- analyse -- string or number or table, with text
 -- Postcondition:
 -- Returns
 -- 1. number, of chars matching assume
 -- 2. number, of chars violating assume
 local rA = 0
 local rX = 0
 local xx = { }
 local i = 1
 local cp, e, p
 Unicode.merge( xx, ISO15924.fetch( "unicodes" ), "*" )
 cp = Unicode.getScripts( xx, analyse, assume )
 while i <= #cp do
 e = cp[ i ]
 p = e[ 2 ]
 if type( p ) == "string" then
 if p == assume then
 rA = rA + 1
 elseif p == "Latn" then
 local j = Unicode.romanNumbers( cp, i )
 if j > i then
 i = j
 rX = rX - 1
 end
 rX = rX + 1
 end
 end
 i = i + 1
 end -- while i
 return rA, rX
 end -- Unicode.testScripts()



 ISO15924.fetch = function ( access, alert )
 -- Fetch mw.loadData component
 -- Precondition:
 -- access -- table name
 -- alert -- true, for throwing error on data problem
 -- Postcondition:
 -- Returns table
 local r = ISO15924[ access ]
 if type( r ) ~= "table" then
 local ext, s, sub
 if not ISO15924.config then
 ISO15924.config = true
 ISO15924.fetch( "config", alert ) -- self
 if ISO15924.config.live then
 ISO15924.statics = "commons"
 end
 end
 for i = 1, #ISO15924.Commons do
 s = ISO15924.Commons[ i ]
 if s == access then
 sub = ISO15924.statics
 break -- for i
 end
 end -- for i
 sub = sub or access
 ISO15924.loadData = ISO15924.loadData or { }
 if ISO15924.loadData[ sub ] then
 ext = ISO15924.loadData[ sub ]
 else
 ext = foreignModule( ISO15924.suite,
 false,
 sub,
 ISO15924.item,
 alert )
 ISO15924.loadData[ sub ] = ext
 end
 if type( ext ) == "table" then
 if type( ext[ access ] ) == "table" then
 r = ext[ access ]
 elseif sub == "config" then
 r = ext
 else
 r = { }
 end
 else
 r = { }
 end
 ISO15924[ access ] = r
 end
 return r
 end -- ISO15924.fetch()



 ISO15924.getLanguageScript = function ( ask )
 -- Retrieve primary script for language
 -- Precondition:
 -- ask -- string, with language code
 -- Returns string, with associated script code
 local r
 if type( ask ) == "string" then
 local s = ask
 local n = #s
 if n == 7 or n == 8 then
 r = s:match( "^%a%a%a?%-(%a%a%a%a)$" )
 if r then
 r = r:sub( 1, 1 ):upper() ..
 r:sub( 2 ):lower()
 end
 elseif n > 3 then
 s = s:match( "^(%a%a%a?)%-" )
 end
 if not r and s then
 local written = ISO15924.fetch( "iso639script" )
 if type( written ) == "table" then
 r = written[ s:lower() ]
 if type( r ) == "table" then
 r = r[ 1 ]
 end
 end
 end
 end
 return r or "Latn"
 end -- ISO15924.getLanguageScript()



 ISO15924.getScripts = function ( analyse )
 -- Retrieve codepoints and assigned script codes
 -- Precondition:
 -- analyse -- string or number or table, with text
 -- Returns table, with all relations codepoint / scripts
 local xx = { }
 Unicode.merge( xx, ISO15924.fetch( "unicodes" ), "*" )
 return Unicode.getScripts( xx, analyse, false )
 end -- ISO15924.getScripts()



 ISO15924.isCJK = function ( ask )
 -- Check whether script is Chinese-Japanese-Korean (CJK)
 -- Precondition:
 -- ask -- string, with language or script code
 -- Returns true, if CJK
 return fulfil( ask, "cjk" )
 end -- ISO15924.isCJK()



 ISO15924.isRTL = function ( ask )
 -- Check whether script is right-to-left
 -- Precondition:
 -- ask -- string, with language or script code
 -- Returns true, if right-to-left
 return fulfil( ask, "rtl" )
 end -- ISO15924.isRTL()



 ISO15924.isScript = function ( assume, analyse )
 -- Check all chars for expected script code ranges
 -- Precondition:
 -- assume -- string, with expected script code
 -- analyse -- string or number or table, with text
 -- Returns
 -- 1. true, if all chars within
 -- 2. analyse as table
 return Unicode.isScript( ISO15924.fetch( "unicodes" ),
 assume,
 analyse )
 end -- ISO15924.isScript()



 ISO15924.isTrans = function ( ask, assign, about )
 -- Check whether valid transcription for context
 -- Precondition:
 -- ask -- string, with transcription key
 -- assign -- string, with language or scripting code
 -- about -- string or nil, with site scripting code
 -- Postcondition:
 -- Returns boolean
 local r = false
 local t, trans
 local r, trsl
 if type( ask ) == "string" then
 local trans = ISO15924.fetch( "trans" )
 local t = trans[ assign ]
 if type( t ) == "table" then
 for k, v in pairs( t ) do
 if v == ask then
 r = true
 break -- for i
 end
 end -- for k, v
 end
 end
 if not r and about == "Latn" then
 r = ( ask == "BGN-PCGN" or ask == "ALA-LC" )
 end
 return r
 end -- ISO15924.isTrans()



 ISO15924.scriptName = function ( assigned, alien, add )
 -- Retrieve script name, hopefully linked
 -- Precondition:
 -- assigned -- string, with script code
 -- alien -- string, with language code, or not
 -- add -- arbitrary additional information
 -- Returns string
 return ISO15924.Text.scriptName( assigned, alien, add )
 end -- ISO15924.scriptName()



 ISO15924.showScript = function ( analyse )
 -- Retrieve assigned script code of first character
 -- Precondition:
 -- analyse -- string or number or table, with text
 -- Returns string, with every codepoint-script identified
 local xx = { }
 local cp, r
 Unicode.merge( xx, ISO15924.fetch( "unicodes" ), "*" )
 cp = Unicode.getScripts( xx, analyse, false )
 if #cp > 0 then
 local s = cp[ 1 ][ 2 ]
 if type( s ) == "string" then
 r = s
 end
 end
 return r or false
 end -- ISO15924.showScript()



 ISO15924.showScripts = function ( analyse )
 -- Retrieve codepoints and assigned script codes for and as string
 -- Precondition:
 -- analyse -- string or number or table, with text
 -- Returns string, with every codepoint-script identified
 local xx = { }
 local cp
 Unicode.merge( xx, ISO15924.fetch( "unicodes" ), "*" )
 cp = Unicode.getScripts( xx, analyse, false )
 return Unicode.showScripts( cp )
 end -- ISO15924.showScripts()



 ISO15924.testScripts = function ( assume, analyse )
 -- Check whether all chars match script
 -- Precondition:
 -- assume -- string, with expected script code
 -- analyse -- string or number or table, with text
 -- Postcondition:
 -- Returns
 -- 1. number, of chars matching assume
 -- 2. number, of chars violating assume
 return Unicode.testScripts( assume, analyse )
 end -- ISO15924.testScripts()



 Failsafe.failsafe = function ( atleast )
 -- Retrieve versioning and check for compliance
 -- Precondition:
 -- atleast -- string, with required version or "wikidata" or "~"
 -- or false
 -- Postcondition:
 -- Returns string -- with queried version, also if problem
 -- false -- if appropriate
 -- 2019年10月15日
 local last = ( atleast == "~" )
 local since = atleast
 local r
 if last or since == "wikidata" then
 local item = Failsafe.item
 since = false
 if type( item ) == "number" and item > 0 then
 local entity = mw.wikibase.getEntity( string.format( "Q%d",
 item ) )
 if type( entity ) == "table" then
 local seek = Failsafe.serialProperty or "P348"
 local vsn = entity:formatPropertyValues( seek )
 if type( vsn ) == "table" and
 type( vsn.value ) == "string" and
 vsn.value ~= "" then
 if last and vsn.value == Failsafe.serial then
 r = false
 else
 r = vsn.value
 end
 end
 end
 end
 end
 if type( r ) == "nil" then
 if not since or since <= Failsafe.serial then
 r = Failsafe.serial
 else
 r = false
 end
 end
 return r
 end -- Failsafe.failsafe()



 -- Export
 local p = { }

 p.getLanguageScript = function ( frame )
 local s = mw.text.trim( frame.args[ 1 ] or "" )
 return ISO15924.getLanguageScript( s )
 end -- p.getLanguageScript

 p.isCJK = function ( frame )
 local s = mw.text.trim( frame.args[ 1 ] or "" )
 return ISO15924.isCJK( s ) and "1" or ""
 end -- p.isCJK()

 p.isRTL = function ( frame )
 local s = mw.text.trim( frame.args[ 1 ] or "" )
 return ISO15924.isRTL( s ) and "1" or ""
 end -- p.isRTL()

 p.isScript = function ( frame )
 local s1 = mw.text.trim( frame.args[ 1 ] or "" )
 local s2 = mw.text.trim( frame.args[ 2 ] or "" )
 local r, cp = ISO15924.isScript( s1, s2 )
 return r and "1" or ""
 end -- p.isScript

 p.isTrans = function ( frame )
 -- Check whether valid transcription for context
 -- 1 -- string, with transcription key
 -- 2 -- string, with language or scripting code
 -- site -- string or nil, with site scripting code
 local s1 = mw.text.trim( frame.args[ 1 ] or "" )
 local s2 = mw.text.trim( frame.args[ 2 ] or "" )
 local site = mw.text.trim( frame.args.site or "" )
 return ISO15924.isTrans( s1, s2, site ) and "1" or ""
 end -- p.isTrans

 p.scriptName = function ( frame )
 local s1 = mw.text.trim( frame.args[ 1 ] or "" )
 local s2 = mw.text.trim( frame.args[ 2 ] or "" )
 local slang = mw.text.trim( frame.args.lang or "" )
 return ISO15924.Text.scriptName( s1, slang, s2 )
 end -- p.scriptName

 p.showScript = function ( frame )
 local s = frame.args[ 1 ]
 local r
 if s then
 s = mw.text.trim( s )
 if s ~= "" then
 if s:sub( 1, 2 ) == "U+" then
 s = s:match( "^U%+(%x+)$" )
 if s then
 s = tonumber( s, 16 )
 end
 end
 if s then
 r = ISO15924.showScript( s )
 end
 end
 end
 return r or ""
 end -- p.showScript

 p.showScripts = function ( frame )
 local s = frame.args[ 1 ]
 local r
 if s then
 r = ISO15924.showScripts( mw.text.trim( s ) )
 else
 r = ""
 end
 return r
 end -- p.showScripts

 p.failsafe = function ( frame )
 -- Versioning interface
 local s = type( frame )
 local since
 if s == "table" then
 since = frame.args[ 1 ]
 elseif s == "string" then
 since = frame
 end
 if since then
 since = mw.text.trim( since )
 if since == "" then
 since = false
 end
 end
 return Failsafe.failsafe( since ) or ""
 end -- p.failsafe()

 p.ISO15924 = function ()
 return ISO15924
 end -- p.ISO15924

 return p