text:
Module:scripts/data

--[=[	When adding new scripts to this file, please don't forget to add style definitons for the script in MediaWiki:Common.css. ]=] local concat = table.concat local insert = table.insert local ipairs = ipairs local next = next local remove = table.remove local select = select local sort = table.sort local u = require("Module:string utilities").char

-- -- Helper functions --

-- Note: a[2] > b[2] means opens are sorted before closes if otherwise equal. local function sort_ranges(a, b)	return a[1] < b[1] or a[1] == b[1] and a[2] > b[2] end

-- Returns the union of two or more range tables. local function union(...) local ranges = {} for i = 1, select("#", ...) do		local argt = select(i, ...) for j, v in ipairs(argt) do			insert(ranges, {v, j % 2 == 1 and 1 or -1}) end end sort(ranges, sort_ranges) local ret, i = {}, 0 for _, range in ipairs(ranges) do		i = i + range[2] if i == 0 and range[2] == -1 then -- close insert(ret, range[1]) elseif i == 1 and range[2] == 1 then -- open if ret[#ret] and range[1] <= ret[#ret] + 1 then remove(ret) -- merge adjacent ranges else insert(ret, range[1]) end end end return ret end

-- Adds the `characters` key, which is determined by a script's `ranges` table. local function process_ranges(sc) local ranges, chars = sc.ranges, {} for i = 2, #ranges, 2 do		if ranges[i] == ranges[i - 1] then insert(chars, u(ranges[i])) else insert(chars, u(ranges[i - 1])) if ranges[i] > ranges[i - 1] + 1 then insert(chars, "-") end insert(chars, u(ranges[i])) end end sc.characters = concat(chars) ranges.n = #ranges return sc end

local function handle_normalization_fixes(fixes) local combiningClasses = fixes.combiningClasses if combiningClasses then local chars, i = {}, 0 for char in next, combiningClasses do			i = i + 1 chars[i] = char end fixes.combiningClassCharacters = concat(chars) end return fixes end

-- -- Data --

local m = {}

m["Adlm"] = process_ranges{ "Adlam", "alphabet", ranges = { 0x061F, 0x061F, 0x0640, 0x0640, 0x1E900, 0x1E94B, 0x1E950, 0x1E959, 0x1E95E, 0x1E95F, },	capitalized = true, direction = "rtl", }

m["Afak"] = { "Afaka", "syllabary", -- Not in Unicode }

m["Aghb"] = process_ranges{ "Caucasian Albanian", "alphabet", ranges = { 0x10530, 0x10563, 0x1056F, 0x1056F, }, }

m["Ahom"] = process_ranges{ "Ahom", "abugida", ranges = { 0x11700, 0x1171A, 0x1171D, 0x1172B, 0x11730, 0x11746, }, }

m["Arab"] = process_ranges{ "Arabic", "abjad",	-- more precisely, impure abjad varieties = {"Jawi", {"Nastaliq", "Nastaleeq"}}, ranges = { 0x0600, 0x06FF, 0x0750, 0x077F, 0x0870, 0x088E, 0x0890, 0x0891, 0x0898, 0x08E1, 0x08E3, 0x08FF, 0xFB50, 0xFBC2, 0xFBD3, 0xFD8F, 0xFD92, 0xFDC7, 0xFDCF, 0xFDCF, 0xFDF0, 0xFDFF, 0xFE70, 0xFE74, 0xFE76, 0xFEFC, 0x102E0, 0x102FB, 0x10E60, 0x10E7E, 0x10EFD, 0x10EFF, 0x1EE00, 0x1EE03, 0x1EE05, 0x1EE1F, 0x1EE21, 0x1EE22, 0x1EE24, 0x1EE24, 0x1EE27, 0x1EE27, 0x1EE29, 0x1EE32, 0x1EE34, 0x1EE37, 0x1EE39, 0x1EE39, 0x1EE3B, 0x1EE3B, 0x1EE42, 0x1EE42, 0x1EE47, 0x1EE47, 0x1EE49, 0x1EE49, 0x1EE4B, 0x1EE4B, 0x1EE4D, 0x1EE4F, 0x1EE51, 0x1EE52, 0x1EE54, 0x1EE54, 0x1EE57, 0x1EE57, 0x1EE59, 0x1EE59, 0x1EE5B, 0x1EE5B, 0x1EE5D, 0x1EE5D, 0x1EE5F, 0x1EE5F, 0x1EE61, 0x1EE62, 0x1EE64, 0x1EE64, 0x1EE67, 0x1EE6A, 0x1EE6C, 0x1EE72, 0x1EE74, 0x1EE77, 0x1EE79, 0x1EE7C, 0x1EE7E, 0x1EE7E, 0x1EE80, 0x1EE89, 0x1EE8B, 0x1EE9B, 0x1EEA1, 0x1EEA3, 0x1EEA5, 0x1EEA9, 0x1EEAB, 0x1EEBB, 0x1EEF0, 0x1EEF1, },	direction = "rtl", normalizationFixes = handle_normalization_fixes{ from = {"ٳ"}, to = {"اٟ"} }, }

m["fa-Arab"] = { "Arabic", m["Arab"][2], ranges = m["Arab"].ranges, characters = m["Arab"].characters, otherNames = {"Perso-Arabic"}, direction = "rtl", parent = "Arab", normalizationFixes = m["Arab"].normalizationFixes, }

m["kk-Arab"] = { "Arabic", m["Arab"][2], ranges = m["Arab"].ranges, characters = m["Arab"].characters, direction = "rtl", parent = "Arab", normalizationFixes = m["Arab"].normalizationFixes, }	m["ks-Arab"] = m["fa-Arab"] m["ku-Arab"] = m["fa-Arab"] m["ms-Arab"] = m["kk-Arab"] m["mzn-Arab"] = m["fa-Arab"] m["ota-Arab"] = m["fa-Arab"] m["pa-Arab"] = { "Shahmukhi", m["Arab"][2], ranges = m["Arab"].ranges, characters = m["Arab"].characters, otherNames = {"Arabic"}, direction = "rtl", parent = "Arab", normalizationFixes = m["Arab"].normalizationFixes, }	m["ps-Arab"] = m["fa-Arab"] m["sd-Arab"] = m["fa-Arab"] m["tt-Arab"] = m["fa-Arab"] m["ug-Arab"] = m["fa-Arab"] m["ur-Arab"] = m["fa-Arab"]

-- Aran (Nastaliq) is subsumed into Arab

m["Armi"] = process_ranges{ "Imperial Aramaic", "abjad", ranges = { 0x10840, 0x10855, 0x10857, 0x1085F, },	direction = "rtl", }

m["Armn"] = process_ranges{ "Armenian", "alphabet", ranges = { 0x0531, 0x0556, 0x0559, 0x058A, 0x058D, 0x058F, 0xFB13, 0xFB17, },	capitalized = true, }

m["Avst"] = process_ranges{ "Avestan", "alphabet", ranges = { 0x10B00, 0x10B35, 0x10B39, 0x10B3F, },	direction = "rtl", }

m["pal-Avst"] = { "Pazend", m["Avst"][2], ranges = m["Avst"].ranges, characters = m["Avst"].characters, direction = "rtl", parent = "Avst", }

m["Bali"] = process_ranges{ "Balinese", "abugida", ranges = { 0x1B00, 0x1B4C, 0x1B50, 0x1B7E, }, }

m["Bamu"] = process_ranges{ "Bamum", "syllabary", ranges = { 0xA6A0, 0xA6F7, 0x16800, 0x16A38, }, }

m["Bass"] = process_ranges{ "Bassa", "alphabet", aliases = {"Bassa Vah", "Vah"}, ranges = { 0x16AD0, 0x16AED, 0x16AF0, 0x16AF5, }, }

m["Batk"] = process_ranges{ "Batak", "abugida", ranges = { 0x1BC0, 0x1BF3, 0x1BFC, 0x1BFF, }, }

m["Beng"] = process_ranges{ "Bengali", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0980, 0x0983, 0x0985, 0x098C, 0x098F, 0x0990, 0x0993, 0x09A8, 0x09AA, 0x09B0, 0x09B2, 0x09B2, 0x09B6, 0x09B9, 0x09BC, 0x09C4, 0x09C7, 0x09C8, 0x09CB, 0x09CE, 0x09D7, 0x09D7, 0x09DC, 0x09DD, 0x09DF, 0x09E3, 0x09E6, 0x09EF, 0x09F2, 0x09FE, 0x1CD0, 0x1CD0, 0x1CD2, 0x1CD2, 0x1CD5, 0x1CD6, 0x1CD8, 0x1CD8, 0x1CE1, 0x1CE1, 0x1CEA, 0x1CEA, 0x1CED, 0x1CED, 0x1CF2, 0x1CF2, 0x1CF5, 0x1CF7, 0xA8F1, 0xA8F1, },	normalizationFixes = handle_normalization_fixes{ from = {"অা", "ঋৃ", "ঌৢ"}, to = {"আ", "ৠ", "ৡ"} }, }

m["as-Beng"] = process_ranges{ "Assamese", m["Beng"][2], otherNames = {"Bengali-Assamese", "Eastern Nagari"}, ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0980, 0x0983, 0x0985, 0x098C, 0x098F, 0x0990, 0x0993, 0x09A8, 0x09AA, 0x09AF, 0x09B2, 0x09B2, 0x09B6, 0x09B9, 0x09BC, 0x09C4, 0x09C7, 0x09C8, 0x09CB, 0x09CE, 0x09D7, 0x09D7, 0x09DC, 0x09DD, 0x09DF, 0x09E3, 0x09E6, 0x09FE, 0x1CD0, 0x1CD0, 0x1CD2, 0x1CD2, 0x1CD5, 0x1CD6, 0x1CD8, 0x1CD8, 0x1CE1, 0x1CE1, 0x1CEA, 0x1CEA, 0x1CED, 0x1CED, 0x1CF2, 0x1CF2, 0x1CF5, 0x1CF7, 0xA8F1, 0xA8F1, },		normalizationFixes = m["Beng"].normalizationFixes, }

m["Bhks"] = process_ranges{ "Bhaiksuki", "abugida", ranges = { 0x11C00, 0x11C08, 0x11C0A, 0x11C36, 0x11C38, 0x11C45, 0x11C50, 0x11C6C, }, }

m["Blis"] = { "Blissymbols", "logography", aliases = {"Blissymbolics"}, -- Not in Unicode }

m["Bopo"] = process_ranges{ "Zhuyin", "semisyllabary", aliases = {"Zhuyin Fuhao", "Bopomofo"}, ranges = { 0x02EA, 0x02EB, 0x3001, 0x3003, 0x3008, 0x3011, 0x3013, 0x301F, 0x302A, 0x302D, 0x3030, 0x3030, 0x3037, 0x3037, 0x30FB, 0x30FB, 0x3105, 0x312F, 0x31A0, 0x31BF, 0xFE45, 0xFE46, 0xFF61, 0xFF65, }, }

m["Brah"] = process_ranges{ "Brahmi", "abugida", ranges = { 0x11000, 0x1104D, 0x11052, 0x11075, 0x1107F, 0x1107F, },	normalizationFixes = handle_normalization_fixes{ from = {"𑀅𑀸", "𑀋𑀾", "𑀏𑁂"}, to = {"𑀆", "𑀌", "𑀐"} }, }

m["Brai"] = process_ranges{ "Braille", "alphabet", ranges = { 0x2800, 0x28FF, }, }

m["Bugi"] = process_ranges{ "Lontara", "abugida", aliases = {"Buginese"}, ranges = { 0x1A00, 0x1A1B, 0x1A1E, 0x1A1F, 0xA9CF, 0xA9CF, }, }

m["Buhd"] = process_ranges{ "Buhid", "abugida", ranges = { 0x1735, 0x1736, 0x1740, 0x1751, 0x1752, 0x1753, }, }

m["Cakm"] = process_ranges{ "Chakma", "abugida", ranges = { 0x09E6, 0x09EF, 0x1040, 0x1049, 0x11100, 0x11134, 0x11136, 0x11147, }, }

m["Cans"] = process_ranges{ "Canadian syllabics", "abugida", ranges = { 0x1400, 0x167F, 0x18B0, 0x18F5, 0x11AB0, 0x11ABF, }, }

m["Cari"] = process_ranges{ "Carian", "alphabet", ranges = { 0x102A0, 0x102D0, }, }

m["Cham"] = process_ranges{ "Cham", "abugida", ranges = { 0xAA00, 0xAA36, 0xAA40, 0xAA4D, 0xAA50, 0xAA59, 0xAA5C, 0xAA5F, }, }

m["Cher"] = process_ranges{ "Cherokee", "syllabary", ranges = { 0x13A0, 0x13F5, 0x13F8, 0x13FD, 0xAB70, 0xABBF, }, }

m["Chis"] = { "Chisoi", "abugida", -- Not in Unicode }

m["Chrs"] = process_ranges{ "Chorasmian", "abjad", ranges = { 0x10FB0, 0x10FCB, },	direction = "rtl", }

m["Copt"] = process_ranges{ "Coptic", "alphabet", ranges = { 0x03E2, 0x03EF, 0x2C80, 0x2CF3, 0x2CF9, 0x2CFF, 0x102E0, 0x102FB, },	capitalized = true, }

m["Cpmn"] = process_ranges{ "Cypro-Minoan", "syllabary", aliases = {"Cypro Minoan"}, ranges = { 0x10100, 0x10101, 0x12F90, 0x12FF2, }, }

m["Cprt"] = process_ranges{ "Cypriot", "syllabary", ranges = { 0x10100, 0x10102, 0x10107, 0x10133, 0x10137, 0x1013F, 0x10800, 0x10805, 0x10808, 0x10808, 0x1080A, 0x10835, 0x10837, 0x10838, 0x1083C, 0x1083C, 0x1083F, 0x1083F, },	direction = "rtl", }

m["Cyrl"] = process_ranges{ "Cyrillic", "alphabet", ranges = { 0x0400, 0x052F, 0x1C80, 0x1C88, 0x1D2B, 0x1D2B, 0x1D78, 0x1D78, 0x1DF8, 0x1DF8, 0x2DE0, 0x2DFF, 0x2E43, 0x2E43, 0xA640, 0xA69F, 0xFE2E, 0xFE2F, 0x1E030, 0x1E06D, 0x1E08F, 0x1E08F, },	capitalized = true, }

m["Cyrs"] = { "Old Cyrillic", m["Cyrl"][2], aliases = {"Early Cyrillic"}, ranges = m["Cyrl"].ranges, characters = m["Cyrl"].characters, capitalized = m["Cyrl"].capitalized, wikipedia_article = "Early Cyrillic alphabet", normalizationFixes = handle_normalization_fixes{ from = {"Ѹ", "ѹ"}, to = {"Ꙋ", "ꙋ"} }, }

m["Deva"] = process_ranges{ "Devanagari", "abugida", ranges = { 0x0900, 0x097F, 0x1CD0, 0x1CF6, 0x1CF8, 0x1CF9, 0x20F0, 0x20F0, 0xA830, 0xA839, 0xA8E0, 0xA8FF, 0x11B00, 0x11B09, },	normalizationFixes = handle_normalization_fixes{ from = {"ॆॆ", "ेे", "ाॅ", "ाॆ", "ाꣿ", "ॊॆ", "ाे", "ाै", "ोे", "ाऺ", "ॖॖ", "अॅ", "अॆ", "अा", "एॅ", "एॆ", "एे", "एꣿ", "ऎॆ", "अॉ", "आॅ", "अॊ", "आॆ", "अो", "आे", "अौ", "आै", "ओे", "अऺ", "अऻ", "आऺ", "अाꣿ", "आꣿ", "ऒॆ", "अॖ", "अॗ", "ॶॖ", "्?ा"}, to = {"ꣿ", "ै", "ॉ", "ॊ", "ॏ", "ॏ", "ो", "ौ", "ौ", "ऻ", "ॗ", "ॲ", "ऄ", "आ", "ऍ", "ऎ", "ऐ", "ꣾ", "ꣾ", "ऑ", "ऑ", "ऒ", "ऒ", "ओ", "ओ", "औ", "औ", "औ", "ॳ", "ॴ", "ॴ", "ॵ", "ॵ", "ॵ", "ॶ", "ॷ", "ॷ"} }, }

m["Diak"] = process_ranges{ "Dhives Akuru", "abugida", aliases = {"Dhivehi Akuru", "Dives Akuru", "Divehi Akuru"}, ranges = { 0x11900, 0x11906, 0x11909, 0x11909, 0x1190C, 0x11913, 0x11915, 0x11916, 0x11918, 0x11935, 0x11937, 0x11938, 0x1193B, 0x11946, 0x11950, 0x11959, }, }

m["Dogr"] = process_ranges{ "Dogra", "abugida", ranges = { 0x0964, 0x096F, 0xA830, 0xA839, 0x11800, 0x1183B, }, }

m["Dsrt"] = process_ranges{ "Deseret", "alphabet", ranges = { 0x10400, 0x1044F, },	capitalized = true, }

m["Dupl"] = process_ranges{ "Duployan", "alphabet", ranges = { 0x1BC00, 0x1BC6A, 0x1BC70, 0x1BC7C, 0x1BC80, 0x1BC88, 0x1BC90, 0x1BC99, 0x1BC9C, 0x1BCA3, }, }

m["Egyd"] = { "Demotic", "abjad, logography", -- Not in Unicode }

m["Egyh"] = { "Hieratic", "abjad, logography", -- Unified with Egyptian hieroglyphic in Unicode }

m["Egyp"] = process_ranges{ "Egyptian hieroglyphic", "abjad, logography", ranges = { 0x13000, 0x13455, },	varieties = {"Hieratic"}, wikipedia_article = "Egyptian hieroglyphs", normalizationFixes = handle_normalization_fixes{ from = {"𓃁", "𓆖"}, to = {"𓃀𓂝", "𓆓𓏏𓇿"} }, }

m["Elba"] = process_ranges{ "Elbasan", "alphabet", ranges = { 0x10500, 0x10527, }, }

m["Elym"] = process_ranges{ "Elymaic", "abjad", ranges = { 0x10FE0, 0x10FF6, },	direction = "rtl", }

m["Ethi"] = process_ranges{ "Ethiopic", "abugida", aliases = {"Ge'ez"}, ranges = { 0x1200, 0x1248, 0x124A, 0x124D, 0x1250, 0x1256, 0x1258, 0x1258, 0x125A, 0x125D, 0x1260, 0x1288, 0x128A, 0x128D, 0x1290, 0x12B0, 0x12B2, 0x12B5, 0x12B8, 0x12BE, 0x12C0, 0x12C0, 0x12C2, 0x12C5, 0x12C8, 0x12D6, 0x12D8, 0x1310, 0x1312, 0x1315, 0x1318, 0x135A, 0x135D, 0x137C, 0x1380, 0x1399, 0x2D80, 0x2D96, 0x2DA0, 0x2DA6, 0x2DA8, 0x2DAE, 0x2DB0, 0x2DB6, 0x2DB8, 0x2DBE, 0x2DC0, 0x2DC6, 0x2DC8, 0x2DCE, 0x2DD0, 0x2DD6, 0x2DD8, 0x2DDE, 0xAB01, 0xAB06, 0xAB09, 0xAB0E, 0xAB11, 0xAB16, 0xAB20, 0xAB26, 0xAB28, 0xAB2E, 0x1E7E0, 0x1E7E6, 0x1E7E8, 0x1E7EB, 0x1E7ED, 0x1E7EE, 0x1E7F0, 0x1E7FE, }, }

m["Gara"] = { "Garay", "alphabet", capitalized = true, direction = "rtl", -- Not in Unicode }

m["Geok"] = process_ranges{ "Khutsuri", "alphabet", ranges = { -- Ⴀ-Ⴭ is Asomtavruli, ⴀ-ⴭ is Nuskhuri 0x10A0, 0x10C5, 0x10C7, 0x10C7, 0x10CD, 0x10CD, 0x10FB, 0x10FB, 0x2D00, 0x2D25, 0x2D27, 0x2D27, 0x2D2D, 0x2D2D, },	varieties = {"Nuskhuri", "Asomtavruli"}, capitalized = true, }

m["Geor"] = process_ranges{ "Georgian", "alphabet", ranges = { -- ა-ჿ is lowercase Mkhedruli; Ა-Ჿ is uppercase Mkhedruli (Mtavruli) 0x10D0, 0x10FF, 0x1C90, 0x1CBA, 0x1CBD, 0x1CBF, },	varieties = {"Mkhedruli", "Mtavruli"}, capitalized = true, }

m["Glag"] = process_ranges{ "Glagolitic", "alphabet", ranges = { 0x0484, 0x0484, 0x0487, 0x0487, 0x2C00, 0x2C5F, 0x2E43, 0x2E43, 0xA66F, 0xA66F, 0x1E000, 0x1E006, 0x1E008, 0x1E018, 0x1E01B, 0x1E021, 0x1E023, 0x1E024, 0x1E026, 0x1E02A, },	capitalized = true, }

m["Gong"] = process_ranges{ "Gunjala Gondi", "abugida", ranges = { 0x0964, 0x0965, 0x11D60, 0x11D65, 0x11D67, 0x11D68, 0x11D6A, 0x11D8E, 0x11D90, 0x11D91, 0x11D93, 0x11D98, 0x11DA0, 0x11DA9, }, }

m["Gonm"] = process_ranges{ "Masaram Gondi", "abugida", ranges = { 0x0964, 0x0965, 0x11D00, 0x11D06, 0x11D08, 0x11D09, 0x11D0B, 0x11D36, 0x11D3A, 0x11D3A, 0x11D3C, 0x11D3D, 0x11D3F, 0x11D47, 0x11D50, 0x11D59, }, }

m["Goth"] = process_ranges{ "Gothic", "alphabet", ranges = { 0x10330, 0x1034A, },	wikipedia_article = "Gothic alphabet", }

m["Gran"] = process_ranges{ "Grantha", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0BE6, 0x0BF3, 0x1CD0, 0x1CD0, 0x1CD2, 0x1CD3, 0x1CF2, 0x1CF4, 0x1CF8, 0x1CF9, 0x20F0, 0x20F0, 0x11300, 0x11303, 0x11305, 0x1130C, 0x1130F, 0x11310, 0x11313, 0x11328, 0x1132A, 0x11330, 0x11332, 0x11333, 0x11335, 0x11339, 0x1133B, 0x11344, 0x11347, 0x11348, 0x1134B, 0x1134D, 0x11350, 0x11350, 0x11357, 0x11357, 0x1135D, 0x11363, 0x11366, 0x1136C, 0x11370, 0x11374, 0x11FD0, 0x11FD1, 0x11FD3, 0x11FD3, }, }

m["Grek"] = process_ranges{ "Greek", "alphabet", ranges = { 0x0342, 0x0342, 0x0345, 0x0345, 0x0370, 0x0377, 0x037A, 0x037F, 0x0384, 0x038A, 0x038C, 0x038C, 0x038E, 0x03A1, 0x03A3, 0x03E1, 0x03F0, 0x03FF, 0x1D26, 0x1D2A, 0x1D5D, 0x1D61, 0x1D66, 0x1D6A, 0x1DBF, 0x1DBF, 0x2126, 0x2127, 0x2129, 0x2129, 0x213C, 0x2140, 0xAB65, 0xAB65, 0x10140, 0x1018E, 0x101A0, 0x101A0, 0x1D200, 0x1D245, },	capitalized = true, }

m["Polyt"] = process_ranges{ "Greek", m["Grek"][2], ranges = union(m["Grek"].ranges, {			0x1F00, 0x1F15,			0x1F18, 0x1F1D,			0x1F20, 0x1F45,			0x1F48, 0x1F4D,			0x1F50, 0x1F57,			0x1F59, 0x1F59,			0x1F5B, 0x1F5B,			0x1F5D, 0x1F5D,			0x1F5F, 0x1F7D,			0x1F80, 0x1FB4,			0x1FB6, 0x1FC4,			0x1FC6, 0x1FD3,			0x1FD6, 0x1FDB,			0x1FDD, 0x1FEF,			0x1FF2, 0x1FF4,			0x1FF6, 0x1FFE,		}), ietf_subtag = "Grek", capitalized = m["Grek"].capitalized, parent = "Grek", }

m["Gujr"] = process_ranges{ "Gujarati", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0A81, 0x0A83, 0x0A85, 0x0A8D, 0x0A8F, 0x0A91, 0x0A93, 0x0AA8, 0x0AAA, 0x0AB0, 0x0AB2, 0x0AB3, 0x0AB5, 0x0AB9, 0x0ABC, 0x0AC5, 0x0AC7, 0x0AC9, 0x0ACB, 0x0ACD, 0x0AD0, 0x0AD0, 0x0AE0, 0x0AE3, 0x0AE6, 0x0AF1, 0x0AF9, 0x0AFF, 0xA830, 0xA839, },	normalizationFixes = handle_normalization_fixes{ from = {"ઓ", "અાૈ", "અા", "અૅ", "અે", "અૈ", "અૉ", "અો", "અૌ", "આૅ", "આૈ", "ૅા"}, to = {"અાૅ", "ઔ", "આ", "ઍ", "એ", "ઐ", "ઑ", "ઓ", "ઔ", "ઓ", "ઔ", "ૉ"} }, }

m["Gukh"] = { "Khema", "abugida", aliases = {"Gurung Khema", "Khema Phri", "Khema Lipi"}, -- Not in Unicode }

m["Guru"] = process_ranges{ "Gurmukhi", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0A01, 0x0A03, 0x0A05, 0x0A0A, 0x0A0F, 0x0A10, 0x0A13, 0x0A28, 0x0A2A, 0x0A30, 0x0A32, 0x0A33, 0x0A35, 0x0A36, 0x0A38, 0x0A39, 0x0A3C, 0x0A3C, 0x0A3E, 0x0A42, 0x0A47, 0x0A48, 0x0A4B, 0x0A4D, 0x0A51, 0x0A51, 0x0A59, 0x0A5C, 0x0A5E, 0x0A5E, 0x0A66, 0x0A76, 0xA830, 0xA839, },	normalizationFixes = handle_normalization_fixes{ from = {"ਅਾ", "ਅੈ", "ਅੌ", "ੲਿ", "ੲੀ", "ੲੇ", "ੳੁ", "ੳੂ", "ੳੋ"}, to = {"ਆ", "ਐ", "ਔ", "ਇ", "ਈ", "ਏ", "ਉ", "ਊ", "ਓ"} }, }

m["Hang"] = process_ranges{ "Hangul", "syllabary", aliases = {"Hangeul"}, ranges = { 0x1100, 0x11FF, 0x3001, 0x3003, 0x3008, 0x3011, 0x3013, 0x301F, 0x302E, 0x3030, 0x3037, 0x3037, 0x30FB, 0x30FB, 0x3131, 0x318E, 0x3200, 0x321E, 0x3260, 0x327E, 0xA960, 0xA97C, 0xAC00, 0xD7A3, 0xD7B0, 0xD7C6, 0xD7CB, 0xD7FB, 0xFE45, 0xFE46, 0xFF61, 0xFF65, 0xFFA0, 0xFFBE, 0xFFC2, 0xFFC7, 0xFFCA, 0xFFCF, 0xFFD2, 0xFFD7, 0xFFDA, 0xFFDC, }, }

m["Hani"] = process_ranges{ "Han", "logography", ranges = { 0x2E80, 0x2E99, 0x2E9B, 0x2EF3, 0x2F00, 0x2FD5, 0x3001, 0x3003, 0x3005, 0x3011, 0x3013, 0x301F, 0x3021, 0x302D, 0x3030, 0x3030, 0x3037, 0x303F, 0x3190, 0x319F, 0x31C0, 0x31E3, 0x3220, 0x3247, 0x3280, 0x32B0, 0x32C0, 0x32CB, 0x30FB, 0x30FB, 0x32FF, 0x32FF, 0x3358, 0x3370, 0x337B, 0x337F, 0x33E0, 0x33FE, 0x3400, 0x4DBF, 0x4E00, 0x9FFF, 0xA700, 0xA707, 0xF900, 0xFA6D, 0xFA70, 0xFAD9, 0xFE45, 0xFE46, 0xFF61, 0xFF65, 0x16FE2, 0x16FE3, 0x16FF0, 0x16FF1, 0x1D360, 0x1D371, 0x1F250, 0x1F251, 0x20000, 0x2A6DF, 0x2A700, 0x2B739, 0x2B740, 0x2B81D, 0x2B820, 0x2CEA1, 0x2CEB0, 0x2EBE0, 0x2EBF0, 0x2EE5D, 0x2F800, 0x2FA1D, 0x30000, 0x3134A, 0x31350, 0x323AF, },	varieties = {"Hanzi", "Kanji", "Hanja", "Chu Nom"}, spaces = false, }

m["Hans"] = { "Simplified Han", m["Hani"][2], ranges = m["Hani"].ranges, characters = m["Hani"].characters, spaces = m["Hani"].spaces, parent = "Hani", }

m["Hant"] = { "Traditional Han", m["Hani"][2], ranges = m["Hani"].ranges, characters = m["Hani"].characters, spaces = m["Hani"].spaces, parent = "Hani", }

m["Hano"] = process_ranges{ "Hanunoo", "abugida", ranges = { 0x1720, 0x1736, }, }

m["Hatr"] = process_ranges{ "Hatran", "abjad", ranges = { 0x108E0, 0x108F2, 0x108F4, 0x108F5, 0x108FB, 0x108FF, },	direction = "rtl", }

m["Hebr"] = process_ranges{ "Hebrew", "abjad",	-- more precisely, impure abjad ranges = { 0x0591, 0x05C7, 0x05D0, 0x05EA, 0x05EF, 0x05F4, 0x2135, 0x2138, 0xFB1D, 0xFB36, 0xFB38, 0xFB3C, 0xFB3E, 0xFB3E, 0xFB40, 0xFB41, 0xFB43, 0xFB44, 0xFB46, 0xFB4F, },	direction = "rtl", }

m["Hira"] = process_ranges{ "Hiragana", "syllabary", ranges = { 0x3001, 0x3003, 0x3008, 0x3011, 0x3013, 0x301F, 0x3030, 0x3035, 0x3037, 0x3037, 0x303C, 0x303D, 0x3041, 0x3096, 0x3099, 0x30A0, 0x30FB, 0x30FC, 0xFE45, 0xFE46, 0xFF61, 0xFF65, 0xFF70, 0xFF70, 0xFF9E, 0xFF9F, 0x1B001, 0x1B11F, 0x1B132, 0x1B132, 0x1B150, 0x1B152, 0x1F200, 0x1F200, },	varieties = {"Hentaigana"}, spaces = false, }

m["Hluw"] = process_ranges{ "Anatolian Hieroglyphs", "logography, syllabary", ranges = { 0x14400, 0x14646, },	wikipedia_article = "Anatolian hieroglyphs", }

m["Hmng"] = process_ranges{ "Pahawh Hmong", "semisyllabary", aliases = {"Hmong"}, ranges = { 0x16B00, 0x16B45, 0x16B50, 0x16B59, 0x16B5B, 0x16B61, 0x16B63, 0x16B77, 0x16B7D, 0x16B8F, }, }

m["Hmnp"] = process_ranges{ "Nyiakeng Puachue Hmong", "alphabet", ranges = { 0x1E100, 0x1E12C, 0x1E130, 0x1E13D, 0x1E140, 0x1E149, 0x1E14E, 0x1E14F, }, }

m["Hung"] = process_ranges{ "Old Hungarian", "alphabet", aliases = {"Hungarian runic"}, ranges = { 0x10C80, 0x10CB2, 0x10CC0, 0x10CF2, 0x10CFA, 0x10CFF, },	capitalized = true, direction = "rtl", }

m["Ibrnn"] = { "Northeastern Iberian", "semisyllabary", ietf_subtag = "Zzzz", -- Not in Unicode }

m["Ibrns"] = { "Southeastern Iberian", "semisyllabary", ietf_subtag = "Zzzz", -- Not in Unicode }

m["Image"] = { -- To be used to avoid any formatting or link processing "Image-rendered", -- This should not have any characters listed ietf_subtag = "Zyyy", translit = false, character_category = false, }

m["Inds"] = { "Indus", aliases = {"Harappan", "Indus Valley"}, }

m["Ipach"] = { "International Phonetic Alphabet", aliases = {"IPA"}, ietf_subtag = "Latn", }

m["Ital"] = process_ranges{ "Old Italic", "alphabet", ranges = { 0x10300, 0x10323, 0x1032D, 0x1032F, }, }

m["Java"] = process_ranges{ "Javanese", "abugida", ranges = { 0xA980, 0xA9CD, 0xA9CF, 0xA9D9, 0xA9DE, 0xA9DF, }, }

m["Jurc"] = { "Jurchen", "logography", spaces = false, }

m["Kali"] = process_ranges{ "Kayah Li", "abugida", ranges = { 0xA900, 0xA92F, }, }

m["Kana"] = process_ranges{ "Katakana", "syllabary", ranges = { 0x3001, 0x3003, 0x3008, 0x3011, 0x3013, 0x301F, 0x3030, 0x3035, 0x3037, 0x3037, 0x303C, 0x303D, 0x3099, 0x309C, 0x30A0, 0x30FF, 0x31F0, 0x31FF, 0x32D0, 0x32FE, 0x3300, 0x3357, 0xFE45, 0xFE46, 0xFF61, 0xFF9F, 0x1AFF0, 0x1AFF3, 0x1AFF5, 0x1AFFB, 0x1AFFD, 0x1AFFE, 0x1B000, 0x1B000, 0x1B120, 0x1B122, 0x1B155, 0x1B155, 0x1B164, 0x1B167, },	spaces = false, }

m["Kawi"] = process_ranges{ "Kawi", "abugida", ranges = { 0x11F00, 0x11F10, 0x11F12, 0x11F3A, 0x11F3E, 0x11F59, }, }

m["Khar"] = process_ranges{ "Kharoshthi", "abugida", ranges = { 0x10A00, 0x10A03, 0x10A05, 0x10A06, 0x10A0C, 0x10A13, 0x10A15, 0x10A17, 0x10A19, 0x10A35, 0x10A38, 0x10A3A, 0x10A3F, 0x10A48, 0x10A50, 0x10A58, },	direction = "rtl", }

m["Khmr"] = process_ranges{ "Khmer", "abugida", ranges = { 0x1780, 0x17DD, 0x17E0, 0x17E9, 0x17F0, 0x17F9, 0x19E0, 0x19FF, },	spaces = false, normalizationFixes = handle_normalization_fixes{ from = {"ឣ", "ឤ"}, to = {"អ", "អា"} }, }

m["Khoj"] = process_ranges{ "Khojki", "abugida", ranges = { 0x0AE6, 0x0AEF, 0xA830, 0xA839, 0x11200, 0x11211, 0x11213, 0x11241, },	normalizationFixes = handle_normalization_fixes{ from = {"𑈀𑈬𑈱", "𑈀𑈬", "𑈀𑈱", "𑈀𑈳", "𑈁𑈱", "𑈆𑈬", "𑈬𑈰", "𑈬𑈱", "𑉀𑈮"}, to = {"𑈇", "𑈁", "𑈅", "𑈇", "𑈇", "𑈃", "𑈲", "𑈳", "𑈂"} }, }

m["Kitl"] = { "Khitan Large", "logography", spaces = false, }

m["Kits"] = process_ranges{ "Khitan Small", "logography, syllabary", ranges = { 0x16FE4, 0x16FE4, 0x18B00, 0x18CD5, },	spaces = false, }

m["Knda"] = process_ranges{ "Kannada", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0C80, 0x0C8C, 0x0C8E, 0x0C90, 0x0C92, 0x0CA8, 0x0CAA, 0x0CB3, 0x0CB5, 0x0CB9, 0x0CBC, 0x0CC4, 0x0CC6, 0x0CC8, 0x0CCA, 0x0CCD, 0x0CD5, 0x0CD6, 0x0CDD, 0x0CDE, 0x0CE0, 0x0CE3, 0x0CE6, 0x0CEF, 0x0CF1, 0x0CF3, 0x1CD0, 0x1CD0, 0x1CD2, 0x1CD2, 0x1CDA, 0x1CDA, 0x1CF2, 0x1CF2, 0x1CF4, 0x1CF4, 0xA830, 0xA835, },	normalizationFixes = handle_normalization_fixes{ from = {"ಉಾ", "ಋಾ", "ಒೌ"}, to = {"ಊ", "ೠ", "ಔ"} }, }

m["Kpel"] = { "Kpelle", "syllabary", -- Not in Unicode }

m["Krai"] = { "Kirat Rai", "abugida", aliases = {"Rai", "Khambu Rai", "Rai Barṇamālā", "Kirat Khambu Rai"}, -- Not in Unicode }

m["Kthi"] = process_ranges{ "Kaithi", "abugida", ranges = { 0x0966, 0x096F, 0xA830, 0xA839, 0x11080, 0x110C2, 0x110CD, 0x110CD, }, }

m["Lana"] = process_ranges{ "Tai Tham", "abugida", aliases = {"Tham", "Tua Mueang", "Lanna"}, ranges = { 0x1A20, 0x1A5E, 0x1A60, 0x1A7C, 0x1A7F, 0x1A89, 0x1A90, 0x1A99, 0x1AA0, 0x1AAD, },	spaces = false, }

m["Laoo"] = process_ranges{ "Lao", "abugida", ranges = { 0x0E81, 0x0E82, 0x0E84, 0x0E84, 0x0E86, 0x0E8A, 0x0E8C, 0x0EA3, 0x0EA5, 0x0EA5, 0x0EA7, 0x0EBD, 0x0EC0, 0x0EC4, 0x0EC6, 0x0EC6, 0x0EC8, 0x0ECE, 0x0ED0, 0x0ED9, 0x0EDC, 0x0EDF, },	spaces = false, }

m["Latn"] = process_ranges{ "Latin", "alphabet", aliases = {"Roman"}, ranges = { 0x0041, 0x005A, 0x0061, 0x007A, 0x00AA, 0x00AA, 0x00BA, 0x00BA, 0x00C0, 0x00D6, 0x00D8, 0x00F6, 0x00F8, 0x02B8, 0x02C0, 0x02C1, 0x02E0, 0x02E4, 0x0363, 0x036F, 0x0485, 0x0486, 0x0951, 0x0952, 0x10FB, 0x10FB, 0x1D00, 0x1D25, 0x1D2C, 0x1D5C, 0x1D62, 0x1D65, 0x1D6B, 0x1D77, 0x1D79, 0x1DBE, 0x1E00, 0x1EFF, 0x202F, 0x202F, 0x2071, 0x2071, 0x207F, 0x207F, 0x2090, 0x209C, 0x20F0, 0x20F0, 0x2100, 0x2125, 0x2128, 0x2128, 0x212A, 0x2134, 0x2139, 0x213B, 0x2141, 0x214E, 0x2160, 0x2188, 0x2C60, 0x2C7F, 0xA700, 0xA707, 0xA722, 0xA787, 0xA78B, 0xA7CA, 0xA7D0, 0xA7D1, 0xA7D3, 0xA7D3, 0xA7D5, 0xA7D9, 0xA7F2, 0xA7FF, 0xA92E, 0xA92E, 0xAB30, 0xAB5A, 0xAB5C, 0xAB64, 0xAB66, 0xAB69, 0xFB00, 0xFB06, 0xFF21, 0xFF3A, 0xFF41, 0xFF5A, 0x10780, 0x10785, 0x10787, 0x107B0, 0x107B2, 0x107BA, 0x1DF00, 0x1DF1E, 0x1DF25, 0x1DF2A, },	varieties = {"Rumi", "Romaji", "Rōmaji", "Romaja"}, capitalized = true, translit = false, }

m["Latf"] = { "Fraktur", m["Latn"][2], ranges = m["Latn"].ranges, characters = m["Latn"].characters, otherNames = {"Blackletter"}, -- Blackletter is actually the parent "script" capitalized = m["Latn"].capitalized, translit = m["Latn"].translit, parent = "Latn", }	m["Latg"] = { "Gaelic", m["Latn"][2], ranges = m["Latn"].ranges, characters = m["Latn"].characters, otherNames = {"Irish"}, capitalized = m["Latn"].capitalized, translit = m["Latn"].translit, parent = "Latn", }	m["pjt-Latn"] = { "Latin", m["Latn"][2], ranges = m["Latn"].ranges, characters = m["Latn"].characters, capitalized = m["Latn"].capitalized, translit = m["Latn"].translit, parent = "Latn", }

m["Leke"] = { "Leke", "abugida", -- Not in Unicode }

m["Lepc"] = process_ranges{ "Lepcha", "abugida", ranges = { 0x1C00, 0x1C37, 0x1C3B, 0x1C49, 0x1C4D, 0x1C4F, }, }

m["Limb"] = process_ranges{ "Limbu", "abugida", ranges = { 0x0965, 0x0965, 0x1900, 0x191E, 0x1920, 0x192B, 0x1930, 0x193B, 0x1940, 0x1940, 0x1944, 0x194F, }, }

m["Lina"] = process_ranges{ "Linear A", ranges = { 0x10107, 0x10133, 0x10600, 0x10736, 0x10740, 0x10755, 0x10760, 0x10767, }, }

m["Linb"] = process_ranges{ "Linear B", ranges = { 0x10000, 0x1000B, 0x1000D, 0x10026, 0x10028, 0x1003A, 0x1003C, 0x1003D, 0x1003F, 0x1004D, 0x10050, 0x1005D, 0x10080, 0x100FA, 0x10100, 0x10102, 0x10107, 0x10133, 0x10137, 0x1013F, }, }

m["Lisu"] = process_ranges{ "Fraser", "alphabet", aliases = {"Old Lisu", "Lisu"}, ranges = { 0xA4D0, 0xA4FF, 0x11FB0, 0x11FB0, },	normalizationFixes = handle_normalization_fixes{ from = {"['’]", "[.ꓸ][.ꓸ]", "[.ꓸ][,ꓹ]"}, to = {"ʼ", "ꓺ", "ꓻ"} }, }

m["Loma"] = { "Loma", "syllabary", -- Not in Unicode }

m["Lyci"] = process_ranges{ "Lycian", "alphabet", ranges = { 0x10280, 0x1029C, }, }

m["Lydi"] = process_ranges{ "Lydian", "alphabet", ranges = { 0x10920, 0x10939, 0x1093F, 0x1093F, },	direction = "rtl", }

m["Mahj"] = process_ranges{ "Mahajani", "abugida", ranges = { 0x0964, 0x096F, 0xA830, 0xA839, 0x11150, 0x11176, }, }

m["Maka"] = process_ranges{ "Makasar", "abugida", aliases = {"Old Makasar"}, ranges = { 0x11EE0, 0x11EF8, }, }

m["Mand"] = process_ranges{ "Mandaic", aliases = {"Mandaean"}, ranges = { 0x0640, 0x0640, 0x0840, 0x085B, 0x085E, 0x085E, },	direction = "rtl", }

m["Mani"] = process_ranges{ "Manichaean", "abjad", ranges = { 0x0640, 0x0640, 0x10AC0, 0x10AE6, 0x10AEB, 0x10AF6, },	direction = "rtl", }

m["Marc"] = process_ranges{ "Marchen", "abugida", ranges = { 0x11C70, 0x11C8F, 0x11C92, 0x11CA7, 0x11CA9, 0x11CB6, }, }

m["Maya"] = process_ranges{ "Maya", aliases = {"Maya hieroglyphic", "Mayan", "Mayan hieroglyphic"}, ranges = { 0x1D2E0, 0x1D2F3, }, }

m["Medf"] = process_ranges{ "Medefaidrin", aliases = {"Oberi Okaime", "Oberi Ɔkaimɛ"}, ranges = { 0x16E40, 0x16E9A, },	capitalized = true, }

m["Mend"] = process_ranges{ "Mende", aliases = {"Mende Kikakui"}, ranges = { 0x1E800, 0x1E8C4, 0x1E8C7, 0x1E8D6, },	direction = "rtl", }

m["Merc"] = process_ranges{ "Meroitic cursive", "abugida", ranges = { 0x109A0, 0x109B7, 0x109BC, 0x109CF, 0x109D2, 0x109FF, },	direction = "rtl", }

m["Mero"] = process_ranges{ "Meroitic hieroglyphic", "abugida", ranges = { 0x10980, 0x1099F, },	direction = "rtl", }

m["Mlym"] = process_ranges{ "Malayalam", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0D00, 0x0D0C, 0x0D0E, 0x0D10, 0x0D12, 0x0D44, 0x0D46, 0x0D48, 0x0D4A, 0x0D4F, 0x0D54, 0x0D63, 0x0D66, 0x0D7F, 0x1CDA, 0x1CDA, 0x1CF2, 0x1CF2, 0xA830, 0xA832, },	normalizationFixes = handle_normalization_fixes{ from = {"ഇൗ", "ഉൗ", "എെ", "ഒാ", "ഒൗ", "ക്", "ണ്", "ന്‍റ", "ന്", "മ്", "യ്", "ര്", "ല്", "ള്", "ഴ്", "െെ", "ൻ്റ"}, to = {"ഈ", "ഊ", "ഐ", "ഓ", "ഔ", "ൿ", "ൺ", "ൻറ", "ൻ", "ൔ", "ൕ", "ർ", "ൽ", "ൾ", "ൖ", "ൈ", "ന്റ"} }, }

m["Modi"] = process_ranges{ "Modi", "abugida", ranges = { 0xA830, 0xA839, 0x11600, 0x11644, 0x11650, 0x11659, },	normalizationFixes = handle_normalization_fixes{ from = {"𑘀𑘹", "𑘀𑘺", "𑘁𑘹", "𑘁𑘺"}, to = {"𑘊", "𑘋", "𑘌", "𑘍"} }, }

m["Mong"] = process_ranges{ "Mongolian", "alphabet", aliases = {"Mongol bichig", "Hudum Mongol bichig"}, ranges = { 0x1800, 0x1805, 0x180A, 0x1819, 0x1820, 0x1842, 0x1878, 0x1878, 0x1880, 0x1897, 0x18A6, 0x18A6, 0x18A9, 0x18A9, 0x200C, 0x200D, 0x202F, 0x202F, 0x11660, 0x11668, },	direction = "vertical-ltr", }

m["mnc-Mong"] = process_ranges{ "Manchu", m["Mong"][2], ranges = { 0x1801, 0x1801, 0x1804, 0x1804, 0x1808, 0x180F, 0x1820, 0x1820, 0x1823, 0x1823, 0x1828, 0x182A, 0x182E, 0x1830, 0x1834, 0x1838, 0x183A, 0x183A, 0x185D, 0x185D, 0x185F, 0x1861, 0x1864, 0x1869, 0x186C, 0x1871, 0x1873, 0x1877, 0x1880, 0x1888, 0x188F, 0x188F, 0x189A, 0x18A5, 0x18A8, 0x18A8, 0x18AA, 0x18AA, 0x200C, 0x200D, 0x202F, 0x202F, },		direction = "vertical-ltr", parent = "Mong", }	m["sjo-Mong"] = process_ranges{ "Xibe", m["Mong"][2], aliases = {"Sibe"}, ranges = { 0x1804, 0x1804, 0x1807, 0x1807, 0x180A, 0x180F, 0x1820, 0x1820, 0x1823, 0x1823, 0x1828, 0x1828, 0x182A, 0x182A, 0x182E, 0x1830, 0x1834, 0x1838, 0x183A, 0x183A, 0x185D, 0x1872, 0x200C, 0x200D, 0x202F, 0x202F, },		direction = "vertical-ltr", parent = "mnc-Mong", }	m["xwo-Mong"] = process_ranges{ "Clear Script", m["Mong"][2], aliases = {"Todo", "Todo bichig"}, ranges = { 0x1800, 0x1801, 0x1804, 0x1806, 0x180A, 0x1820, 0x1828, 0x1828, 0x182F, 0x1831, 0x1834, 0x1834, 0x1837, 0x1838, 0x183A, 0x183B, 0x1840, 0x1840, 0x1843, 0x185C, 0x1880, 0x1887, 0x1889, 0x188F, 0x1894, 0x1894, 0x1896, 0x1899, 0x18A7, 0x18A7, 0x200C, 0x200D, 0x202F, 0x202F, 0x11669, 0x1166C, },		direction = "vertical-ltr", parent = "Mong", }

m["Moon"] = { "Moon", "alphabet", aliases = {"Moon System of Embossed Reading", "Moon type", "Moon writing", "Moon alphabet", "Moon code"}, -- Not in Unicode }

m["Morse"] = { "Morse code", ietf_subtag = "Zsym", }

m["Mroo"] = process_ranges{ "Mro", ranges = { 0x16A40, 0x16A5E, 0x16A60, 0x16A69, 0x16A6E, 0x16A6F, }, }

m["Mtei"] = process_ranges{ "Meitei Mayek", "abugida", aliases = {"Meetei Mayek", "Manipuri"}, ranges = { 0xAAE0, 0xAAF6, 0xABC0, 0xABED, 0xABF0, 0xABF9, }, }

m["Mult"] = process_ranges{ "Multani", "abugida", ranges = { 0x0A66, 0x0A6F, 0x11280, 0x11286, 0x11288, 0x11288, 0x1128A, 0x1128D, 0x1128F, 0x1129D, 0x1129F, 0x112A9, }, }

m["Music"] = process_ranges{ "Musical notation", "pictography", ranges = { 0x2669, 0x266F, 0x1D100, 0x1D126, 0x1D129, 0x1D1EA, },	ietf_subtag = "Zsym", translit = false, }

m["Mymr"] = process_ranges{ "Burmese", "abugida", aliases = {"Myanmar"}, ranges = { 0x1000, 0x109F, 0xA92E, 0xA92E, 0xA9E0, 0xA9FE, 0xAA60, 0xAA7F, },	spaces = false, }

m["Nagm"] = process_ranges{ "Nag Mundari", "alphabet", ranges = { 0x1E4D0, 0x1E4F9, }, }

m["Nand"] = process_ranges{ "Nandinagari", "abugida", ranges = { 0x0964, 0x0965, 0x0CE6, 0x0CEF, 0x1CE9, 0x1CE9, 0x1CF2, 0x1CF2, 0x1CFA, 0x1CFA, 0xA830, 0xA835, 0x119A0, 0x119A7, 0x119AA, 0x119D7, 0x119DA, 0x119E4, }, }

m["Narb"] = process_ranges{ "Old North Arabian", "abjad", ranges = { 0x10A80, 0x10A9F, },	direction = "rtl", }

m["Nbat"] = process_ranges{ "Nabataean", "abjad", aliases = {"Nabatean"}, ranges = { 0x10880, 0x1089E, 0x108A7, 0x108AF, },	direction = "rtl", }

m["Newa"] = process_ranges{ "Newa", "abugida", aliases = {"Newar", "Newari", "Prachalit Nepal"}, ranges = { 0x11400, 0x1145B, 0x1145D, 0x11461, }, }

m["Nkdb"] = { "Dongba", "pictography", aliases = {"Naxi Dongba", "Nakhi Dongba", "Tomba", "Tompa", "Mo-so"}, spaces = false, -- Not in Unicode }

m["Nkgb"] = { "Geba", "syllabary", aliases = {"Nakhi Geba", "Naxi Geba"}, spaces = false, -- Not in Unicode }

m["Nkoo"] = process_ranges{ "N'Ko", "alphabet", ranges = { 0x060C, 0x060C, 0x061B, 0x061B, 0x061F, 0x061F, 0x07C0, 0x07FA, 0x07FD, 0x07FF, 0xFD3E, 0xFD3F, },	direction = "rtl", }

m["None"] = { "Unspecified", -- renders as 'unspecified script' -- This should not have any characters listed ietf_subtag = "Zyyy", translit = false, character_category = false, }

m["Nshu"] = process_ranges{ "Nüshu", "syllabary", aliases = {"Nushu"}, ranges = { 0x16FE1, 0x16FE1, 0x1B170, 0x1B2FB, },	spaces = false, }

m["Ogam"] = process_ranges{ "Ogham", ranges = { 0x1680, 0x169C, }, }

m["Olck"] = process_ranges{ "Ol Chiki", ranges = { 0x1C50, 0x1C7F, }, }

m["Onao"] = { "Ol Onal", "alphabet", -- Not in Unicode }

m["Orkh"] = process_ranges{ "Orkhon runes", aliases = {"Old Turkic"}, ranges = { 0x10C00, 0x10C48, },	direction = "rtl", }

m["Orya"] = process_ranges{ "Odia", "abugida", aliases = {"Oriya"}, ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0B01, 0x0B03, 0x0B05, 0x0B0C, 0x0B0F, 0x0B10, 0x0B13, 0x0B28, 0x0B2A, 0x0B30, 0x0B32, 0x0B33, 0x0B35, 0x0B39, 0x0B3C, 0x0B44, 0x0B47, 0x0B48, 0x0B4B, 0x0B4D, 0x0B55, 0x0B57, 0x0B5C, 0x0B5D, 0x0B5F, 0x0B63, 0x0B66, 0x0B77, 0x1CDA, 0x1CDA, 0x1CF2, 0x1CF2, },	normalizationFixes = handle_normalization_fixes{ from = {"ଅା", "ଏୗ", "ଓୗ"}, to = {"ଆ", "ଐ", "ଔ"} }, }

m["Osge"] = process_ranges{ "Osage", ranges = { 0x104B0, 0x104D3, 0x104D8, 0x104FB, },	capitalized = true, }

m["Osma"] = process_ranges{ "Osmanya", ranges = { 0x10480, 0x1049D, 0x104A0, 0x104A9, }, }

m["Ougr"] = process_ranges{ "Old Uyghur", "abjad, alphabet", ranges = { 0x0640, 0x0640, 0x10AF2, 0x10AF2, 0x10F70, 0x10F89, },	-- This should ideally be "vertical-ltr", but getting the CSS right is tricky because it's right-to-left horizontally, but left-to-right vertically. Currently, displaying it vertically causes it to display bottom-to-top. direction = "rtl", }

m["Palm"] = process_ranges{ "Palmyrene", ranges = { 0x10860, 0x1087F, },	direction = "rtl", }

m["Pauc"] = process_ranges{ "Pau Cin Hau", ranges = { 0x11AC0, 0x11AF8, }, }

m["Perm"] = process_ranges{ "Old Permic", ranges = { 0x0483, 0x0483, 0x10350, 0x1037A, }, }

m["Phag"] = process_ranges{ "Phags-pa", "abugida", ranges = { 0x1802, 0x1803, 0x1805, 0x1805, 0x200C, 0x200D, 0x202F, 0x202F, 0x3002, 0x3002, 0xA840, 0xA877, },	direction = "vertical-ltr", }

m["Phli"] = process_ranges{ "Inscriptional Pahlavi", "abjad", ranges = { 0x10B60, 0x10B72, 0x10B78, 0x10B7F, },	direction = "rtl", }

m["Phlp"] = process_ranges{ "Psalter Pahlavi", "abjad", ranges = { 0x0640, 0x0640, 0x10B80, 0x10B91, 0x10B99, 0x10B9C, 0x10BA9, 0x10BAF, },	direction = "rtl", }

m["Phlv"] = { "Book Pahlavi", "abjad", direction = "rtl", -- Not in Unicode }

m["Phnx"] = process_ranges{ "Phoenician", "abjad", ranges = { 0x10900, 0x1091B, 0x1091F, 0x1091F, },	direction = "rtl", }

m["Plrd"] = process_ranges{ "Pollard", "abugida", aliases = {"Miao"}, ranges = { 0x16F00, 0x16F4A, 0x16F4F, 0x16F87, 0x16F8F, 0x16F9F, }, }

m["Prti"] = process_ranges{ "Inscriptional Parthian", ranges = { 0x10B40, 0x10B55, 0x10B58, 0x10B5F, },	direction = "rtl", }

m["Ranj"] = { "Ranjana", "abugida", -- Not in Unicode }

m["Rjng"] = process_ranges{ "Rejang", "abugida", ranges = { 0xA930, 0xA953, 0xA95F, 0xA95F, }, }

m["Rohg"] = process_ranges{ "Hanifi Rohingya", "alphabet", ranges = { 0x060C, 0x060C, 0x061B, 0x061B, 0x061F, 0x061F, 0x0640, 0x0640, 0x06D4, 0x06D4, 0x10D00, 0x10D27, 0x10D30, 0x10D39, },	direction = "rtl", }

m["Roro"] = { "Rongorongo", -- Not in Unicode }

m["Rumin"] = process_ranges{ "Rumi numerals", ranges = { 0x10E60, 0x10E7E, },	ietf_subtag = "Arab", character_category = "Rumi numerals", }

m["Runr"] = process_ranges{ "Runic", "alphabet", ranges = { 0x16A0, 0x16EA, 0x16EE, 0x16F8, }, }

m["Samr"] = process_ranges{ "Samaritan", "abjad", ranges = { 0x0800, 0x082D, 0x0830, 0x083E, },	direction = "rtl", }

m["Sarb"] = process_ranges{ "Old South Arabian", "abjad", ranges = { 0x10A60, 0x10A7F, },	direction = "rtl", }

m["Saur"] = process_ranges{ "Saurashtra", "abugida", ranges = { 0xA880, 0xA8C5, 0xA8CE, 0xA8D9, }, }

m["Semap"] = { "flag semaphore", "pictography", ietf_subtag = "Zsym", }

m["Sgnw"] = process_ranges{ "SignWriting", "pictography", aliases = {"Sutton SignWriting"}, ranges = { 0x1D800, 0x1DA8B, 0x1DA9B, 0x1DA9F, 0x1DAA1, 0x1DAAF, },	translit = false, }

m["Shaw"] = process_ranges{ "Shavian", aliases = {"Shaw"}, ranges = { 0x10450, 0x1047F, }, }

m["Shrd"] = process_ranges{ "Sharada", "abugida", ranges = { 0x0951, 0x0951, 0x1CD7, 0x1CD7, 0x1CD9, 0x1CD9, 0x1CDC, 0x1CDD, 0x1CE0, 0x1CE0, 0xA830, 0xA835, 0xA838, 0xA838, 0x11180, 0x111DF, }, }

m["Shui"] = { "Sui", "logography", spaces = false, -- Not in Unicode }

m["Sidd"] = process_ranges{ "Siddham", "abugida", ranges = { 0x11580, 0x115B5, 0x115B8, 0x115DD, }, }

m["Sidt"] = { "Sidetic", "alphabet", direction = "rtl", -- Not in Unicode }

m["Sind"] = process_ranges{ "Khudawadi", "abugida", aliases = {"Khudabadi"}, ranges = { 0x0964, 0x0965, 0xA830, 0xA839, 0x112B0, 0x112EA, 0x112F0, 0x112F9, },	normalizationFixes = handle_normalization_fixes{ from = {"𑊰𑋠", "𑊰𑋥", "𑊰𑋦", "𑊰𑋧", "𑊰𑋨"}, to = {"𑊱", "𑊶", "𑊷", "𑊸", "𑊹"} }, }

m["Sinh"] = process_ranges{ "Sinhalese", "abugida", aliases = {"Sinhala"}, ranges = { 0x0964, 0x0965, 0x0D81, 0x0D83, 0x0D85, 0x0D96, 0x0D9A, 0x0DB1, 0x0DB3, 0x0DBB, 0x0DBD, 0x0DBD, 0x0DC0, 0x0DC6, 0x0DCA, 0x0DCA, 0x0DCF, 0x0DD4, 0x0DD6, 0x0DD6, 0x0DD8, 0x0DDF, 0x0DE6, 0x0DEF, 0x0DF2, 0x0DF4, 0x1CF2, 0x1CF2, 0x111E1, 0x111F4, },	normalizationFixes = handle_normalization_fixes{ from = {"අා", "අැ", "අෑ", "උෟ", "ඍෘ", "ඏෟ", "එ්", "එෙ", "ඔෟ", "ෘෘ"}, to = {"ආ", "ඇ", "ඈ", "ඌ", "ඎ", "ඐ", "ඒ", "ඓ", "ඖ", "ෲ"} }, }

m["Sogd"] = process_ranges{ "Sogdian", "abjad", ranges = { 0x0640, 0x0640, 0x10F30, 0x10F59, },	direction = "rtl", }

m["Sogo"] = process_ranges{ "Old Sogdian", "abjad", ranges = { 0x10F00, 0x10F27, },	direction = "rtl", }

m["Sora"] = process_ranges{ "Sorang Sompeng", aliases = {"Sora Sompeng"}, ranges = { 0x110D0, 0x110E8, 0x110F0, 0x110F9, }, }

m["Soyo"] = process_ranges{ "Soyombo", "abugida", ranges = { 0x11A50, 0x11AA2, }, }

m["Sund"] = process_ranges{ "Sundanese", "abugida", ranges = { 0x1B80, 0x1BBF, 0x1CC0, 0x1CC7, }, }

m["Sunu"] = { "Sunuwar", "alphabet", -- Not in Unicode }

m["Sylo"] = process_ranges{ "Syloti Nagri", "abugida", aliases = {"Sylheti Nagari"}, ranges = { 0x0964, 0x0965, 0x09E6, 0x09EF, 0xA800, 0xA82C, }, }

m["Syrc"] = process_ranges{ "Syriac", "abjad",	-- more precisely, impure abjad ranges = { 0x060C, 0x060C, 0x061B, 0x061C, 0x061F, 0x061F, 0x0640, 0x0640, 0x064B, 0x0655, 0x0670, 0x0670, 0x0700, 0x070D, 0x070F, 0x074A, 0x074D, 0x074F, 0x0860, 0x086A, 0x1DF8, 0x1DF8, 0x1DFA, 0x1DFA, },	direction = "rtl", }

-- Syre, Syrj, Syrn are apparently subsumed into Syrc; discuss if this causes issues

m["Tagb"] = process_ranges{ "Tagbanwa", "abugida", ranges = { 0x1735, 0x1736, 0x1760, 0x176C, 0x176E, 0x1770, 0x1772, 0x1773, }, }

m["Takr"] = process_ranges{ "Takri", "abugida", ranges = { 0x0964, 0x0965, 0xA830, 0xA839, 0x11680, 0x116B9, 0x116C0, 0x116C9, },	normalizationFixes = handle_normalization_fixes{ from = {"𑚀𑚭", "𑚀𑚴", "𑚀𑚵", "𑚆𑚲"}, to = {"𑚁", "𑚈", "𑚉", "𑚇"} }, }

m["Tale"] = process_ranges{ "Tai Nüa", "abugida", aliases = {"Tai Nuea", "New Tai Nüa", "New Tai Nuea", "Dehong Dai", "Tai Dehong", "Tai Le"}, ranges = { 0x1040, 0x1049, 0x1950, 0x196D, 0x1970, 0x1974, },	spaces = false, }

m["Talu"] = process_ranges{ "New Tai Lue", "abugida", ranges = { 0x1980, 0x19AB, 0x19B0, 0x19C9, 0x19D0, 0x19DA, 0x19DE, 0x19DF, },	spaces = false, }

m["Taml"] = process_ranges{ "Tamil", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0B82, 0x0B83, 0x0B85, 0x0B8A, 0x0B8E, 0x0B90, 0x0B92, 0x0B95, 0x0B99, 0x0B9A, 0x0B9C, 0x0B9C, 0x0B9E, 0x0B9F, 0x0BA3, 0x0BA4, 0x0BA8, 0x0BAA, 0x0BAE, 0x0BB9, 0x0BBE, 0x0BC2, 0x0BC6, 0x0BC8, 0x0BCA, 0x0BCD, 0x0BD0, 0x0BD0, 0x0BD7, 0x0BD7, 0x0BE6, 0x0BFA, 0x1CDA, 0x1CDA, 0xA8F3, 0xA8F3, 0x11301, 0x11301, 0x11303, 0x11303, 0x1133B, 0x1133C, 0x11FC0, 0x11FF1, 0x11FFF, 0x11FFF, },	normalizationFixes = handle_normalization_fixes{ from = {"அூ", "ஸ்ரீ"}, to = {"ஆ", "ஶ்ரீ"} }, }

m["Tang"] = process_ranges{ "Tangut", "logography, syllabary", ranges = { 0x16FE0, 0x16FE0, 0x17000, 0x187F7, 0x18800, 0x18AFF, 0x18D00, 0x18D08, },	spaces = false, }

m["Tavt"] = process_ranges{ "Tai Viet", "abugida", ranges = { 0xAA80, 0xAAC2, 0xAADB, 0xAADF, },	spaces = false, }

m["Tayo"] = { "Lai Tay", "abugida", aliases = {"Tai Yo"}, direction = "vertical-rtl", -- Not in Unicode }

m["Telu"] = process_ranges{ "Telugu", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x0C00, 0x0C0C, 0x0C0E, 0x0C10, 0x0C12, 0x0C28, 0x0C2A, 0x0C39, 0x0C3C, 0x0C44, 0x0C46, 0x0C48, 0x0C4A, 0x0C4D, 0x0C55, 0x0C56, 0x0C58, 0x0C5A, 0x0C5D, 0x0C5D, 0x0C60, 0x0C63, 0x0C66, 0x0C6F, 0x0C77, 0x0C7F, 0x1CDA, 0x1CDA, 0x1CF2, 0x1CF2, },	normalizationFixes = handle_normalization_fixes{ from = {"ఒౌ", "ఒౕ", "ిౕ", "ెౕ", "ొౕ"}, to = {"ఔ", "ఓ", "ీ", "ే", "ో"} }, }

m["Teng"] = { "Tengwar", }

m["Tfng"] = process_ranges{ "Tifinagh", "abjad, alphabet", ranges = { 0x2D30, 0x2D67, 0x2D6F, 0x2D70, 0x2D7F, 0x2D7F, },	otherNames = {"Libyco-Berber", "Berber"}, -- per Wikipedia, Libyco-Berber is the parent }

m["Tglg"] = process_ranges{ "Baybayin", "abugida", aliases = {"Tagalog"}, ranges = { 0x1700, 0x1715, 0x171F, 0x171F, 0x1735, 0x1736, }, }

m["Thaa"] = process_ranges{ "Thaana", "abugida", ranges = { 0x060C, 0x060C, 0x061B, 0x061C, 0x061F, 0x061F, 0x0660, 0x0669, 0x0780, 0x07B1, 0xFDF2, 0xFDF2, 0xFDFD, 0xFDFD, },	direction = "rtl", }

m["Thai"] = process_ranges{ "Thai", "abugida", ranges = { 0x0E01, 0x0E3A, 0x0E40, 0x0E5B, },	spaces = false, }

m["Tibt"] = process_ranges{ "Tibetan", "abugida", ranges = { 0x0F00, 0x0F47, 0x0F49, 0x0F6C, 0x0F71, 0x0F97, 0x0F99, 0x0FBC, 0x0FBE, 0x0FCC, 0x0FCE, 0x0FD4, 0x0FD9, 0x0FDA, },	normalizationFixes = handle_normalization_fixes{ combiningClasses = {["༹"] = 1}, from = {"ཷ", "ཹ"}, to = {"ྲཱྀ", "ླཱྀ"} }, }

m["sit-tam-Tibt"] = { "Tamyig", m["Tibt"][2], ranges = m["Tibt"].ranges, characters = m["Tibt"].characters, parent = "Tibt", normalizationFixes = m["Tibt"].normalizationFixes, }

m["Tirh"] = process_ranges{ "Tirhuta", "abugida", ranges = { 0x0951, 0x0952, 0x0964, 0x0965, 0x1CF2, 0x1CF2, 0xA830, 0xA839, 0x11480, 0x114C7, 0x114D0, 0x114D9, },	normalizationFixes = handle_normalization_fixes{ from = {"𑒁𑒰", "𑒋𑒺", "𑒍𑒺", "𑒪𑒵", "𑒪𑒶"}, to = {"𑒂", "𑒌", "𑒎", "𑒉", "𑒊"} }, }

m["Tnsa"] = process_ranges{ "Tangsa", "alphabet", ranges = { 0x16A70, 0x16ABE, 0x16AC0, 0x16AC9, }, }

m["Todr"] = { "Todhri", "alphabet", direction = "rtl", -- Not in Unicode }

m["Tols"] = { "Tolong Siki", "alphabet", -- Not in Unicode }

m["Toto"] = process_ranges{ "Toto", "abugida", ranges = { 0x1E290, 0x1E2AE, }, }

m["Tutg"] = { "Tigalari", "abugida", aliases = {"Tulu"}, -- Not in Unicode }

m["Ugar"] = process_ranges{ "Ugaritic", "abjad", ranges = { 0x10380, 0x1039D, 0x1039F, 0x1039F, }, }

m["Vaii"] = process_ranges{ "Vai", "syllabary", ranges = { 0xA500, 0xA62B, }, }

m["Visp"] = { "Visible Speech", "alphabet", -- Not in Unicode }

m["Vith"] = process_ranges{ "Vithkuqi", "alphabet", ranges = { 0x10570, 0x1057A, 0x1057C, 0x1058A, 0x1058C, 0x10592, 0x10594, 0x10595, 0x10597, 0x105A1, 0x105A3, 0x105B1, 0x105B3, 0x105B9, 0x105BB, 0x105BC, },	capitalized = true, }

m["Wara"] = process_ranges{ "Varang Kshiti", aliases = {"Warang Citi"}, ranges = { 0x118A0, 0x118F2, 0x118FF, 0x118FF, },	capitalized = true, }

m["Wcho"] = process_ranges{ "Wancho", "alphabet", ranges = { 0x1E2C0, 0x1E2F9, 0x1E2FF, 0x1E2FF, }, }

m["Wole"] = { "Woleai", "syllabary", -- Not in Unicode }

m["Xpeo"] = process_ranges{ "Old Persian", ranges = { 0x103A0, 0x103C3, 0x103C8, 0x103D5, }, }

m["Xsux"] = process_ranges{ "Cuneiform", aliases = {"Sumero-Akkadian Cuneiform"}, ranges = { 0x12000, 0x12399, 0x12400, 0x1246E, 0x12470, 0x12474, 0x12480, 0x12543, }, }

m["Yezi"] = process_ranges{ "Yezidi", "alphabet", ranges = { 0x060C, 0x060C, 0x061B, 0x061B, 0x061F, 0x061F, 0x0660, 0x0669, 0x10E80, 0x10EA9, 0x10EAB, 0x10EAD, 0x10EB0, 0x10EB1, },	direction = "rtl", }

m["Yiii"] = process_ranges{ "Yi", "syllabary", ranges = { 0x3001, 0x3002, 0x3008, 0x3011, 0x3014, 0x301B, 0x30FB, 0x30FB, 0xA000, 0xA48C, 0xA490, 0xA4C6, 0xFF61, 0xFF65, }, }

m["Zanb"] = process_ranges{ "Zanabazar Square", ranges = { 0x11A00, 0x11A47, }, }

m["Zmth"] = process_ranges{ "mathematical notation", ranges = { 0x00AC, 0x00AC, 0x00B1, 0x00B1, 0x00D7, 0x00D7, 0x00F7, 0x00F7, 0x03D0, 0x03D2, 0x03D5, 0x03D5, 0x03F0, 0x03F1, 0x03F4, 0x03F6, 0x0606, 0x0608, 0x2016, 0x2016, 0x2032, 0x2034, 0x2040, 0x2040, 0x2044, 0x2044, 0x2052, 0x2052, 0x205F, 0x205F, 0x2061, 0x2064, 0x207A, 0x207E, 0x208A, 0x208E, 0x20D0, 0x20DC, 0x20E1, 0x20E1, 0x20E5, 0x20E6, 0x20EB, 0x20EF, 0x2102, 0x2102, 0x2107, 0x2107, 0x210A, 0x2113, 0x2115, 0x2115, 0x2118, 0x211D, 0x2124, 0x2124, 0x2128, 0x2129, 0x212C, 0x212D, 0x212F, 0x2131, 0x2133, 0x2138, 0x213C, 0x2149, 0x214B, 0x214B, 0x2190, 0x21A7, 0x21A9, 0x21AE, 0x21B0, 0x21B1, 0x21B6, 0x21B7, 0x21BC, 0x21DB, 0x21DD, 0x21DD, 0x21E4, 0x21E5, 0x21F4, 0x22FF, 0x2308, 0x230B, 0x2320, 0x2321, 0x237C, 0x237C, 0x239B, 0x23B5, 0x23B7, 0x23B7, 0x23D0, 0x23D0, 0x23DC, 0x23E2, 0x25A0, 0x25A1, 0x25AE, 0x25B7, 0x25BC, 0x25C1, 0x25C6, 0x25C7, 0x25CA, 0x25CB, 0x25CF, 0x25D3, 0x25E2, 0x25E2, 0x25E4, 0x25E4, 0x25E7, 0x25EC, 0x25F8, 0x25FF, 0x2605, 0x2606, 0x2640, 0x2640, 0x2642, 0x2642, 0x2660, 0x2663, 0x266D, 0x266F, 0x27C0, 0x27FF, 0x2900, 0x2AFF, 0x2B30, 0x2B44, 0x2B47, 0x2B4C, 0xFB29, 0xFB29, 0xFE61, 0xFE66, 0xFE68, 0xFE68, 0xFF0B, 0xFF0B, 0xFF1C, 0xFF1E, 0xFF3C, 0xFF3C, 0xFF3E, 0xFF3E, 0xFF5C, 0xFF5C, 0xFF5E, 0xFF5E, 0xFFE2, 0xFFE2, 0xFFE9, 0xFFEC, 0x1D400, 0x1D454, 0x1D456, 0x1D49C, 0x1D49E, 0x1D49F, 0x1D4A2, 0x1D4A2, 0x1D4A5, 0x1D4A6, 0x1D4A9, 0x1D4AC, 0x1D4AE, 0x1D4B9, 0x1D4BB, 0x1D4BB, 0x1D4BD, 0x1D4C3, 0x1D4C5, 0x1D505, 0x1D507, 0x1D50A, 0x1D50D, 0x1D514, 0x1D516, 0x1D51C, 0x1D51E, 0x1D539, 0x1D53B, 0x1D53E, 0x1D540, 0x1D544, 0x1D546, 0x1D546, 0x1D54A, 0x1D550, 0x1D552, 0x1D6A5, 0x1D6A8, 0x1D7CB, 0x1D7CE, 0x1D7FF, 0x1EE00, 0x1EE03, 0x1EE05, 0x1EE1F, 0x1EE21, 0x1EE22, 0x1EE24, 0x1EE24, 0x1EE27, 0x1EE27, 0x1EE29, 0x1EE32, 0x1EE34, 0x1EE37, 0x1EE39, 0x1EE39, 0x1EE3B, 0x1EE3B, 0x1EE42, 0x1EE42, 0x1EE47, 0x1EE47, 0x1EE49, 0x1EE49, 0x1EE4B, 0x1EE4B, 0x1EE4D, 0x1EE4F, 0x1EE51, 0x1EE52, 0x1EE54, 0x1EE54, 0x1EE57, 0x1EE57, 0x1EE59, 0x1EE59, 0x1EE5B, 0x1EE5B, 0x1EE5D, 0x1EE5D, 0x1EE5F, 0x1EE5F, 0x1EE61, 0x1EE62, 0x1EE64, 0x1EE64, 0x1EE67, 0x1EE6A, 0x1EE6C, 0x1EE72, 0x1EE74, 0x1EE77, 0x1EE79, 0x1EE7C, 0x1EE7E, 0x1EE7E, 0x1EE80, 0x1EE89, 0x1EE8B, 0x1EE9B, 0x1EEA1, 0x1EEA3, 0x1EEA5, 0x1EEA9, 0x1EEAB, 0x1EEBB, 0x1EEF0, 0x1EEF1, },	translit = false, character_category = "Mathematical notation symbols", -- ? }

m["Zsym"] = process_ranges{ "symbol", "pictography", ranges = { 0x20DD, 0x20E0, 0x20E2, 0x20E4, 0x20E7, 0x20EA, 0x20F0, 0x20F0, 0x2100, 0x2101, 0x2103, 0x2106, 0x2108, 0x2109, 0x2114, 0x2114, 0x2116, 0x2117, 0x211E, 0x2123, 0x2125, 0x2127, 0x212A, 0x212B, 0x212E, 0x212E, 0x2132, 0x2132, 0x2139, 0x213B, 0x214A, 0x214A, 0x214C, 0x214F, 0x21A8, 0x21A8, 0x21AF, 0x21AF, 0x21B2, 0x21B5, 0x21B8, 0x21BB, 0x21DC, 0x21DC, 0x21DE, 0x21E3, 0x21E6, 0x21F3, 0x2300, 0x2307, 0x230C, 0x231F, 0x2322, 0x237B, 0x237D, 0x239A, 0x23B6, 0x23B6, 0x23B8, 0x23CF, 0x23D1, 0x23DB, 0x23E3, 0x23FF, 0x2500, 0x259F, 0x25A2, 0x25AD, 0x25B8, 0x25BB, 0x25C2, 0x25C5, 0x25C8, 0x25C9, 0x25CC, 0x25CE, 0x25D4, 0x25E1, 0x25E3, 0x25E3, 0x25E5, 0x25E6, 0x25ED, 0x25F7, 0x2600, 0x2604, 0x2607, 0x263F, 0x2641, 0x2641, 0x2643, 0x265F, 0x2664, 0x266C, 0x2670, 0x27BF, 0x2B00, 0x2B2F, 0x2B45, 0x2B46, 0x2B4D, 0x2B73, 0x2B76, 0x2B95, 0x2B97, 0x2BFF, 0x4DC0, 0x4DFF, 0x1F000, 0x1F02B, 0x1F030, 0x1F093, 0x1F0A0, 0x1F0AE, 0x1F0B1, 0x1F0BF, 0x1F0C1, 0x1F0CF, 0x1F0D1, 0x1F0F5, 0x1F300, 0x1F6D7, 0x1F6DC, 0x1F6EC, 0x1F6F0, 0x1F6FC, 0x1F700, 0x1F776, 0x1F77B, 0x1F7D9, 0x1F7E0, 0x1F7EB, 0x1F7F0, 0x1F7F0, 0x1F800, 0x1F80B, 0x1F810, 0x1F847, 0x1F850, 0x1F859, 0x1F860, 0x1F887, 0x1F890, 0x1F8AD, 0x1F8B0, 0x1F8B1, 0x1F900, 0x1FA53, 0x1FA60, 0x1FA6D, 0x1FA70, 0x1FA7C, 0x1FA80, 0x1FA88, 0x1FA90, 0x1FABD, 0x1FABF, 0x1FAC5, 0x1FACE, 0x1FADB, 0x1FAE0, 0x1FAE8, 0x1FAF0, 0x1FAF8, 0x1FB00, 0x1FB92, 0x1FB94, 0x1FBCA, 0x1FBF0, 0x1FBF9, },	translit = false, character_category = false, -- none }

m["Zyyy"] = { "undetermined", -- This should not have any characters listed, probably translit = false, character_category = false, -- none }

m["Zzzz"] = { "uncoded", -- This should not have any characters listed translit = false, character_category = false, -- none }

-- These should be defined after the scripts they are composed of.

m["Hrkt"] = process_ranges{ "Kana", "syllabary", aliases = {"Japanese syllabaries"}, ranges = union(		m["Hira"].ranges,		m["Kana"].ranges	), spaces = false, }

m["Jpan"] = process_ranges{ "Japanese", "logography, syllabary", ranges = union(		m["Hrkt"].ranges,		m["Hani"].ranges,		m["Latn"].ranges	), spaces = false, sort_by_scraping = true, }

m["Kore"] = process_ranges{ "Korean", "logography, syllabary", ranges = union(		m["Hang"].ranges,		m["Hani"].ranges,		m["Latn"].ranges	), }

return m

title: Module:scripts/data


text:
palīdzēts

Participle

 * 1) helped;

license: Creative Commons - Attribution Share-Alike - https://creativecommons.org/licenses/by-sa/4.0/

title: palīdzēts


text:
nepalīdzēts

Participle

 * 1) not helped;

title: nepalīdzēts


text:
līdzēts

Participle

 * 1) helped;

title: līdzēts


text:
nelīdzēts

Participle

 * 1) not helped;

title: nelīdzēts


text:
eksistēšana

Etymology
From.

Noun

 * 1) existing;

title: eksistēšana


text:
neeksistēšana

Etymology
From.

Noun

 * 1) not existing;

title: neeksistēšana


text:
jautāšana

Etymology
From.

Noun

 * 1) asking, enquiring, questioning;

title: jautāšana


text:
palīdzēšana

Etymology
From.

Noun

 * 1) helping;

title: palīdzēšana


text:
līdzēšana

Etymology
From.

Noun

 * 1) not helping;

title: līdzēšana


text:
nelīdzēšana

Etymology
From.

Noun

 * 1) not helping;

title: nelīdzēšana


text: eksistēšanā

title: eksistēšanā


text: eksistēšanu

title: eksistēšanu


text: eksistēšanas

title: eksistēšanas


text: eksistēšanai

title: eksistēšanai


text: neeksistēšanā

title: neeksistēšanā


text: neeksistēšanu

title: neeksistēšanu


text: neeksistēšanai

title: neeksistēšanai


text: neeksistēšanas

title: neeksistēšanas


text: jautāšanas

title: jautāšanas


text: jautāšanā

title: jautāšanā


text:
nejautāšana

Etymology
From.

Noun

 * 1) not asking, not enquiring, not questioning;

title: nejautāšana


text: nejautāšanā

title: nejautāšanā


text: nejautāšanas

title: nejautāšanas


text: nejautāšanai

title: nejautāšanai


text: nejautāšanu

title: nejautāšanu


text: palīdzēšanā

title: palīdzēšanā


text:
nepalīdzēšana

Etymology
From.

Noun

 * 1) not helping;

title: nepalīdzēšana


text: palīdzēšanu

title: palīdzēšanu


text: palīdzēšanas

title: palīdzēšanas


text: palīdzēšanai

title: palīdzēšanai


text: nepalīdzēšanā

title: nepalīdzēšanā


text: nepalīdzēšanas

title: nepalīdzēšanas


text: nepalīdzēšanu

title: nepalīdzēšanu


text: nepalīdzēšanai

title: nepalīdzēšanai


text: līdzēšanai

title: līdzēšanai


text: līdzēšanas

title: līdzēšanas


text: līdzēšanu

title: līdzēšanu


text: līdzēšanā

title: līdzēšanā


text: nelīdzēšanu

title: nelīdzēšanu


text: nelīdzēšanā

title: nelīdzēšanā


text: nelīdzēšanas

title: nelīdzēšanas


text: nelīdzēšanai

title: nelīdzēšanai


text: eksistēdama

title: eksistēdama


text: shariah

title: shariah


text: shakujō

title: shakujō


text: eksistēdami

title: eksistēdami


text: しゃくじょう

title: しゃくじょう


text: eksistēdamas

title: eksistēdamas


text: neeksistēdama

title: neeksistēdama


text: neeksistēdami

title: neeksistēdami


text: neeksistēdamas

title: neeksistēdamas


text: jautādama

title: jautādama


text: jautādami

title: jautādami


text: jautādamas

title: jautādamas


text: nejautādama

title: nejautādama


text: nejautādami

title: nejautādami


text: nejautādamas

title: nejautādamas


text: palīdzēdama

title: palīdzēdama


text: palīdzēdami

title: palīdzēdami


text: palīdzēdamas

title: palīdzēdamas


text: nepalīdzēdama

title: nepalīdzēdama


text: nepalīdzēdami

title: nepalīdzēdami


text: nepalīdzēdamas

title: nepalīdzēdamas


text: līdzēdama

title: līdzēdama


text: līdzēdami

title: līdzēdami


text: līdzēdamas

title: līdzēdamas


text: nelīdzēdama

title: nelīdzēdama


text: nelīdzēdami

title: nelīdzēdami


text: nelīdzēdamas

title: nelīdzēdamas


text:
aan-

Prefix

 * 1) A prefix appended to a small group of verbs; for which it has an intensive meaning.

title: aan-


text:
bloed-

Etymology
From.

Prefix

 * 1)   very, intensely, incredibly

title: bloed-


text:
פטל אדום

Noun

 * 1) raspberry (the plant )

title: פטל אדום


text: Category:Dutch terms prefixed with bloed-


text:
Talk:deponens

I this article the nominative singular of the participle is written as dēpōnens (last e short), but the dictionary form is written as "dēpōnēns m, f, n ..." (last e long).

This does not agree with each other. I think the nominative singular should be written as dēpōnēns. Am I right? 2001:838:305:0:0:0:0:3 19:16, 30 June 2013 (UTC)
 * They definitely should match. I suspect the version without the macron is correct, but I'll have to look it up. Chuck Entz (talk) 23:49, 30 June 2013 (UTC)

title: Talk:deponens


text:
basarunek

Etymology
.

Noun

 * 1)  lash
 * 2)  compensation for damages
 * 1)  compensation for damages

title: basarunek


text:
ładunek

Etymology
From or. Compare 🇨🇬.

Noun

 * 1)  load, cargo
 * 2)  charge
 * 1)  charge

title: ładunek


text:
malunek

Etymology
From, or formed from (rare) by analogy with other German loans.

Noun

 * 1)  painting

title: malunek


text:
meldunek

Etymology
.

Noun

 * 1) report

title: meldunek


text:
Citations:yamless

Adjective: "without a yam or yams"

 * 1974, Frederick Goodridge, "Of fermented malt and grain beverages", The Heights (Boston College), Volume LV, Number 13, 25 November 1974, page 11:
 * Advice, merely. Beer is brewed from grain (cereal), malt, hops, yeast and water. It is full of starch and carbohydrates. Those who quaff more than a couple a week would find it wise (if their waistlines want worrying) to eliminate certain other sources of these elements from their diets: no morning Kellogg's, yamless meals, a saladal substitute for a sandwich.
 * 1976, T. C. Nwosu, The Blind Spots of God, Cross Continental Press (1976), ISBN 9789781340024, page 17:
 * Parboiled yamless porridge mixed with 'land-army' vegetables and some edible rodents?
 * 1989, Fred Chappell, "Chronicling the Culture: The Poet and the Modern Epic Ambition", Imprimis (Hillsdale College), May 1989:
 * If his poem demands no sweet potatoes, then it must go yamless, and to hell with those numbers collected so expensively and assiduously.
 * 2000, Cathy Gant Hill, "Let Others Cook On Turkey Day", News & Record, 22 November 2000:
 * If you don't feel like cooking this Thanksgiving, that's no reason to go hamless, yamless and - heaven forbid - Spamless.
 * 2003, R. T. Smith, "Twang Chic: Sam Buckhannon Explores the Latest Fashion", in The Hollow Log Lounge: Poems, University of Illinois Press (2003), ISBN 9780252092442, page 39:
 * Midwest porkless, yamless, no-cornbread-or-cracklin' patter.
 * 2011, David Freid, "Surviving the Thanksgiving Apocalypse", The Huffington Post, 23 November 2011:
 * I was lucky with this one, as my roommate's girlfriend left me the aforementioned yams. She took care of this step for me. But if you find yourself yamless, get out and fill your home with a small reminder of the holiday.

title: Citations:yamless


text: Category:Dutch terms prefixed with boven-


text:
yamless

Adjective

 * 1) Without a yam or yams.
 * 2) * 1974, Frederick Goodridge, "Of fermented malt and grain beverages", The Heights (Boston College), Volume LV, Number 13, 25 November 1974, page 11:
 * Advice, merely. Beer is brewed from grain (cereal), malt, hops, yeast and water. It is full of starch and carbohydrates. Those who quaff more than a couple a week would find it wise (if their waistlines want worrying) to eliminate certain other sources of these elements from their diets: no morning Kellogg's, yamless meals, a saladal substitute for a sandwich.

title: yamless


text:
pakunek

Etymology
.

Noun

 * 1) package
 * 2) wad
 * 1) wad

title: pakunek


text:
boven-

Prefix

 * 1) upper, above

title: boven-


text: Template:gml-verb

title: Template:gml-verb


text:
פטל שחור

Noun

 * 1) blackberry

title: פטל שחור


text: rugadh

title: rugadh


text:
корез

Etymology
.

Noun

 * 1) qanat, karez

title: корез


text: کاریزها

title: کاریزها


text:
symmict

Etymology
From.

Adjective

 * 1)  Describing a sedimentation unit that lacks structure and is composed of various-sized particles that are mixed to a greater extent in the lower section.

title: symmict


text: zanbatō

title: zanbatō


text:
ざんばとう

Noun

 * 1)  An especially large, curved sword

title: ざんばとう


text:
toereikend

Adjective

 * De rechtbank concludeert dat de bewijzen niet toereikend zijn.
 * Court concludes that proof is not adequate.
 * Court concludes that proof is not adequate.

title: toereikend


text:
Module:labels

local export = {}

export.lang_specific_data_list_module = "Module:labels/data/lang" export.lang_specific_data_modules_prefix = "Module:labels/data/lang/" local m_lang_specific_data = mw.loadData(export.lang_specific_data_list_module) local parse_utilities_module = "Module:parse utilities" local string_utilities_module = "Module:string utilities" local table_module = "Module:table" local utilities_module = "Module:utilities"

--[==[ intro: Labels go through several stages of processing to get from the original (raw) label specified in the Wikicode to the final (formatted) label displayed to the user. The following terminology will help keep things straight:

to fetch the associated label data structure and determine the canonical form of the label. Normally this is the same as the raw label, but it will be different if the raw label is of the form `! label ` (e.g. `!Australian`) ` label ! display ` (e.g. `Southern US!Southern`). The former syntax indicates that the label should display as-is instead of in its canonical form (which in the example given is `Australia`), and the latter syntax indicates that the label should display in the form specified after the exclamation point. canonical label rather than the non-canonical label is what is shown to the user. display form to get the formatted form of the label. The display form comes from the `.display` field of the module label data for the label; if no such field exists in the label data, it is normally the canonical label. However, if the display override exists (see below), it takes precedence over the `.display` field or canonical label when determining the display form of the label. specified in two circumstances, i.e. in the `! label ` and ` label ! display ` raw label formats (i.e. in the same cirumstances where the raw label and non-canonical label are different). the user as the display form of the label, but in the Wikicode, the formatted form may wrap the display form with a link to Wikipedia, the Wiktionary glossary or another Wiktionary entry, and that link in turn may be wrapped in an  HTML span with a "deprecated" CSS class attached, causing the label to display differently (to indicate that it is  deprecated). ]==]
 * The "raw label" is the label specified in the Wikicode.
 * The "non-canonical label" is the label extracted from the raw label, used for looking up in the label modules in order
 * The "canonical label" is the result of applying alias resolution to the non-canonical label. Normally, the
 * The "display form of the label" is what is shown to the user, not considering links and HTML that may wrap the
 * The "display override", if specified, overrides all other means of determining the display form of the label. It is
 * The "formatted form of the label" is the final form of the label shown directly to the user. It generally appears to

-- for testing local force_cat = false

local SUBPAGENAME = mw.title.getCurrentTitle.subpageText

-- Disable tracking on heavy pages to save time. local pages_where_tracking_is_disabled = { -- pages that consistently hit timeouts ["a"] = true, -- pages that sometimes hit timeouts ["de"] = true, ["i"] = true, ["и"] = true, ["山"] = true, ["子"] = true, ["月"] = true, }

-- Add tracking category for PAGE. The tracking category linked to is Tracking/labels/PAGE. -- We also add to Tracking/labels/PAGE/LANGCODE and Tracking/labels/PAGE/MODE if -- LANGCODE and/or MODE given. local function track(page, langcode, mode) if pages_where_tracking_is_disabled[SUBPAGENAME] then return true end -- avoid including links in pages (may cause error) page = page:gsub("%[", "("):gsub("%]", ")"):gsub("|", "!") require("Module:debug/track")("labels/" .. page) if langcode then require("Module:debug/track")("labels/" .. page .. "/" .. langcode) end if mode then require("Module:debug/track")("labels/" .. page .. "/" .. mode) end -- We don't currently add a tracking label for both langcode and mode to reduce the total number of labels, to -- save some memory. return true end

local function ucfirst(txt) return mw.getContentLanguage:ucfirst(txt) end

local mode_to_outer_class = { ["label"] = "usage-label-sense", ["term-label"] = "usage-label-term", ["accent"] = "usage-label-accent", ["form-of"] = "usage-label-form-of", }

local mode_to_property_prefix = { ["label"] = false, ["term-label"] = false, -- handled specially ["accent"] = "accent_", ["form-of"] = "form_of_", }

local function validate_mode(mode) mode = mode or "label" if not mode_to_outer_class[mode] then local allowed_values = {} for key, _ in pairs(mode_to_outer_class) do table.insert(allowed_values, "'" .. key .. "'") end table.sort(allowed_values) error(("Invalid value '%s' for `mode`; should be one of %s"):format(mode, table.concat(allowed_values, ", "))) end return mode end

local function getprop(labdata, mode, prop) local mode_prefix = mode_to_property_prefix[mode] return mode_prefix and labdata[mode_prefix .. prop] or labdata[prop] end

-- HACK! For languages in any of the given families, check the specified-language Wikipedia for appropriate -- Wikipedia articles for the language in question (esp. useful for obscure etymology-only languages that may not -- have English articles for them, like many Chinese lects). local families_to_wikipedia_languages = { {"zhx", "zh"}, {"sem-arb", "ar"}, }

--[==[ Given language `lang` (a full language, etymology-language or family), fetch a list of Wikimedia languages to check when converting a Wikidata item to a Wikipedia article. English is always first, followed by the Wikimedia language code(s) of `lang` if `lang` is a language (which may or may not be the same as `lang`'s Wiktionary code), followed by the macrolanguage of `lang` for certain languages and families (currently, only languages and families in the Chinese and Arabic families). If `lang` is nil, only return English. Note that the same code may occur more than once in the list. This is exported because it's also used by Module:category tree/poscatboiler/data/language varieties. ]==] function export.get_langs_to_extract_wikipedia_articles_from_wikidata(lang) local wikipedia_langs = {} table.insert(wikipedia_langs, "en") if lang then local article_lang = lang while article_lang do			if article_lang:hasType("language") then local wmcodes = article_lang:getWikimediaLanguageCodes for _, wmcode in ipairs(wmcodes) do					table.insert(wikipedia_langs, wmcode) end end article_lang = article_lang:getParent end for _, family_to_wp_lang in ipairs(families_to_wikipedia_languages) do			local family, wp_lang = unpack(family_to_wp_lang) if lang:inFamily(family) then table.insert(wikipedia_langs, wp_lang) end end end return wikipedia_langs end

--[==[ Fetch the categories to add to a page, given that the label whose canonical form is `canon_label` with language `lang` has been seen. `labdata` is the label data structure for `label`, fetched from the appropriate submodule. `mode` specifies how the label was invoked (see {get_label_info} for more information). The return value is a list of the actual categories, unless `for_doc` is specified, in which case the categories returned are marked up for display on a documentation page. If `for_doc` is given, `lang` may be nil to format the categories in a language-independent fashion; otherwise, it must be specified. If `category_types` is specified, it should be a set object (i.e. with category types as keys and {true} as values), and only categories of the specified types will be returned. ]==] function export.fetch_categories(canon_label, labdata, lang, mode, for_doc, category_types) local categories = {}

mode = validate_mode(mode) local langcode, canonical_name if lang then langcode = lang:getFullCode canonical_name = lang:getFullName elseif for_doc then langcode = " [langcode] " canonical_name = " [language name] " else error("Internal error: Must specify `lang` unless `for_doc` is given") end

local function labprop(prop) return getprop(labdata, mode, prop) end local empty_list = {} local function get_cats(cat_type) if category_types and not category_types[cat_type] then return empty_list end local cats = labprop(cat_type) if not cats then return empty_list end if type(cats) ~= "table" then return {cats} end return cats end

local topical_categories = get_cats("topical_categories") local sense_categories = get_cats("sense_categories") local pos_categories = get_cats("pos_categories") local regional_categories = get_cats("regional_categories") local plain_categories = get_cats("plain_categories")

local function insert_cat(cat, sense_cat) if for_doc then cat = " " if sense_cat then if mode == "term-label" then cat = cat .. " (using tlb)" else cat = cat .. " (using lb or form-of template)" end cat = mw.getCurrentFrame:preprocess(cat) end end

table.insert(categories, cat) end

for _, cat in ipairs(topical_categories) do insert_cat(langcode .. ":" .. (cat == true and ucfirst(canon_label) or cat)) end

for _, cat in ipairs(sense_categories) do		if cat == true then cat = canon_label end cat = mode == "term-label" and cat .. " terms" or "terms with " .. cat .. " senses" insert_cat(canonical_name .. " " .. cat, true) end

for _, cat in ipairs(pos_categories) do insert_cat(canonical_name .. " " .. (cat == true and canon_label or cat)) end

for _, cat in ipairs(regional_categories) do insert_cat((cat == true and ucfirst(canon_label) or cat) .. " " .. canonical_name) end

for _, cat in ipairs(plain_categories) do		insert_cat(cat == true and ucfirst(canon_label) or cat) end

return categories end

--[==[ Return the list of all labels data modules for a label whose language is `lang`. The return value is a list of module names, with overriding modules earlier in the list (that is, if a label occurs in two modules in the list, the earlier-listed module takes precedence). If `lang` is nil, only return non-language-specific submodules. ]==] function export.get_submodules(lang) local submodules = {}

-- get language-specific labels from data module local langcode = lang and lang:getFullCode or nil

if langcode and m_lang_specific_data.langs_with_lang_specific_modules[langcode] then -- prefer per-language label in order to pick subvariety labels over regional ones table.insert(submodules, export.lang_specific_data_modules_prefix .. langcode) end table.insert(submodules, "Module:labels/data") table.insert(submodules, "Module:labels/data/qualifiers") table.insert(submodules, "Module:labels/data/regional") table.insert(submodules, "Module:labels/data/topical") return submodules end

--[==[ Return the formatted form of a label `label` (which should be the canonical form of the label; see comment at top), given (a) the label data structure `labdata` from one of the data modules; (b) the language object `lang` of the language being processed, or nil for no language; (c) `deprecated` (true if the label is deprecated, otherwise the deprecation information is taken from `labdata`); (d) `override_display` (if specified, override the display form of the label with the specified string, instead of any value in `labdata.display` or `labdata.special_display` or the canonical label in `label` itself); (e) `mode` (same as `data.mode` passed to {get_label_info}). Returns two values: the formatted label form and a boolean indicating whether the label is deprecated.

NOTE: Under normal circumstances, do not use this. Instead, use {get_label_info}, which searches all the data modules for a given label and handles other complications. ]==] function export.format_label(label, labdata, lang, deprecated, override_display, mode) local formatted_label

mode = validate_mode(mode) local function labprop(prop) return getprop(labdata, mode, prop) end deprecated = deprecated or labprop("deprecated") if not override_display and labprop("special_display") then local function add_language_name(str) if str == "canonical_name" then if lang then return lang:getFullName else return " " end else return "" end end

formatted_label = labprop("special_display"):gsub("<(.-)>", add_language_name) else --[=[			If labdata.glossary or labdata.Wikipedia are set to true, there is a glossary definition with an anchor identical to the label, or a Wikipedia article with a title identical to the label. For example, the code labels["formal"] = { glossary = true, }				indicates that there is a glossary entry for "formal".

Otherwise: * labdata.glossary specifies the anchor in Appendix:Glossary. * labdata.Wiktionary specifies an arbitrary Wiktionary page or page + anchor (e.g. a separate Appendix			 entry). * labdata.Wikipedia specifies an arbitrary Wikipedia article. * labdata.Wikidata specifies an arbitrary Wikidata item to retrieve a Wikipedia article from, or a list of such items (in this case, we select the first one, but other modules using this info might use all			 of them). If the item is of the form `wmcode:id`, the Wikipedia article corresponding to `wmcode` is fetched if available. Otherwise, the English-language Wikipedia article is retrieved if available, falling back to the Wikimedia language(s) corresponding to `lang` and then (in certain cases) to the macrolanguage that `lang` is part of.

Note that if `mode` is specified, prefixed properties (e.g. "accent_display" for `mode` == "accent",			"form_display" for `mode` == "form") are checked before the bare equivalent (e.g. "display"). ]=]		local display = override_display or labprop("display") or label

-- There are several 'Foo spelling' labels specially designed for use in the |from= param in --, and the like. Often the display includes the word -- "spelling" at the end (e.g. if it's defaulted), which is useful when the label is used with lb or		-- tlb; but it causes redundancy when used with the form-of templates, which add the word "form", -- "spelling", "standard spelling", etc. after the label. if mode == "form-of" then display = display:gsub(" spelling$", "") end

if display:find("%[%[") then formatted_label = display else local glossary = labprop("glossary") local Wiktionary = labprop("Wiktionary") local Wikipedia = labprop("Wikipedia") local Wikidata = labprop("Wikidata") if glossary then local glossary_entry = type(glossary) == "string" and glossary or label formatted_label = "" .. display .. "" elseif Wiktionary then formatted_label = "" .. display .. "" elseif Wikipedia then local Wikipedia_entry = type(Wikipedia) == "string" and Wikipedia or label formatted_label = "" .. display .. "" elseif Wikidata then if not mw.wikibase then error(("Unable to retrieve data from Wikidata ID for label '%s'; `mw.wikibase` not defined" ):format(label)) end local function make_formatted_label(wmcode, id) local article = mw.wikibase.sitelink(id, wmcode .. "wiki") if article then local link = wmcode == "en" and "w:" .. article or "w:" .. wmcode .. ":" .. article return ("%s"):format(link, display) else return nil end end if type(Wikidata) == "table" then Wikidata = Wikidata[1] end local wmcode, id = Wikidata:match("^(.*):(.*)$") if wmcode then formatted_label = make_formatted_label(wmcode, id) else local langs_to_check = export.get_langs_to_extract_wikipedia_articles_from_wikidata(lang) for _, wmcode in ipairs(langs_to_check) do						formatted_label = make_formatted_label(wmcode, Wikidata) if formatted_label then break end end end formatted_label = formatted_label or display else formatted_label = display end end end

if deprecated then formatted_label = ' ' .. formatted_label .. ' '	end

return formatted_label, deprecated end

--[==[ Return information on a label. On input `data` is an object with the following fields: ** {nil} or {"label"}: invoked through lb or another template whose labels in the same fashion, e.g.    alt, quote or syn; ** {"term-label"}: invoked through tlb; ** {"accent"}: invoked through a or the a or aa parameters of other pronunciation templates, such as IPA, rhymes or homophones; ** {"form-of"}: invoked through alt form, standard spelling of or other form-of template. This changes the display and/or categorization of a minority of labels. (The majority work the same for all modes.) `categories` to be formatted for documentation display. to the display form of the label, so if two labels have the same display form, the second one won't be displayed (but its categories will still be added). If `already_seen` is {nil}, this tracking doesn't happen.
 * `label`: The raw label to return information on.
 * `lang`: The language of the label. Must be specified unless `for_doc` is given.
 * `mode`: How the label was invoked. One of the following:
 * `for_doc`: Data is being fetched for documentation purposes. This causes the raw categories returned in
 * `nocat`: If true, don't add the label to any categories.
 * `notrack`: Disable all tracking for this label.
 * `already_seen`: An object used to track labels already seen, so they aren't displayed twice. Tracking is according

The return value is an object with the following fields: when double angle bracket (<<...>>) notation is used. {get_label_info} does not currently return objects with this field set, but {process_raw_labels} does. The value is {"begin"} (this is the first raw text portion derived from a double angle bracket spec, provided there are at least two raw text portions); {"end"} (this is the last raw text  portion derived from a double angle bracket spec, provided there are at least two portions); {"middle"} (this is  neither the first nor the last raw text portion); or {"only"} (this is a raw text portion standing by itself). The particular value determines the handling of commas and spaces on one or both sides of the raw text. If this field is specified, only the `label` field (containing the actual raw text) and the `category` field (containing an empty list) are set; all other fields are {nil}. but if the raw label was preceded by an exclamation point (meaning "display the raw label as-is"), this field will contain the label stripped of the exclamation point, and if the raw label is of the form ` label ! display ` (meaning "display the label in the specified form"), this field will contain the label before the exclamation point. will be {nil}. display form of a label is the `.display` field of the label data if present, and otherwise is normally the canonical form of the label (i.e. after alias resolution). (This is not the same as the formatted form of the label, found in `label`, which is the final form shown to the user and includes links to Wikipedia, the glossary, etc. as well as an  HTML wrapper if the label is deprecated.) If `override_display` is specified, however, this is used in place of the normal display form of the label. This currently happens in two circumstances: (1) the label was preceded by ! to indicate that the raw label should be displayed rather than the canonical form; (2) the label was given in the form ` label ! display ` (meaning "display the label in the specified ` display ` form"). (found in some module), this will typically be in the form of a link. or if `categories` is empty. Currently will be an empty string if there are categories to format but the namespace is one that normally excludes categories (e.g. userspace and discussion pages), and `force_cat` isn't specified. be an empty object. ]==] function export.get_label_info(data) if not data.label then error("`data` must now be an object containing the params") end
 * `raw_text`: If specified, the object does not describe a label but simply raw text surrounding labels. This occurs
 * `raw_label`: The raw label that was passed in.
 * `non_canonical`: The label prior to canonicalization (i.e. alias resolution). Usually this is the same as `raw_label`,
 * `canonical`: If the label in `non_canonical` is an alias, this contains the canonical name of the label; otherwise it
 * `override_display`: If specified, this contains a string that overrides the normal display form of the label. The
 * `label`: The formatted form of the label. This is what is actually shown to the user. If the label is recognized
 * `categories`: A list of the categories to add the label to; an empty list of `nocat` was specified.
 * `formatted_categories`: A string containing the formatted categories; {nil} if `nocat` or `for_doc` was specified,
 * `deprecated`: True if the label is deprecated.
 * `recognized`: If true, the label was found in some module.
 * `data`: The data structure for the label, as fetched from the label modules. For unrecognized labels, this will

local mode = validate_mode(data.mode) local ret = {categories = {}} local label = data.label local raw_label = label ret.raw_label = raw_label local override_display if label:find("^!") then label = label:gsub("^!", "") override_display = label elseif label:find("![^%s]") then label, override_display = label:match("^(.-)!([^%s].*)$") if not label then error(("Internal error: This Lua pattern should never fail to match for label '%s'"):format(raw_label)) end end local non_canonical = label ret.non_canonical = non_canonical local deprecated = false local labdata local submodule local data_langcode = data.lang and data.lang:getCode or nil

local submodules_to_check = export.get_submodules(data.lang) for _, submodule_to_check in ipairs(submodules_to_check) do		submodule = mw.loadData(submodule_to_check) local this_labdata = submodule[label] local resolved_label if type(this_labdata) == "string" then resolved_label = this_labdata this_labdata = submodule[this_labdata] if not this_labdata then error(("Internal error: Label alias '%s' points to '%s', which is undefined in module %s"):format( label, resolved_label, submodule_to_check)) end if type(this_labdata) == "string" then error(("Internal error: Label alias '%s' points to '%s', which is also an alias (of '%s') in module %s"):format( label, resolved_label, this_labdata, submodule_to_check)) end end if this_labdata then -- Make sure either there's no lang restriction, or we're processing lang-independent, or our language -- is among the listed languages. Otherwise, continue processing (which could conceivably pick up a			-- lang-appropriate version of the label in another label data module). local lablangs = getprop(this_labdata, mode, "langs") if not lablangs or not data_langcode then labdata = this_labdata label = resolved_label or label break end local lang_in_list = false for _, langcode in ipairs(lablangs) do				if langcode == data_langcode then lang_in_list = true break end end if lang_in_list then labdata = this_labdata label = resolved_label or label break elseif not data.notrack then -- Track use of a label that fails the lang restriction. -- Special:WhatLinksHere/Wiktionary:Tracking/labels/wrong-lang-label -- Special:WhatLinksHere/Wiktionary:Tracking/labels/wrong-lang-label/LANGCODE -- Special:WhatLinksHere/Wiktionary:Tracking/labels/wrong-lang-label/LABEL -- Special:WhatLinksHere/Wiktionary:Tracking/labels/wrong-lang-label/LABEL/LANGCODE track("wrong-lang-label", data_langcode) track("wrong-lang-label/" .. label, data_langcode) if resolved_label then track("wrong-lang-label/" .. resolved_label, data_langcode) end end end end if labdata then ret.recognized = true else labdata = {} ret.recognized = false end

local function labprop(prop) return getprop(labdata, mode, prop) end if labprop("deprecated") then deprecated = true end if label ~= non_canonical then -- Note that this is an alias and store the canonical version. ret.canonical = label end

if not data.notrack then -- labprop("track") then -- track all labels now -- Track label (after converting aliases to canonical form; but also track raw label (alias) if different		-- from canonical label). -- Special:WhatLinksHere/Wiktionary:Tracking/labels/label/LABEL -- Special:WhatLinksHere/Wiktionary:Tracking/labels/label/LABEL/LANGCODE -- Special:WhatLinksHere/Wiktionary:Tracking/labels/label/LABEL/MODE track("label/" .. label, data_langcode, mode) if label ~= non_canonical then track("label/" .. non_canonical, data_langcode, mode) end end

local formatted_label formatted_label, deprecated = export.format_label(label, labdata, data.lang, deprecated, override_display, mode) ret.deprecated = deprecated if deprecated then if not data.nocat then local depcat = "Entries with deprecated labels" if data.for_doc then depcat = " " end table.insert(ret.categories, depcat) end end

local label_for_already_seen = (labprop("topical_categories") or labprop("regional_categories")		or labprop("plain_categories") or labprop("pos_categories")		or labprop("sense_categories")) and formatted_label or nil

-- Track label text. If label text was previously used, don't show it, but include the categories. -- For an example, see hypocretin. if data.already_seen and data.already_seen[label_for_already_seen] then ret.label = "" else if formatted_label:find("{") then formatted_label = mw.getCurrentFrame:preprocess(formatted_label) end ret.label = formatted_label end

if data.nocat then -- do nothing else local cats = export.fetch_categories(label, labdata, data.lang, mode, data.for_doc) for _, cat in ipairs(cats) do			table.insert(ret.categories, cat) end if not ret.categories[1] or data.for_doc then -- Don't try to format categories if we're doing this for documentation, because there -- will be HTML in the categories. -- do nothing else ret.formatted_categories = require(utilities_module).format_categories(ret.categories, data.lang,				data.sort, nil, force_cat) end end

ret.data = labdata

if label_for_already_seen and data.already_seen then data.already_seen[label_for_already_seen] = true end

return ret end

--[==[ Split a string containing comma-separated raw labels into the individual labels. This will not split on a comma followed by whitespace, and it will not split inside of matched <...> or [...]. The code is written to be efficient, so that it does not load modules (e.g. Module:parse utilities) unnecessarily. ]==] function export.split_labels_on_comma(term) if term:find("[%[<]") then -- Do it the "hard way". We don't want to split anything inside of <...> or <<...>> even if there are commas -- inside of the angle brackets. For good measure we do the same for [...] and .... We first parse balanced -- segment runs involving either [...] or <...>. Then we split alternating runs on comma (but not on		-- comma+whitespace). Then we rejoin the split runs. For example, given the following: -- "regional,older <> speakers", the first call to		-- parse_multi_delimiter_balanced_segment_run produces --		-- {"regional,older ", "<>", " speakers"} --		-- After calling split_alternating_runs_on_comma, we get the following: --		-- {{"regional"}, {"older ", "<>", " speakers"}} --		-- After rejoining each group, we get: --		-- {"regional", "older <> speakers"} --		-- which is the desired output. When processing the second "label" string, the code in process_raw_labels -- will do a similar process to this to pull out the labels inside of the <<...>> notation. local put = require(parse_utilities_module) local segments = put.parse_multi_delimiter_balanced_segment_run(term, {{"<", ">"}, {"[", "]"}}) -- This won't split on comma+whitespace. local comma_separated_groups = put.split_alternating_runs_on_comma(segments) for i, group in ipairs(comma_separated_groups) do			comma_separated_groups[i] = table.concat(group) end return comma_separated_groups elseif term:find(",%s") then -- This won't split on comma+whitespace. return require(parse_utilities_module).split_on_comma(term) elseif term:find(",") then return require(string_utilities_module).split(term, ",") else return {term} end end

--[==[ Return a list of objects corresponding to a set of raw labels. Each object returned is of the format returned by {get_label_info}. This is similar to looping over the labels and calling {get_label_info} on each one, but it also correctly handles embedded double angle bracket specs <<...>> found in the labels. (In such a case, there will be more objects returned than raw labels passed in.) On input, `data` is an object with the following fields: to the display form of the label, so if two labels have the same display form, the second one won't be displayed (but its categories will still be added). If `already_seen` is {nil}, this tracking doesn't happen.
 * `labels`: The list of labels to process.
 * `lang`: The language of the labels. Must be specified.
 * `mode`: How the label was invoked; see {get_label_info} for more information.
 * `nocat`: If true, don't add the label to any categories.
 * `notrack`: Disable all tracking for this label.
 * `sort`: Sort key for categorization.
 * `already_seen`: An object used to track labels already seen, so they aren't displayed twice. Tracking is according

WARNING: This destructively modifies the `data` structure. ]==] function export.process_raw_labels(data) local label_infos = {}

local function get_info_and_insert(label) -- Reuse this structure to save memory. data.label = label table.insert(label_infos, export.get_label_info(data)) end

for _, label in ipairs(data.labels) do		if label:find("<<") then local segments = require(string_utilities_module).split(label, "<<(.-)>>") for i, segment in ipairs(segments) do				if i % 2 == 1 then local raw_text_type = i == 1 and "begin" or i == #segments and "end" or "middle" table.insert(label_infos, {raw_text = raw_text_type, label = segment, categories = {}}) else local segment_labels = export.split_labels_on_comma(segment) for _, segment_label in ipairs(segment_labels) do						get_info_and_insert(segment_label) end end end else get_info_and_insert(label) end end

return label_infos end

--[==[ Split a comma-separated string of raw labels and process each label to get a list of objects suitable for passing to {format_processed_labels}. Each object returned is of the format returned by {get_label_info}. This is equivalent to calling {split_labels_on_comma} followed by {process_raw_labels}. On input, `data` is an object with the following fields: to the display form of the label, so if two labels have the same display form, the second one won't be displayed (but its categories will still be added). If `already_seen` is {nil}, this tracking doesn't happen.
 * `labels`: The string containing the raw comma-separated labels.
 * `lang`: The language of the labels. Must be specified.
 * `mode`: How the label was invoked; see {get_label_info} for more information.
 * `nocat`: If true, don't add the label to any categories.
 * `notrack`: Disable all tracking for this label.
 * `sort`: Sort key for categorization.
 * `already_seen`: An object used to track labels already seen, so they aren't displayed twice. Tracking is according

WARNING: This destructively modifies the `data` structure. ]==] function export.split_and_process_raw_labels(data) data.labels = export.split_labels_on_comma(data.labels) return export.process_raw_labels(data) end

--[==[ Format one or more already-processed labels for display and categorization. "Already-processed" means that {get_label_info} or {process_raw_labels} has been called on the raw labels to convert them into objects containing information on how to display and categorize the labels. This is a lower-level alternative to {show_labels} and is meant for modules such as Module:alternative forms, Module:quote and Module:etymology/templates/descendant that support displaying labels along with some other information.

On input `data` is an object with the following fields: {get_label_info}. To enable this, set this to an empty object. If `already_seen` is {nil}, this tracking doesn't happen, meaning if the same label appears twice, it will be displayed twice. {"ib-brac"} CSS class. If {nil}, no open bracket is displayed. {"ib-brac"} CSS class. If {nil}, no close bracket is displayed. {"ib-content"} CSS class. Specify this to suppress this wrapping.
 * `labels`: List of the label objects to format, in the format returned by {get_label_info}.
 * `lang`: The language of the labels.
 * `mode`: How the label was invoked; see {get_label_info} for more information.
 * `sort`: Sort key for categorization.
 * `already_seen`: An object used to track labels already seen, so they aren't displayed twice, as documented in
 * `open`: Open bracket or parenthesis to display before the concatenated labels. If specified, it is wrapped in the
 * `close`: Close bracket or parenthesis to display after the concatenated labels. If specified, it is wrapped in the
 * `no_ib_content`: By default, the concatenated formatted labels inside of the open/close brackets are wrapped in the

Return value is a string containing the contenated labels, optionally surrounded by open/close brackets or parentheses. Normally, labels are separated by comma-space sequences, but this may be suppressed for certain labels. If `nocat` wasn't given to {get_label_info or process_raw_labels}, the label objects will contain formatted categories in them, which will be inserted into the returned text. The concatenated text inside of the open/close brackets is normally wrapped in the {"ib-content"} CSS class, but this can be suppressed, as mentioned above.

WARNING: This destructively modifies the `data` structure. ]==] function export.format_processed_labels(data) if not data.labels then error("`data` must now be an object containing the params") end local labels = data.labels if not labels[1] then error("You must specify at least one label.") end

-- Show the labels local omit_preComma = false local omit_postComma = true local omit_preSpace = false local omit_postSpace = true

for _, label in ipairs(labels) do		omit_preComma = omit_postComma omit_preSpace = omit_postSpace

local raw_text_omit_before = label.raw_text == "middle" or label.raw_text == "end" local raw_text_omit_after = label.raw_text == "middle" or label.raw_text == "begin" label.omit_comma = omit_preComma or (label.data and label.data.omit_preComma) or raw_text_omit_before omit_postComma = (label.data and label.data.omit_postComma) or raw_text_omit_after label.omit_space = omit_preSpace or (label.data and label.data.omit_preSpace) or raw_text_omit_before omit_postSpace = (label.data and label.data.omit_postSpace) or raw_text_omit_after end

if data.lang then local lang_functions_module = export.lang_specific_data_modules_prefix .. data.lang:getCode .. "/functions" local m_lang_functions = require(utilities_module).safe_require(lang_functions_module) if m_lang_functions and m_lang_functions.postprocess_handlers then for _, handler in ipairs(m_lang_functions.postprocess_handlers) do				handler(data) end end end

for i, labelinfo in ipairs(labels) do		local label -- Need to check for 'not raw_text' here because blank labels may legitimately occur as raw text if a double -- angle bracket spec occurs at the beginning of a label. In this case we've already taken into account the -- context and don't want to leave out a preceding comma and space e.g. in a case like -- . FIXME: We should reconsider whether we need this special case -- at all. if labelinfo.label == "" and not labelinfo.raw_text then label = "" else label = (labelinfo.omit_comma and "" or ', ') .. (labelinfo.omit_space and "" or " ") .. labelinfo.label end labels[i] = label .. (labelinfo.formatted_categories or "") end

local function wrap_open_close(val) if val then return "" .. val .. " "		else return "" end end

local concatenated_labels = table.concat(labels, "") if not data.no_ib_content then concatenated_labels = "" .. concatenated_labels .. " "	end

return wrap_open_close(data.open) .. concatenated_labels .. wrap_open_close(data.close) end

--[==[ Format one or more labels for display and categorization. This provides the implementation of the label/lb, term label/tlb and accent/a templates, and can also be called from a module. The return value is a string to be inserted into the generated page, including the display and categories. On input `data` is an object with the following fields: again, but still categorize. See the documentation of {get_label_info}. parenthesis. Set to {false} to disable. parenthesis. Set to {false} to disable.
 * `labels`: List of the labels to format.
 * `lang`: The language of the labels.
 * `mode`: How the label was invoked; see {get_label_info} for more information.
 * `nocat`: If true, don't add the labels to any categories.
 * `notrack`: Disable all tracking for these labels.
 * `sort`: Sort key for categorization.
 * `no_track_already_seen`: Don't track already-seen labels. If not specified, already-seen labels are not displayed
 * `open`: Open bracket or parenthesis to display before the concatenated labels. If {nil}, defaults to an open
 * `close`: Close bracket or parenthesis to display after the concatenated labels. If {nil}, defaults to a close

Compared with {format_processed_labels}, this function has the following differences: `mode`).
 * 1) The labels specified in `labels` are raw labels (i.e. strings) rather than formatted objects.
 * 2) The open and close brackets default to parentheses ("round brackets") rather than not being displayed by default.
 * 3) Tracking of already-seen labels is enabled unless explicitly turned off using `no_track_already_seen`.
 * 4) The entire formatted result is wrapped in a {"usage-label- type "} CSS class (depending on the value of

WARNING: This destructively modifies the `data` structure. ]==] function export.show_labels(data) if not data.labels then error("`data` must now be an object containing the params") end local labels = data.labels if not labels[1] then error("You must specify at least one label.") end

local mode = validate_mode(data.mode)

if not data.no_track_already_seen then data.already_seen = {} end

data.labels = export.process_raw_labels(data) if data.open == nil then data.open = "("	end	if data.close == nil then		data.close = ")" end local formatted = export.format_processed_labels(data) return "" .. formatted .. " " end

--[==[Helper function for the data modules.]==] function export.alias(labels, key, aliases) require(table_module).alias(labels, key, aliases) end

--[==[ Split the display form of a label. Returns two values: `link` and `display`. If the display form consists of a two-part link, `link` is the first part and `display` is the second part. If the display form consists of a single-part link, `link` and `display` are the same. Otherwise (the display form is not a link or contains an embedded link), `link` is the same as the passed-in `label` and `display` is nil. ]==] function export.split_display_form(label) if not label:find("%[%[") then return label, nil end local link, display = label:match("^%[%[([^%[%]|]+)|([^%[%]|]+)%]%]$") if link then return link, display end local link = label:match("^%[%[([^%[%]|])+%]%]$") if link then return link, link end return label, nil end

--[==[ Combine the `link` and `display` parts of the display form of a label as returned by {split_display_form}. If `display` is nil, `link` is returned directly. Otherwise, a one-part or two-part link is constructed depending on whether `link` and `display` are the same. (As a special case, if both consist of a blank string, the return value is a blank string rather than a malformed link.) ]==] function export.combine_display_form_parts(link, display) if not display then return link end if link == display then if link == "" then return "" else return ("%s"):format(link) end end return ("%s"):format(link, display) end

--[==[Used to finalize the data into the form that is actually returned.]==] function export.finalize_data(labels) local shallowcopy = require(table_module).shallowcopy local aliases = {} for label, data in pairs(labels) do		if type(data) == "table" then if data.aliases then for _, alias in ipairs(data.aliases) do					aliases[alias] = label end data.aliases = nil end if data.deprecated_aliases then local data2 = shallowcopy(data) data2.deprecated = true data2.canonical = label for _, alias in ipairs(data2.deprecated_aliases) do					aliases[alias] = data2 end data.deprecated_aliases = nil data2.deprecated_aliases = nil end end end for label, data in pairs(aliases) do		labels[label] = data end return labels end

return export

title: Module:labels


text:
ontoereikend

Etymology
.

Adjective

 * Mijn Frans is ontoereikend om "De graaf van Monte-Cristo" te lezen.
 * My French is inadequate for reading of "The Count of Monte Cristo".
 * My French is inadequate for reading of "The Count of Monte Cristo".

title: ontoereikend


text:
Citations:whitesplainer

Noun: "one who whitesplains"

 * 2015, Lorena Ornelas, "Whitesplaining", Kaleidoscope (Loyola University), page 47:
 * Ironically, the whitesplainer offends the very people who they are trying to “help.”
 * 2015, Lorena Ornelas, "Whitesplaining", Kaleidoscope (Loyola University), page 47:
 * Ironically, the whitesplainer offends the very people who they are trying to “help.”

title: Citations:whitesplainer


text:
гороскоп

Noun

 * 1) horoscope astrological forecast

Noun

 * 1) horoscope astrological forecast

title: гороскоп


text: Category:German terms derived from Upper Sorbian


text:
cartão vermelho

Noun

 * 1)  red card

title: cartão vermelho


text:
cartão amarelo

Noun

 * 1)  yellow card

title: cartão amarelo


text:
tetracampeão

Etymology
From.

Noun

 * 1) four-time champion

title: tetracampeão


text:
Maracanã

Etymology
From.

Proper noun

 * , named after the river
 * 1) a stadium located in this neighbourhood
 * 1) a stadium located in this neighbourhood

title: Maracanã


text:
vivência

Noun

 * 1) experience

title: vivência


text:
Talk:quarl

Etymological comment
The extraneous 'r', which was probably not pronounced when the word was borrowed (see ), is similar to the one in (from 🇨🇬). - -sche (discuss) 00:13, 1 July 2013 (UTC)

title: Talk:quarl


text:
artilheiro

Noun

 * 1) artilleryman
 * 2)  top scorer

title: artilheiro


text: ñiciaron

title: ñiciaron


text: ñiciara

title: ñiciara


text: ñiciare

title: ñiciare


text: ñiciares

title: ñiciares


text: ñiciaras

title: ñiciaras


text: ñiciáramos

title: ñiciáramos


text: ñiciáremos

title: ñiciáremos


text: ñiciareis

title: ñiciareis


text: ñiciarais

title: ñiciarais


text: ñiciaran

title: ñiciaran


text: ñiciaren

title: ñiciaren