ဝိက်ရှေန်နရဳ

မဝ်ဂျူ:scripts: အရာမတၞဟ်ခြာ အကြာ မူတၞဟ်ဂမၠိုင်

ရာဇဝင်ကို အပြန်အလှန်အားဖြင့် ဝင်ကြည့်ရန်
← အရာမပလေဝ်ဒါန်လဝ် တြေံမပလေဝ်ဒါန်လဝ် တၟိနူဂှ် →
Content deleted Content added
咽頭べさ (ဆွေးနွေး) ၏ တည်းဖြတ်မူ 66388 ကို ပြန်လည်ပယ်ဖျက်လိုက်သည်
ဒစင်: ဟွံပ
No edit summary
ဒစင်: မကလေၚ်ပလေဝ်ဒါန်လဝ်
လာင် ၁-
local m_str_utils = require("Module:string utilities")
 
local codepoint = m_str_utils.codepoint
local gsplit = m_str_utils.gsplit
local select = select
local split = m_str_utils.split
local toNFC = mw.ustring.toNFC
local toNFD = mw.ustring.toNFD
local toNFKC = mw.ustring.toNFKC
local toNFKD = mw.ustring.toNFKD
local type = type
local u = m_str_utils.char
local ugsub = m_str_utils.gsub
local umatch = m_str_utils.match
 
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
 
Line ၂၆ ⟶ ၄၅:
end
 
--[==[Returns the parent of the script. Example: {{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 = split(self._rawData[2], "%s*,%s*", true)
else
self._systemCodes = {}
end
end
return self._systemCodes
end
 
Line ၃၅ ⟶ ၆၈:
self._systemObjects = {}
for _, sysws in ipairs(self._rawData.systems or {}:getSystemCodes()) do
table.insert(self._systemObjects, m_systems.getByCode(sysws))
end
end
return self._systemObjects
end
 
--[==[Check whether the script is of type `system`, which can be a writing system code or object. If multiple systems are passed, return true if the script is any of the specified systems.]==]
function Script:isSystem(...)
for _, system in ipairs{...} do
if type(system) == "table" then
system = system:getCode()
end
for _, s in ipairs(self:getSystemCodes()) do
if system == s then
return true
end
end
end
return false
end
 
Line ၄၇ ⟶ ၉၅:
--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
function Script:getType()
may be a language, family or script is a script.
return "script"
]==]
function Script:hasType(...)
local types = self._types
if types == nil then
types = {script = true}
local rawtypes = self._rawData.type
if rawtypes then
for rawtype in gsplit(rawtypes, "%s*,%s*", true) do
types[rawtype] = true
end
end
self._types = types
end
for i = 1, arg.n do
if not types[arg[i]] 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()
function Script:getCategoryName(nocap)
local name = self._rawData.canonicalName
local name = self._rawData[1] or self._rawData.canonicalName
--[[ not use in Thai
-- If the name already has "script", "code" or "semaphore" inat the itend, don't add it.
if not (
-- No names contain "script".
if name:find("[Cc %-]ode$") or name:find("[Ss]emaphorecript$") thenor
name:find("[ %-][Cc]ode$") or
return name
name:find("[ %-][Ss]emaphore$")
else
) then
return "အက္ခရ်" .. name
name = name .. " script"
end
if not nocap then
name = mw.getContentLanguage():ucfirst(name)
end
--]]
if not (
name:find("^အက္ခရ်") or
name:find("^code") or
name:find("^signal")
) then
name = "အက္ခရ်" .. name
end
return name
end
 
 
function Script:makeCategoryLink()
Line ၇၀ ⟶ ၁၅၂:
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 charset 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()
ifreturn self._rawData.characters thenor nil
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 assume that text consists 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)
iflocal notcharset = self._rawData.characters then
if charset == nil then
return 0
else
local _, num = mw.ustring.gsub(text, "[" .. self._rawData.characters .. "]", "")
return num
end
return select(2, ugsub(text, "[" .. charset .. "]", ""))
end
 
function Script:getDirectionhasCapitalization()
localreturn directionnot =not self._rawData.directioncapitalized
end
if not direction then
 
return nil
function Script:hasSpaces()
else
return self._rawData.spaces ~= false
return direction
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. Horizontal scripts return {{code|lua|"ltr"}} (left-to-right) or {{code|lua|"rtl"}} (right-to-left), while vertical scripts return {{code|lua|"vertical-ltr"}} (vertical left-to-right) or {{code|lua|"vertical-rtl"}} (vertical right-to-left).]==]
function Script:getDirection()
return self._rawData.direction or "ltr"
end
 
function Script:getRawData()
Line ၁၀၈ ⟶ ၁၉၉:
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
for i, from in ipairs(self._rawData.normalizationFixes.from) do
text = ugsub(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 umatch(text, "[" .. charsToFix .. "]") then
-- 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 = ugsub(text, "([" .. table.concat(intermediaryChars) .. "]+)(" .. charToFix .. ")", "%2%1")
end
end
end
return text
end
 
function Script:toFixedNFC(text)
return fixNormalization(toNFC(text), self)
end
 
function Script:toFixedNFD(text)
return fixNormalization(toNFD(text), self)
end
 
function Script:toFixedNFKC(text)
return fixNormalization(toNFKC(text), self)
end
 
function Script:toFixedNFKD(text)
return fixNormalization(toNFKD(text), self)
end
 
function Script:toJSON()
if not self._types then
self:hasType()
end
local types = {}
for type in pairs(self._types) do
table.insert(types, type)
end
local ret = {
canonicalName = self:getCanonicalName(),
categoryName = self:getCategoryName("nocap"),
code = self._code:getCode(),
otherNames = self:getOtherNames(true),
aliases = self:getAliases(),
varieties = self:getVarieties(),
type = self:getType()types,
direction = self:getDirection(),
characters = self:getCharacters(),
parent = self:getParent(),
systems = self._rawData.systems or {}:getSystemCodes(),
wikipediaArticle = self._rawData.wikipedia_article,
}
Line ၁၂၇ ⟶ ၂၈၀:
return require("Module:JSON").toJSON(ret)
end
 
 
Script.__index = Script
function export.makeObject(code, data, useRequire)
return data and setmetatable({
_rawData = data,
_code = code,
characters = data.characters
}, Script) or nil
end
 
-- Track scripts with anomalous names.
local scriptsToTrack = {
-- scripts already renamed
["IPAchar"] = true,
["musical"] = true,
["Ruminumerals"] = true,
["polytonic"] = true,
-- scripts not yet renamed
["Latinx"] = true,
["Latnx"] = true,
}
 
-- Temporary aliases from canonicalized names to (existing) anomalous names. Once we have converted everything we will
function export.makeObject(code, data)
-- rename the scripts and remove the alias code.
return data and setmetatable({ _rawData = data, _code = code }, Script) or nil
local scriptAliases = {
end
-- scripts already renamed; we now alias the old names to the new ones
["IPAchar"] = "Ipach",
["musical"] = "Music",
["Ruminumerals"] = "Rumin",
["polytonic"] = "Polyt",
["Latinx"] = "Latn",
["Latnx"] = "Latn",
}
 
--[==[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)
-- Track uses of paramForError, ultimately so it can be removed, as error-handling should be done by [[Module:parameters]], not here.
if code == nil and not disallowNil then
if paramForError ~= nil then
return nil
require("Module:debug/track")("scripts/paramForError")
end
if code == "IPAchar" then
require("Module:debug").track("IPAchar")
end
local retval = export.makeObject(code, mw.loadData("Module:scripts/data")[code])
if not retval and paramForError then
require("Module:languages").err(code, paramForError, "script code", nil, "not real lang")
end
return retval
end
 
function export.getByCanonicalName(name)
local code = mw.loadData("Module:scripts/by name")[name]
if code == nil and not codedisallowNil then
return nil
end
if scriptsToTrack[code] then
require("Module:debug/track")("scripts/" .. code)
return export.makeObject(code, mw.loadData("Module:scripts/data")[code])
end
 
-- Find the best script to use, based on the characters of a string.
-- If forceDetect is set, run the detection algorithm even if there's only one
-- possible script; in that case, if the text isn't in the script, the return
-- value will be None.
function export.findBestScript(text, lang, forceDetect)
if not text or not lang or not lang.getScripts then
return export.getByCode("None")
end
code = scriptAliases[code] or code
local scripts = lang:getScripts()data
if useRequire then
data = require("Module:scripts/data")[code]
if not scripts[2] and not forceDetect then
else
return scripts[1]
data = mw.loadData("Module:scripts/data")[code]
end
local retval = export.makeObject(code, data, useRequire)
--[=[
Remove any HTML entities; catfix function in [[Module:utilities]]
adds tagging to a no-break space (&nbsp;), which contains Latin characters;
hence Latin was returned as the script if "Latn" is one of the language's scripts.
]=]
text = string.gsub(text, "&[a-zA-Z0-9]+;", "")
if not retval and paramForError then
-- Try to match every script against the text,
require("Module:languages/error")(code, paramForError, "script code", nil, "not real lang")
-- and return the one with the most matching characters.
local bestcount = 0
local bestscript = nil
-- Get length of text minus any spacing or punctuation characters.
-- Counting instances of UTF-8 character pattern is faster than mw.ustring.len.
local _, length = string.gsub(mw.ustring.gsub(text, "[%s%p]+", ""), "[\1-\127\194-\244][\128-\191]*", "")
if length == 0 then
return export.getByCode("None")
end
return retval
for i, script in ipairs(scripts) do
local count = script:countCharacters(text)
if count >= length then
return script
end
if count > bestcount then
bestcount = count
bestscript = script
end
end
if bestscript then
return bestscript
end
-- No matching script was found. Return "None".
return export.getByCode("None")
end
 
function export.getByCanonicalName(name, useRequire)
-- Copied from [[Module:Unicode data]].
local floor = math.floorcode
if useRequire then
local function binaryRangeSearch(codepoint, ranges)
code = require("Module:scripts/by name")[name]
local low, mid, high
else
low, high = 1, ranges.length or require "Module:table".length(ranges)
code = mw.loadData("Module:scripts/by name")[name]
while low <= high do
mid = floor((low + high) / 2)
local range = ranges[mid]
if codepoint < range[1] then
high = mid - 1
elseif codepoint <= range[2] then
return range, mid
else
low = mid + 1
end
end
return nil, mid
return export.getByCode(code, nil, nil, useRequire)
end
 
--[==[
-- Copied from [[Module:Unicode data]].
local function linearRangeSearch(codepoint, ranges)
for i, range in ipairs(ranges) do
if codepoint < range[1] then
break
elseif codepoint <= range[2] then
return range
end
end
end
 
local function compareRanges(range1, range2)
return range1[1] < range2[1]
end
 
-- Save previously used codepoint ranges in case another character is in the
-- same range.
local rangesCache = {}
 
--[=[
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
Line ၂၆၄ ⟶ ၃၆၆:
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".
]==]
local charToScriptData
function export.charToScript(char)
return require("Module:scripts/charToScript").charToScript(char)
charToScriptData = charToScriptData or mw.loadData("Module:scripts/recognition data")
local t = type(char)
local codepoint
if t == "string" then
local etc
codepoint, etc = mw.ustring.codepoint(char, 1, 2)
if etc then
error("bad argument #1 to 'charToScript' (expected a single character)")
end
elseif t == "number" then
codepoint = char
else
error(("bad argument #1 to 'charToScript' (expected string or a number, got %s)")
:format(t))
end
 
local individualMatch = charToScriptData.individual[codepoint]
if individualMatch then
return individualMatch
else
local range
if rangesCache[1] then
range = linearRangeSearch(codepoint, rangesCache)
if range then
return range[3]
end
end
 
local index = floor(codepoint / 0x1000)
 
range = linearRangeSearch(index, charToScriptData.blocks)
if not range and charToScriptData[index] then
range = binaryRangeSearch(codepoint, charToScriptData[index])
if range then
table.insert(rangesCache, range)
table.sort(rangesCache, compareRanges)
end
end
return range and range[3] or "None"
end
end
 
--[==[
function export.findBestScriptWithoutLang(text)
Returns the code for the script that has the greatest number of characters in `text`. Useful for script tagging text
local scripts = {}
that is unspecified for language. Uses [[Module:scripts/recognition data]] to determine a script code for a character
for character in text:gmatch("[%z\1-\127\194-\244][\128-\191]*") do
language-agnostically. Specifically, it works as follows:
local script = export.charToScript(character)
scripts[script] = (scripts[script] or 0) + 1
end
Convert each character to a codepoint. Iterate the counter for the script code if the codepoint is in the list
local bestScript
of individual characters, or if it is in one of the defined ranges in the 4096-character block that it belongs to.
local greatestCount = 0
for script, count in pairs(scripts) do
Each script has a two-part counter, for primary and secondary matches. Primary matches are when the script is the
if count > greatestCount then
first one listed; otherwise, it's a secondary match. When comparing scripts, first the total of both are compared
bestScript = script
(i.e. the overall number of matches). If these are the same, the number of primary and then secondary matches are
greatestCount = count
used as tiebreakers. For example, this is used to ensure that `Grek` takes priority over `Polyt` if no characters
end
which exclusively match `Polyt` are found, as `Grek` is a subset of `Polyt`.
end
If `none_is_last_resort_only` is specified, this will never return {"None"} if any characters in `text` belong to a
return bestScript
script. Otherwise, it will return {"None"} if there are more characters that don't belong to a script than belong to
any individual script. (FIXME: This behavior is probably wrong, and `none_is_last_resort_only` should probably
become the default.)
]==]
function export.findBestScriptWithoutLang(text, none_is_last_resort_only)
return require("Module:scripts/charToScript").findBestScriptWithoutLang(text, none_is_last_resort_only)
end
 
ကလေၚ်သီကေတ်လဝ် နူ "https://mnw.wiktionary.org/wiki/မဝ်ဂျူ:scripts"