local export =
local Script =
--[==[Returns the script code of the language. Example: {{code|lua|"Cyrl"}} for Cyrillic.]
--[==[Returns the canonical name of the script. This is the name used to represent that script on Wiktionary. Example: {{code|lua|"Cyrillic"}} for Cyrillic.]
--[==[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: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:getSystemCodes if not self._systemCodes then if type(self._rawData[2])
"string" then self._systemCodes = mw.text.split(self._rawData[2], "%s*,%s*") else self._systemCodes = end end return self._systemCodesend
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._systemObjectsend
--function Script:getAllNames-- return self._rawData.names--end
--[==[Given a list of types as strings, returns true if the script has all of them. Currently the only possible type is {script}; use {{lua|hasType("script")}} to determine if an object that may be a language, family or script is a script. ]
--[==[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 nocap 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 Semap has the name "flag semaphore", which should remain lowercase when used as part of the category name but should be capitalized in .) If you are considering using getCategoryName("nocap"), use getDisplayForm instead.]
function Script:makeCategoryLink return "" .. self:getDisplayForm .. ""end
--[==[Returns the {{code|lua|wikipedia_article}} item in the language's data file, or else calls {{code|lua|Script:getCategoryName}}.]
--[==[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.]
--[==[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.]
"Hant" or self:getCode
"Hant" and mw.loadData("Module:zh/data/ts") or mw.loadData("Module:zh/data/st") for char in text:gmatch("[\194-\244][\128-\191]*") do num = num + (charData[char] and 1 or 0) end return num end return select(2, mw.ustring.gsub(text, "[" .. self._rawData.characters .. "]", ""))end
function Script:hasCapitalization return not not self._rawData.capitalizedend
function Script:hasSpaces return self._rawData.spaces ~= falseend
function Script:isTransliterated return self._rawData.translit ~= falseend
--[==[Returns true if the script is (sometimes) sorted by scraping page content, meaning that it is sensitive to changes in capitalization during sorting.]
--[==[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:getRawData return self._rawDataend
--[==[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.]
--[==[Corrects discouraged sequences of Unicode characters to the encouraged equivalents.]
-- 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 textend
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 = return require("Module:JSON").toJSON(ret)end
Script.__index = Script function export.makeObject(code, data, useRequire) return data and setmetatable(Script) or nilend
-- Track scripts with anomalous names.local scriptsToTrack =
-- 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 =
--[==[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.]
nil and not disallowNil then return nil end if scriptsToTrack[code] then require("Module:debug/track")("scripts/" .. code) 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 retvalend
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 using .
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".]
--[==[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.]
return export