Module:scripts: Difference between revisions
Jump to navigation
Jump to search
No edit summary |
No edit summary Tag: Reverted |
||
Line 1: | Line 1: | ||
local export = {} | local export = {} | ||
local Script = {} | local Script = {} | ||
--[==[Returns the script code of the language. Example: {{code|lua|"Cyrl"}} for Cyrillic.]==] | |||
function Script:getCode() | function Script:getCode() | ||
return self._code | return self._code | ||
end | end | ||
--[==[Returns the canonical name of the script. This is the name used to represent that script on Wiktionary. Example: {{code|lua|"Cyrillic"}} for Cyrillic.]==] | |||
function Script:getCanonicalName() | function Script:getCanonicalName() | ||
return self._rawData.canonicalName | return self._rawData[1] or self._rawData.canonicalName | ||
end | end | ||
--[==[Returns the display form of the script. For scripts, this is the same as the value returned by <code>:getCategoryName("nocap")</code>, i.e. it reads "NAME script" (e.g. {{code|lua|"Arabic script"}}). For regular and etymology languages, this is the same as the canonical name, and for families, it reads "NAME languages" (e.g. {{code|lua|"Indo-Iranian languages"}}). The displayed text used in <code>:makeCategoryLink</code> is always the same as the display form.]==] | |||
function Script:getDisplayForm() | function Script:getDisplayForm() | ||
return self:getCategoryName("nocap") | return self:getCategoryName("nocap") | ||
end | end | ||
Line 31: | Line 30: | ||
end | end | ||
--[==[Returns the parent of the script. Example: {{code|lua|"Latn"}} for {{code|lua|"Latnx"}} and {{code|lua|"Arab"}} for {{code|lua|"fa-Arab"}}. It returns {{code|lua|"top"}} for scripts without a parent, like {{code|lua|"Latn"}}, {{code|lua|"Grek"}}, etc.]==] | |||
function Script:getParent() | function Script:getParent() | ||
return self._rawData.parent | return self._rawData.parent | ||
end | |||
function Script:getSystemCodes() | |||
if not self._systemCodes then | |||
if type(self._rawData[2]) == "table" then | |||
self._systemCodes = self._rawData[2] | |||
elseif type(self._rawData[2]) == "string" then | |||
self._systemCodes = mw.text.split(self._rawData[2], "%s*,%s*") | |||
else | |||
self._systemCodes = {} | |||
end | |||
end | |||
return self._systemCodes | |||
end | end | ||
Line 40: | Line 53: | ||
self._systemObjects = {} | self._systemObjects = {} | ||
for _, | for _, ws in ipairs(self:getSystemCodes()) do | ||
table.insert(self._systemObjects, m_systems.getByCode( | table.insert(self._systemObjects, m_systems.getByCode(ws)) | ||
end | end | ||
end | end | ||
Line 52: | Line 65: | ||
--end | --end | ||
--[==[Given a list of types as strings, returns true if the script has all of them. Possible types are explained in [[Module:scripts/data]].]==] | |||
function Script: | function Script:hasType(...) | ||
if not self._type then | |||
self._type = {script = true} | |||
if self._rawData.type then | |||
for _, type in ipairs(mw.text.split(self._rawData.type, "%s*,%s*")) do | |||
self._type[type] = true | |||
end | |||
end | |||
end | |||
for _, type in ipairs{...} do | |||
if not self._type[type] then | |||
return false | |||
end | |||
end | |||
return true | |||
end | end | ||
--[==[Returns the name of the main category of that script. Example: {{code|lua|"Cyrillic script"}} for Cyrillic, whose category is at [[:Category:Cyrillic script]]. | |||
Unless optional argument <code>nocap</code> is given, the script name at the beginning of the returned value will be capitalized. This capitalization is correct for category names, but not if the script name is lowercase and the returned value of this function is used in the middle of a sentence. (For example, the script with the code <code>Semap</code> has the name <code>"flag semaphore"</code>, which should remain lowercase when used as part of the category name [[:Category:Translingual letters in flag semaphore]] but should be capitalized in [[:Category:Flag semaphore templates]].) If you are considering using <code>getCategoryName("nocap")</code>, use <code>getDisplayForm()</code> instead.]==] | |||
function Script:getCategoryName(nocap) | function Script:getCategoryName(nocap) | ||
local name = self._rawData.canonicalName | local name = self._rawData[1] or self._rawData.canonicalName | ||
-- If the name already has "code" or "semaphore" in it, don't add it. | -- If the name already has "code" or "semaphore" in it, don't add it. | ||
Line 71: | Line 98: | ||
return name | return name | ||
end | end | ||
function Script:makeCategoryLink() | function Script:makeCategoryLink() | ||
Line 77: | Line 103: | ||
end | end | ||
--[==[Returns the {{code|lua|wikipedia_article}} item in the language's data file, or else calls {{code|lua|Script:getCategoryName()}}.]==] | |||
function Script:getWikipediaArticle() | function Script:getWikipediaArticle() | ||
return self._rawData.wikipedia_article or self:getCategoryName() | return self._rawData.wikipedia_article or self:getCategoryName() | ||
end | end | ||
--[==[Returns the regex defining the script's characters from the language's data file. | |||
This can be used to search for words consisting only of this script, but see the warning above.]==] | |||
function Script:getCharacters() | function Script:getCharacters() | ||
if self._rawData.characters then | if self._rawData.characters then | ||
Line 91: | Line 118: | ||
end | end | ||
--[==[Returns the number of characters in the text that are part of this script. | |||
'''Note:''' You should never rely on text consisting entirely of the same script. Strings may contain spaces, punctuation and even wiki markup or HTML tags. HTML tags will skew the counts, as they contain Latin-script characters. So it's best to avoid them.]==] | |||
function Script:countCharacters(text) | function Script:countCharacters(text) | ||
if not self._rawData.characters then | if not self._rawData.characters then | ||
return 0 | return 0 | ||
-- Due to the number of Chinese characters, a different determination method is used when differentiating between traditional ("Hant") and simplified ("Hans") Chinese. | |||
elseif self:getCode() == "Hant" or self:getCode() == "Hans" then | |||
local charData, num = self:getCode() == "Hant" and require("Module:zh/data/ts/serialized") or require("Module:zh/data/st/serialized"), 0 | |||
charData = charData:sub(1, charData:len() / 2) | |||
for char in text:gmatch("[\194-\244][\128-\191]*") do | |||
if charData:find(char) then | |||
num = num + 1 | |||
end | |||
end | |||
return num | |||
else | else | ||
local _, num = mw.ustring.gsub(text, "[" .. self._rawData.characters .. "]", "") | local _, num = mw.ustring.gsub(text, "[" .. self._rawData.characters .. "]", "") | ||
Line 101: | Line 139: | ||
end | end | ||
function Script:hasCapitalization() | |||
return not not self._rawData.capitalized | |||
end | |||
function Script:hasSpaces() | |||
return self._rawData.spaces ~= false | |||
end | |||
function Script:isTransliterated() | |||
return self._rawData.translit ~= false | |||
end | |||
--[==[Returns true if the script is (sometimes) sorted by scraping page content, meaning that it is sensitive to changes in capitalization during sorting.]==] | |||
function Script:sortByScraping() | |||
return not not self._rawData.sort_by_scraping | |||
end | |||
--[==[Returns the text direction, if any. Currently, left-to-right scripts are unmarked, while most right-to-left scripts have direction specified as {{code|lua|"rtl"}} and Mongolian as {{code|lua|"down"}}.]==] | |||
function Script:getDirection() | function Script:getDirection() | ||
return self._rawData.direction | |||
end | end | ||
Line 115: | Line 166: | ||
end | end | ||
--[==[Returns {{code|lua|true}} if the script contains characters that require fixes to Unicode normalization under certain circumstances, {{code|lua|false}} if it doesn't.]==] | |||
function Script:hasNormalizationFixes() | |||
return not not self._rawData.normalizationFixes | |||
end | |||
--[==[Corrects discouraged sequences of Unicode characters to the encouraged equivalents.]==] | |||
function Script:fixDiscouragedSequences(text) | |||
if self:hasNormalizationFixes() and self._rawData.normalizationFixes.from then | |||
local gsub = require("Module:string utilities").gsub | |||
for i, from in ipairs(self._rawData.normalizationFixes.from) do | |||
text = gsub(text, from, self._rawData.normalizationFixes.to[i] or "") | |||
end | |||
end | |||
return text | |||
end | |||
-- Implements a modified form of Unicode normalization for instances where there are identified deficiencies in the default Unicode combining classes. | |||
local function fixNormalization(text, self) | |||
if self:hasNormalizationFixes() and self._rawData.normalizationFixes.combiningClasses then | |||
local combiningClassFixes = self._rawData.normalizationFixes.combiningClasses | |||
local charsToFix = table.concat(require("Module:table").keysToList(combiningClassFixes)) | |||
if require("Module:string utilities").match(text, "[" .. charsToFix .. "]") then | |||
local codepoint, u = mw.ustring.codepoint, mw.ustring.char | |||
-- Obtain the list of default combining classes. | |||
local combiningClasses = mw.loadData("Module:scripts/data/combiningClasses") | |||
-- For each character that needs fixing, find all characters with combining classes equal to or lower than its default class, but greater than its new class (i.e. intermediary characters). | |||
for charToFix, newCombiningClass in pairs(combiningClassFixes) do | |||
local intermediaryChars = {} | |||
for character, combiningClass in pairs(combiningClasses) do | |||
if newCombiningClass < combiningClass and combiningClass <= combiningClasses[codepoint(charToFix)] then | |||
table.insert(intermediaryChars, u(character)) | |||
end | |||
end | |||
-- Swap the character with any intermediary characters that are immediately before it. | |||
text = require("Module:string utilities").gsub(text, "([" .. table.concat(intermediaryChars) .. "]+)(" .. charToFix .. ")", "%2%1") | |||
end | |||
end | |||
end | |||
return text | |||
end | |||
function Script:toFixedNFC(text) | |||
return fixNormalization(mw.ustring.toNFC(text), self) | |||
end | |||
function Script:toFixedNFD(text) | |||
return fixNormalization(mw.ustring.toNFD(text), self) | |||
end | |||
function Script:toFixedNFKC(text) | |||
return fixNormalization(mw.ustring.toNFKC(text), self) | |||
end | |||
function Script:toFixedNFKD(text) | |||
return fixNormalization(mw.ustring.toNFKD(text), self) | |||
end | |||
function Script:toJSON() | function Script:toJSON() | ||
if not self._type then | |||
self:hasType() | |||
end | |||
local types = {} | |||
for type in pairs(self._type) do | |||
table.insert(types, type) | |||
end | |||
local ret = { | local ret = { | ||
canonicalName = self:getCanonicalName(), | canonicalName = self:getCanonicalName(), | ||
categoryName = self:getCategoryName("nocap"), | categoryName = self:getCategoryName("nocap"), | ||
code = self | code = self:getCode(), | ||
otherNames = self:getOtherNames(true), | otherNames = self:getOtherNames(true), | ||
aliases = self:getAliases(), | aliases = self:getAliases(), | ||
varieties = self:getVarieties(), | varieties = self:getVarieties(), | ||
type = | type = types, | ||
direction = self:getDirection(), | direction = self:getDirection(), | ||
characters = self:getCharacters(), | characters = self:getCharacters(), | ||
parent = self:getParent(), | parent = self:getParent(), | ||
systems = self | systems = self:getSystemCodes(), | ||
wikipediaArticle = self._rawData.wikipedia_article, | wikipediaArticle = self._rawData.wikipedia_article, | ||
} | } | ||
Line 134: | Line 249: | ||
return require("Module:JSON").toJSON(ret) | return require("Module:JSON").toJSON(ret) | ||
end | end | ||
Script.__index = Script | Script.__index = Script | ||
function export.makeObject(code, data, useRequire) | |||
function export.makeObject(code, data) | return data and setmetatable({_rawData = data, _code = code}, Script) or nil | ||
return data and setmetatable({ _rawData = data, _code = code }, Script) or nil | |||
end | end | ||
-- Temporary aliases from canonicalized names to (existing) anomalous names. Once we have converted everything we will | |||
-- rename the scripts and remove the alias code. | |||
local scriptAliases = { | |||
-- scripts already renamed; we now alias the old names to the new ones | |||
["IPAchar"] = "Ipach", | |||
["musical"] = "Music", | |||
["Ruminumerals"] = "Rumin", | |||
["polytonic"] = "Polyt", | |||
["Latinx"] = "Latnx", | |||
} | |||
function export.getByCode(code, paramForError, disallowNil) | --[==[Finds the script whose code matches the one provided. If it exists, it returns a {{code|lua|Script}} object representing the script. Otherwise, it returns {{code|lua|nil}}, unless <span class="n">paramForError</span> is given, in which case an error is generated. If <code class="n">paramForError</code> is {{code|lua|true}}, a generic error message mentioning the bad code is generated; otherwise <code class="n">paramForError</code> should be a string or number specifying the parameter that the code came from, and this parameter will be mentioned in the error message along with the bad code.]==] | ||
function export.getByCode(code, paramForError, disallowNil, useRequire) | |||
if code == nil and not disallowNil then | if code == nil and not disallowNil then | ||
return nil | return nil | ||
end | end | ||
code = scriptAliases[code] or code | |||
if | local data | ||
if useRequire then | |||
data = require("Module:scripts/data")[code] | |||
else | |||
data = mw.loadData("Module:scripts/data")[code] | |||
end | end | ||
local retval = export.makeObject(code, data, useRequire) | |||
if not retval and paramForError then | |||
require("Module:languages/error")(code, paramForError, "script code", nil, "not real lang") | |||
if not | |||
end | end | ||
return retval | |||
end | end | ||
function export.getByCanonicalName(name, useRequire) | |||
local code | |||
if useRequire then | |||
local | code = require("Module:scripts/by name")[name] | ||
else | |||
code = mw.loadData("Module:scripts/by name")[name] | |||
end | end | ||
return export.getByCode(code, nil, nil, useRequire) | |||
end | end | ||
--[==[ | |||
-- | |||
Takes a codepoint or a character and finds the script code (if any) that is | Takes a codepoint or a character and finds the script code (if any) that is | ||
appropriate for it based on the codepoint, using the data module | appropriate for it based on the codepoint, using the data module | ||
Line 268: | Line 310: | ||
is in the list of individual characters, or if it is in one of the defined | is in the list of individual characters, or if it is in one of the defined | ||
ranges in the 4096-character block that it belongs to, else returns "None". | ranges in the 4096-character block that it belongs to, else returns "None". | ||
]=] | ]==] | ||
function export.charToScript(char) | function export.charToScript(char) | ||
return require("Module:scripts/charToScript").charToScript(char) | |||
end | end | ||
--[==[Returns the code for the script that has the greatest number of characters in <code>text</code>. Useful for script tagging text that is unspecified for language. Uses [[Module:scripts/recognition data]] to determine a script code for a character language-agnostically.]==] | |||
function export.findBestScriptWithoutLang(text) | function export.findBestScriptWithoutLang(text) | ||
return require("Module:scripts/charToScript").findBestScriptWithoutLang(text) | |||
end | end | ||
return export | return export |
Revision as of 14:01, 29 July 2023
- The following documentation is located at Module:scripts/doc.[edit]
- Useful links: subpage list • links • transclusions • testcases • sandbox
local export = {}
local Script = {}
--[==[Returns the script code of the language. Example: {{code|lua|"Cyrl"}} for Cyrillic.]==]
function Script:getCode()
return self._code
end
--[==[Returns the canonical name of the script. This is the name used to represent that script on Wiktionary. Example: {{code|lua|"Cyrillic"}} for Cyrillic.]==]
function Script:getCanonicalName()
return self._rawData[1] or self._rawData.canonicalName
end
--[==[Returns the display form of the script. For scripts, this is the same as the value returned by <code>:getCategoryName("nocap")</code>, i.e. it reads "NAME script" (e.g. {{code|lua|"Arabic script"}}). For regular and etymology languages, this is the same as the canonical name, and for families, it reads "NAME languages" (e.g. {{code|lua|"Indo-Iranian languages"}}). The displayed text used in <code>:makeCategoryLink</code> is always the same as the display form.]==]
function Script:getDisplayForm()
return self:getCategoryName("nocap")
end
function Script:getOtherNames(onlyOtherNames)
return require("Module:language-like").getOtherNames(self, onlyOtherNames)
end
function Script:getAliases()
return self._rawData.aliases or {}
end
function Script:getVarieties(flatten)
return require("Module:language-like").getVarieties(self, flatten)
end
--[==[Returns the parent of the script. Example: {{code|lua|"Latn"}} for {{code|lua|"Latnx"}} and {{code|lua|"Arab"}} for {{code|lua|"fa-Arab"}}. It returns {{code|lua|"top"}} for scripts without a parent, like {{code|lua|"Latn"}}, {{code|lua|"Grek"}}, etc.]==]
function Script:getParent()
return self._rawData.parent
end
function Script:getSystemCodes()
if not self._systemCodes then
if type(self._rawData[2]) == "table" then
self._systemCodes = self._rawData[2]
elseif type(self._rawData[2]) == "string" then
self._systemCodes = mw.text.split(self._rawData[2], "%s*,%s*")
else
self._systemCodes = {}
end
end
return self._systemCodes
end
function Script:getSystems()
if not self._systemObjects then
local m_systems = require("Module:writing systems")
self._systemObjects = {}
for _, ws in ipairs(self:getSystemCodes()) do
table.insert(self._systemObjects, m_systems.getByCode(ws))
end
end
return self._systemObjects
end
--function Script:getAllNames()
-- return self._rawData.names
--end
--[==[Given a list of types as strings, returns true if the script has all of them. Possible types are explained in [[Module:scripts/data]].]==]
function Script:hasType(...)
if not self._type then
self._type = {script = true}
if self._rawData.type then
for _, type in ipairs(mw.text.split(self._rawData.type, "%s*,%s*")) do
self._type[type] = true
end
end
end
for _, type in ipairs{...} do
if not self._type[type] then
return false
end
end
return true
end
--[==[Returns the name of the main category of that script. Example: {{code|lua|"Cyrillic script"}} for Cyrillic, whose category is at [[:Category:Cyrillic script]].
Unless optional argument <code>nocap</code> is given, the script name at the beginning of the returned value will be capitalized. This capitalization is correct for category names, but not if the script name is lowercase and the returned value of this function is used in the middle of a sentence. (For example, the script with the code <code>Semap</code> has the name <code>"flag semaphore"</code>, which should remain lowercase when used as part of the category name [[:Category:Translingual letters in flag semaphore]] but should be capitalized in [[:Category:Flag semaphore templates]].) If you are considering using <code>getCategoryName("nocap")</code>, use <code>getDisplayForm()</code> instead.]==]
function Script:getCategoryName(nocap)
local name = self._rawData[1] or self._rawData.canonicalName
-- If the name already has "code" or "semaphore" in it, don't add it.
-- No names contain "script".
if not name:find("[Cc]ode$") and not name:find("[Ss]emaphore$") then
name = name .. " script"
end
if not nocap then
name = mw.getContentLanguage():ucfirst(name)
end
return name
end
function Script:makeCategoryLink()
return "[[:Category:" .. self:getCategoryName() .. "|" .. self:getDisplayForm() .. "]]"
end
--[==[Returns the {{code|lua|wikipedia_article}} item in the language's data file, or else calls {{code|lua|Script:getCategoryName()}}.]==]
function Script:getWikipediaArticle()
return self._rawData.wikipedia_article or self:getCategoryName()
end
--[==[Returns the regex defining the script's characters from the language's data file.
This can be used to search for words consisting only of this script, but see the warning above.]==]
function Script:getCharacters()
if self._rawData.characters then
return self._rawData.characters
else
return nil
end
end
--[==[Returns the number of characters in the text that are part of this script.
'''Note:''' You should never rely on text consisting entirely of the same script. Strings may contain spaces, punctuation and even wiki markup or HTML tags. HTML tags will skew the counts, as they contain Latin-script characters. So it's best to avoid them.]==]
function Script:countCharacters(text)
if not self._rawData.characters then
return 0
-- Due to the number of Chinese characters, a different determination method is used when differentiating between traditional ("Hant") and simplified ("Hans") Chinese.
elseif self:getCode() == "Hant" or self:getCode() == "Hans" then
local charData, num = self:getCode() == "Hant" and require("Module:zh/data/ts/serialized") or require("Module:zh/data/st/serialized"), 0
charData = charData:sub(1, charData:len() / 2)
for char in text:gmatch("[\194-\244][\128-\191]*") do
if charData:find(char) then
num = num + 1
end
end
return num
else
local _, num = mw.ustring.gsub(text, "[" .. self._rawData.characters .. "]", "")
return num
end
end
function Script:hasCapitalization()
return not not self._rawData.capitalized
end
function Script:hasSpaces()
return self._rawData.spaces ~= false
end
function Script:isTransliterated()
return self._rawData.translit ~= false
end
--[==[Returns true if the script is (sometimes) sorted by scraping page content, meaning that it is sensitive to changes in capitalization during sorting.]==]
function Script:sortByScraping()
return not not self._rawData.sort_by_scraping
end
--[==[Returns the text direction, if any. Currently, left-to-right scripts are unmarked, while most right-to-left scripts have direction specified as {{code|lua|"rtl"}} and Mongolian as {{code|lua|"down"}}.]==]
function Script:getDirection()
return self._rawData.direction
end
function Script:getRawData()
return self._rawData
end
--[==[Returns {{code|lua|true}} if the script contains characters that require fixes to Unicode normalization under certain circumstances, {{code|lua|false}} if it doesn't.]==]
function Script:hasNormalizationFixes()
return not not self._rawData.normalizationFixes
end
--[==[Corrects discouraged sequences of Unicode characters to the encouraged equivalents.]==]
function Script:fixDiscouragedSequences(text)
if self:hasNormalizationFixes() and self._rawData.normalizationFixes.from then
local gsub = require("Module:string utilities").gsub
for i, from in ipairs(self._rawData.normalizationFixes.from) do
text = gsub(text, from, self._rawData.normalizationFixes.to[i] or "")
end
end
return text
end
-- Implements a modified form of Unicode normalization for instances where there are identified deficiencies in the default Unicode combining classes.
local function fixNormalization(text, self)
if self:hasNormalizationFixes() and self._rawData.normalizationFixes.combiningClasses then
local combiningClassFixes = self._rawData.normalizationFixes.combiningClasses
local charsToFix = table.concat(require("Module:table").keysToList(combiningClassFixes))
if require("Module:string utilities").match(text, "[" .. charsToFix .. "]") then
local codepoint, u = mw.ustring.codepoint, mw.ustring.char
-- Obtain the list of default combining classes.
local combiningClasses = mw.loadData("Module:scripts/data/combiningClasses")
-- For each character that needs fixing, find all characters with combining classes equal to or lower than its default class, but greater than its new class (i.e. intermediary characters).
for charToFix, newCombiningClass in pairs(combiningClassFixes) do
local intermediaryChars = {}
for character, combiningClass in pairs(combiningClasses) do
if newCombiningClass < combiningClass and combiningClass <= combiningClasses[codepoint(charToFix)] then
table.insert(intermediaryChars, u(character))
end
end
-- Swap the character with any intermediary characters that are immediately before it.
text = require("Module:string utilities").gsub(text, "([" .. table.concat(intermediaryChars) .. "]+)(" .. charToFix .. ")", "%2%1")
end
end
end
return text
end
function Script:toFixedNFC(text)
return fixNormalization(mw.ustring.toNFC(text), self)
end
function Script:toFixedNFD(text)
return fixNormalization(mw.ustring.toNFD(text), self)
end
function Script:toFixedNFKC(text)
return fixNormalization(mw.ustring.toNFKC(text), self)
end
function Script:toFixedNFKD(text)
return fixNormalization(mw.ustring.toNFKD(text), self)
end
function Script:toJSON()
if not self._type then
self:hasType()
end
local types = {}
for type in pairs(self._type) do
table.insert(types, type)
end
local ret = {
canonicalName = self:getCanonicalName(),
categoryName = self:getCategoryName("nocap"),
code = self:getCode(),
otherNames = self:getOtherNames(true),
aliases = self:getAliases(),
varieties = self:getVarieties(),
type = types,
direction = self:getDirection(),
characters = self:getCharacters(),
parent = self:getParent(),
systems = self:getSystemCodes(),
wikipediaArticle = self._rawData.wikipedia_article,
}
return require("Module:JSON").toJSON(ret)
end
Script.__index = Script
function export.makeObject(code, data, useRequire)
return data and setmetatable({_rawData = data, _code = code}, Script) or nil
end
-- Temporary aliases from canonicalized names to (existing) anomalous names. Once we have converted everything we will
-- rename the scripts and remove the alias code.
local scriptAliases = {
-- scripts already renamed; we now alias the old names to the new ones
["IPAchar"] = "Ipach",
["musical"] = "Music",
["Ruminumerals"] = "Rumin",
["polytonic"] = "Polyt",
["Latinx"] = "Latnx",
}
--[==[Finds the script whose code matches the one provided. If it exists, it returns a {{code|lua|Script}} object representing the script. Otherwise, it returns {{code|lua|nil}}, unless <span class="n">paramForError</span> is given, in which case an error is generated. If <code class="n">paramForError</code> is {{code|lua|true}}, a generic error message mentioning the bad code is generated; otherwise <code class="n">paramForError</code> should be a string or number specifying the parameter that the code came from, and this parameter will be mentioned in the error message along with the bad code.]==]
function export.getByCode(code, paramForError, disallowNil, useRequire)
if code == nil and not disallowNil then
return nil
end
code = scriptAliases[code] or code
local data
if useRequire then
data = require("Module:scripts/data")[code]
else
data = mw.loadData("Module:scripts/data")[code]
end
local retval = export.makeObject(code, data, useRequire)
if not retval and paramForError then
require("Module:languages/error")(code, paramForError, "script code", nil, "not real lang")
end
return retval
end
function export.getByCanonicalName(name, useRequire)
local code
if useRequire then
code = require("Module:scripts/by name")[name]
else
code = mw.loadData("Module:scripts/by name")[name]
end
return export.getByCode(code, nil, nil, useRequire)
end
--[==[
Takes a codepoint or a character and finds the script code (if any) that is
appropriate for it based on the codepoint, using the data module
[[Module:scripts/recognition data]]. The data module was generated from the
patterns in [[Module:scripts/data]] using [[Module:User:Erutuon/script recognition]].
Converts the character to a codepoint. Returns a script code if the codepoint
is in the list of individual characters, or if it is in one of the defined
ranges in the 4096-character block that it belongs to, else returns "None".
]==]
function export.charToScript(char)
return require("Module:scripts/charToScript").charToScript(char)
end
--[==[Returns the code for the script that has the greatest number of characters in <code>text</code>. Useful for script tagging text that is unspecified for language. Uses [[Module:scripts/recognition data]] to determine a script code for a character language-agnostically.]==]
function export.findBestScriptWithoutLang(text)
return require("Module:scripts/charToScript").findBestScriptWithoutLang(text)
end
return export