local export = {}
local u = mw.ustring.char
local rsplit = mw.text.split
local rfind = mw.ustring.find
local rmatch = mw.ustring.match
local rsubn = mw.ustring.gsub
local ulen = mw.ustring.len
local ulower = mw.ustring.lower
local uupper = mw.ustring.upper
local usub = mw.ustring.sub
-- version of rsubn() that discards all but the first return value
local function rsub(term, foo, bar)
local retval = rsubn(term, foo, bar)
return retval
end
-- apply rsub() repeatedly until no change
local function rsub_repeatedly(term, foo, bar)
while true do
local new_term = rsub(term, foo, bar)
if new_term == term then
return term
end
term = new_term
end
end
local AC = u(0x0301) -- acute = ́
local GR = u(0x0300) -- acute = ̀
local CFLEX = u(0x0302) -- circumflex = ̂
local DOTBELOW = u(0x0323) -- dot below = ̣
export.accents = AC .. CFLEX .. DOTBELOW
export.accents_c = "[" .. export.accents .. "]"
export.vowel = "аеіоуяэыёюАЕІОУЯЭЫЁЮ"
export.vowel_c = "[" .. export.vowel .. "]"
export.non_vowel_c = "[^" .. export.vowel .. "]"
export.velar = "кгґхКГҐХ"
export.velar_c = "[" .. export.velar .. "]"
export.always_hard = "ршчжРШЧЖ"
export.always_hard_c = "[" .. export.always_hard .. "]"
export.always_hard_or_ts = export.always_hard .. "цЦ"
export.always_hard_or_ts_c = "[" .. export.always_hard_or_ts .. "]"
export.cons_except_always_hard_or_ts = "бдфгґйклмнпствхзўьБДФГҐЙКЛМНПСТВХЗЎЬ'"
export.cons_except_always_hard_or_ts_c = "[" .. export.cons_except_always_hard_or_ts .. "]"
export.cons = export.always_hard .. export.cons_except_always_hard_or_ts .. "цЦ"
export.cons_c = "[" .. export.cons .. "]"
export.VAR1 = u(0xFFF0)
export.VAR2 = u(0xFFF1)
export.VAR3 = u(0xFFF2)
export.var_code_c = "[" .. export.VAR1 .. export.VAR2 .. export.VAR3 .. "]"
local grave_deaccenter = {
[GR] = "", -- grave accent
["ѐ"] = "е", -- composed Cyrillic chars w/grave accent
["Ѐ"] = "Е",
["ѝ"] = "и",
["Ѝ"] = "И",
}
local deaccenter = mw.clone(grave_deaccenter)
deaccenter[AC] = "" -- acute accent
local destresser = mw.clone(deaccenter)
destresser["ё"] = "е"
destresser["Ё"] = "Е"
destresser["о"] = "а"
destresser["О"] = "А"
destresser["э"] = "а"
destresser["Э"] = "А"
local pre_tonic_destresser = mw.clone(destresser)
pre_tonic_destresser["ё"] = "я"
pre_tonic_destresser["Ё"] = "Я"
pre_tonic_destresser["е"] = "я"
pre_tonic_destresser["Е"] = "Я"
local ae_stresser = {
["а"] = "э",
["я"] = "е",
}
local ao_stresser = {
["а"] = "о",
["я"] = "ё",
}
local first_palatalization = {
["к"] = "ч",
["г"] = "ж",
["ґ"] = "ж",
["х"] = "ш",
["ц"] = "ч",
}
local second_palatalization = {
["к"] = "ц",
["г"] = "з",
["ґ"] = "з",
["х"] = "с",
}
function export.get_variants(form)
return
form:find(export.VAR1) and "var1" or
form:find(export.VAR2) and "var2" or
form:find(export.VAR3) and "var3" or
nil
end
function export.remove_variant_codes(word)
return rsub(word, export.var_code_c, "")
end
-- Remove acute and grave accents; don't affect ёЁ.
function export.remove_accents(word)
return rsub(word, "[́̀ѐЀѝЍ]", deaccenter)
end
function export.needs_accents(text)
for _, word in ipairs(rsplit(text, "%s+")) do
-- A word needs accents if it contains no accent or ё and has more than one vowel
if not export.is_stressed(word) and not export.is_monosyllabic(word) then
return true
end
end
return false
end
function export.is_stressed(word)
return rfind(word, "[́ёЁ]")
end
-- Return whether the word has an acute accent. Use this in preference to is_stressed()
-- once mark_stressed_vowels_in_unstressed_syllables() has been called, because
-- is_accented() will correctly ignore ё/Ё in unstressed syllables (those in stressed
-- syllables are marked with an acute accent).
function export.is_accented(word)
return rfind(word, AC)
end
function export.is_initial_stressed(word)
return rfind(word, "^" .. export.non_vowel_c .. "*" .. export.vowel_c .. AC) or
not rfind(word, AC) and rfind(word, "^" .. export.non_vowel_c .. "*[ёЁ]")
end
function export.is_final_stressed(word)
return rfind(word, AC .. export.non_vowel_c .. "*$") or
not rfind(word, AC) and rfind(word, "[ёЁ]" .. export.non_vowel_c .. "*$")
end
-- Check if word ends in a vowel.
function export.ends_in_vowel(word)
return rfind(word, export.vowel_c .. export.accents_c .. "*$")
end
-- Check if word ends in a velar.
function export.ends_in_velar(word)
return rfind(word, export.velar_c .. "$")
end
-- Check if word ends in an always-hard consonant.
function export.ends_always_hard(word)
return rfind(word, export.always_hard_c .. "$")
end
-- Check if word ends in an always-hard consonant or ц.
function export.ends_always_hard_or_ts(word)
return rfind(word, export.always_hard_or_ts_c .. "$")
end
--[=[
HANDLING BELARUSIAN VOWEL ALTERNATIONS:
We proceed as follows:
1. Call mark_stressed_vowels_in_unstressed_syllables() to attach a stress mark
(acute accent) to monosyllabic vowels and to stressed ё vowels, and attach
a special signal (DOTBELOW) to vowels that are in positions they should not be
(о э ё in unstressed syllables, е directly before the stress), so that they
are never converted to their destressed equivalent.
2. Attempt to reconstruct, as much as possible, the underlying vowels of the word.
This is normally done using apply_vowel_alternation().
3. Move the stress mark elsewhere in the word (e.g. by removing the stress mark and
appending a stressed suffix).
4. Call destress_vowels_after_stress_movement() to convert the word to its final
form. This turns о э ё in unstressed syllables and е directly before the stress
into other vowels, taking care not to do this if DOTBELOW follows the vowel.
After that, it undoes the changes made in mark_stressed_vowels_in_unstressed_syllables().
]=]
-- Apply one or more vowel alternant specifications ("ao"/"ao2"/"ao3", "ae"/"ae2"/"ae3",
-- "avo"/"avo2"/"avo3", "yo"/"yo2"/"yo3", "oy" or "voa") to the given word.
function export.apply_vowel_alternation(word, vowel_alternants)
if not vowel_alternants then
return word
end
for _, valt in ipairs(vowel_alternants) do
if rfind(valt, "^av?[eo][23]?$") or rfind(valt, "^yo[23]?$") then
local re, errmsg
if rfind(valt, "[^23]$") then
re = export.non_vowel_c .. "*" .. export.vowel_c .. AC
errmsg = "directly before the stress"
elseif rfind(valt, "2$") then
re = export.non_vowel_c .. "*" .. export.vowel_c .. export.non_vowel_c .. "*" .. export.vowel_c .. AC
errmsg = "two syllables before the stress"
elseif rfind(valt, "3$") then
re = export.non_vowel_c .. "*" .. export.vowel_c .. export.non_vowel_c .. "*" .. export.vowel_c .. export.non_vowel_c .. "*" .. export.vowel_c
errmsg = "three syllables before the stress"
else
error("Unrecognized vowel alternant '" .. valt .. "'")
end
local new_word, req_vowel
if rfind(valt, "^a[eo]") then
new_word = rsub(word, "([аАяЯ])(" .. re .. ")",
function(a_vowel, rest)
local stresser = rfind(valt, "^ao") and ao_stresser or ae_stresser
return stresser[a_vowel] .. rest
end
)
req_vowel = "а or я"
elseif rfind(valt, "^avo") then
new_word = rsub(word, "([аА])(" .. re .. ")",
function(a_vowel, rest)
return (a_vowel == "а" and "в" or "В") .. CFLEX .. "о" .. rest
end
)
req_vowel = "а"
elseif rfind(valt, "^yo") then
new_word = rsub(word, "([ыЫ])(" .. re .. ")",
function(y_vowel, rest)
return (y_vowel == "ы" and "о" or "О") .. CFLEX .. rest
end
)
req_vowel = "ы"
else
error("Unrecognized vowel alternant '" .. valt .. "'")
end
if new_word == word then
error("Indicator '" .. valt .. "' can't be applied because word '" .. word .. "' doesn't have an " .. req_vowel .. " " .. errmsg)
end
word = new_word
elseif valt == "oy" then
local new_word = rsub(word, "([оО]́)", "%1" .. CFLEX)
if new_word == word then
error("Indicator 'oy' can't be applied because word '" .. word .. "' doesn't have a stressed о")
end
word = new_word
elseif valt == "voa" then
local new_word = rsub(word, "([вВ])о́", "%1" .. CFLEX .. "о́")
if new_word == word then
error("Indicator 'voa' can't be applied because word '" .. word .. "' doesn't have a stressed во")
end
word = new_word
else
error("Unrecognized vowel alternant '" .. valt .. "'")
end
end
return word
end
-- Mark vowels that should only occur in stressed syllables (э, о, ё) but
-- actually occur in unstressed syllables with a dot-below. Also mark е
-- that occurs directly before the stress in this fashion, and add an acute
-- accent to stressed ё. We determine whether an ё is stressed as follows:
-- (1) If an acute accent already occurs, an ё isn't marked with an acute
-- accent (e.g. ра́дыё).
-- (2) Otherwise, mark only the last ё with an acute, as multiple ё sounds
-- can occur (at least, in Russian this is the case, as in трёхколёсный).
function export.mark_stressed_vowels_in_unstressed_syllables(word)
if export.is_nonsyllabic(word) then
return word
end
if export.is_multi_stressed(word) then
error("Word " .. word .. " has multiple accent marks")
end
if export.has_grave_accents(word) then
error("Word " .. word .. " has grave accents")
end
word = export.add_monosyllabic_accent(word)
if not rfind(word, AC) then
if rfind(word, "[ёЁ]") then
word = rsub(word, "([ёЁ])(.-)$", "%1" .. AC .. "%2")
else
error("Multisyllabic word " .. word .. "missing an accent")
end
end
word = rsub(word, "([эоёЭОЁ])([^́])", "%1" .. DOTBELOW .. "%2")
word = rsub(word, "([эоёЭОЁ])$", "%1" .. DOTBELOW)
word = rsub(word, "([еЕ])(" .. export.non_vowel_c .. "*" .. export.vowel_c .. AC .. ")",
"%1" .. DOTBELOW .. "%2")
return word
end
-- Undo extra diacritics added by `mark_stressed_vowels_in_unstressed_syllables` or
-- otherwise (e.g. CFLEX).
function export.undo_mark_stressed_vowels_in_unstressed_syllables(word)
word = rsub(word, DOTBELOW, "")
word = rsub(word, CFLEX, "")
word = rsub(word, "([ёЁ])́", "%1")
return word
end
-- Destress vowels in unstressed syllables. Vowels followed by DOTBELOW are unchanged;
-- otherwise, о -> а; э -> а; ё -> я directly before the stress or when followed by
-- CFLEX, otherwise е; е -> я directly before the stress. After that, remove extra
-- diacritics added by mark_stressed_vowels_in_unstressed_syllables().
function export.destress_vowels_after_stress_movement(word)
-- Handle ё + CFLEX. This assumes that a stress mark comes between ё and CFLEX,
-- which will normally be the case if maybe_accent_initial_syllable() or
-- maybe_accent_final_syllable() is used to add stress. We remove the CFLEX after
-- destressing the syllable; a CFLEX after a stressed syllable will get removed by
-- undo_mark_stressed_vowels_in_unstressed_syllables().
word = rsub(word, "([ёЁ])" .. CFLEX, pre_tonic_destresser)
-- Handle о + CFLEX; same idea as above.
word = rsub(word, "([оО])" .. CFLEX, function(o_vowel) return o_vowel == "о" and "ы" or "Ы" end)
word = rsub_repeatedly(word, "([эоёЭОЁ])([^" .. AC .. DOTBELOW .. "])",
function(vowel, rest)
return destresser[vowel] .. rest
end
)
word = rsub(word, "([эоёЭОЁ])$", destresser)
word = rsub(word, "([еЕ])(" .. export.non_vowel_c .. "*" .. export.vowel_c .. AC .. ")",
function(vowel, rest)
if not rfind(rest, "^" .. DOTBELOW) then
return pre_tonic_destresser[vowel] .. rest
else
return vowel .. rest
end
end)
-- Handle в + CFLEX + non-о, which loses the в. Do this after converting unstressed о to а.
word = rsub_repeatedly(word, "([вВ])" .. CFLEX .. "([^оО])", "%2")
return export.undo_mark_stressed_vowels_in_unstressed_syllables(word)
end
-- If word is lacking an accent, add it onto the initial syllable.
-- This assumes the word has been processed by mark_stressed_vowels_in_unstressed_syllables(),
-- so that even the ё vowel gets stress.
function export.maybe_accent_initial_syllable(word)
if not rfind(word, AC) then
-- accent first syllable
word = rsub(word, "^(.-" .. export.vowel_c .. ")", "%1" .. AC)
end
return word
end
-- If word is lacking an accent, add it onto the final syllable.
-- This assumes the word has been processed by mark_stressed_vowels_in_unstressed_syllables(),
-- so that even the ё vowel gets stress.
function export.maybe_accent_final_syllable(word)
if not rfind(word, AC) then
-- accent last syllable
word = rsub(word, "(.*" .. export.vowel_c .. ")", "%1" .. AC)
end
return word
end
-- Make a word unstressed, appropriately handling akanye and yakanye on the
-- stressed syllable. PRE_TONIC indicates whether ё should be converted to я
-- (PRE_TONIC is true) or е (otherwise). This has no effect on unstressed
-- syllables, although in some cases they need to change (in particular,
-- я in the pre-tonic syllabic might need to change to underlying е, and
-- other changes might be necessary if the stress is going to be moved onto
-- a different syllable of the word).
function export.make_unstressed(word, pre_tonic)
local destresser = pre_tonic and pre_tonic_destresser or destresser
-- ё may occur in unstressed syllables, e.g. ра́дыё "radio". э may occur in
-- unstressed syllables, e.g. тэлеві́зар "television". Possibly the same
-- with о. In this case, we don't want to modify the ё/э/о. But we do want to
-- modify stressed ё́/э́/о́ appropriately.
if rfind(word, AC) then
word = rsub(word, "([ёЁэЭоО])́", function(vowel)
return destresser[vowel]
end)
return rsub(word, AC, "")
end
return rsub(word, "[̀ёЁэЭоОѐЀѝЍ]", destresser)
end
function export.is_multi_stressed(text)
for _, word in ipairs(rsplit(text, "[%s%-]+")) do
if ulen(rsub(word, "[^́]", "")) > 1 then
return true
end
end
return false
end
-- Check if word is nonsyllabic.
function export.is_nonsyllabic(word)
return not rfind(word, export.vowel_c)
end
-- Check if word is monosyllabic (also includes words without vowels).
function export.is_monosyllabic(word)
local num_syl = ulen(rsub(word, export.non_vowel_c, ""))
return num_syl <= 1
end
-- Check if word has grave accents.
function export.has_grave_accents(word)
return rfind(word, "[̀ѐЀѝЍ]")
end
-- If word is monosyllabic, add an accent mark to the vowel. Don't affect ёЁ
-- unless `even_yo` is specified.
function export.add_monosyllabic_stress(word, even_yo)
if export.is_monosyllabic(word) and not rfind(word, "^%-") and not rfind(word, "%-$") and
not (even_yo and export.is_accented(word) or export.is_stressed(word)) then
word = rsub(word, "(" .. export.vowel_c .. ")", "%1" .. AC)
end
return word
end
-- If word is monosyllabic, add an accent mark to the vowel. Unlike
-- add_monosyllabic_stress(), even add an accent to ёЁ.
function export.add_monosyllabic_accent(word)
return export.add_monosyllabic_stress(word, "even yo")
end
-- If word is monosyllabic, remove accent marks from the vowel.
function export.remove_monosyllabic_accents(word)
if export.is_monosyllabic(word) and not rfind(word, "^%-") and not rfind(word, "%-$") then
return export.remove_accents(word)
end
return word
end
function export.iotate(stem)
stem = rsub(stem, "с[ктц]$", "шч")
stem = rsub(stem, "[ктц]$", "ч")
stem = rsub(stem, "[сх]$", "ш")
stem = rsub(stem, "[гґз]$", "ж")
stem = rsub(stem, "дз?$", "дж")
stem = rsub(stem, "([бўмпф])$", "%1л")
stem = rsub(stem, "в$", "ўл")
return stem
end
function export.apply_first_palatalization(word)
return rsub(word, "^(.*)([кгґхц])$",
function(prefix, lastchar) return prefix .. first_palatalization[lastchar] end
)
end
function export.apply_second_palatalization(word)
return rsub(word, "^(.*)([кгґх])$",
function(prefix, lastchar) return prefix .. second_palatalization[lastchar] end
)
end
function export.palatalize_td(stem)
stem = rsub(stem, "т$", "ц")
stem = rsub(stem, "д$", "дз")
return stem
end
function export.combine_stem_ending(stem, ending)
if stem == "?" then
return "?"
end
if export.is_accented(ending) then
stem = export.remove_accents(stem)
end
if rfind(ending, "^[яеіёюь]") then
stem = export.palatalize_td(stem)
end
return stem .. ending
end
function export.combine_stem_ending_into_external_form(stem, ending)
return export.destress_vowels_after_stress_movement(
export.combine_stem_ending(stem, ending)
)
end
-- Remove the vowel between the last two consonants of a stem.
-- Used especially in masculine and third-declension feminine nouns to
-- generate the stem that is used before endings beginning with a vowel.
-- This is based on the corresponding function in [[Module:ru-common]],
-- adapted for Belarusian phonology and orthography.
function export.reduce(stem)
local pre, letter, post = rmatch(stem, "^(.+)([оОёЁаАэЭеЕ])́?(" .. export.cons_c .. "+)$")
if not pre then
return nil
end
if rfind(letter, "[оОаАэЭ]") then
-- FIXME, what about when the accent is on the removed letter?
if rfind(post, "^[йЙ]$") then
-- FIXME, is this correct?
return nil
end
-- аўто́рак -> аўто́рк-, вы́нятак -> вы́нятк-, ло́жак -> ло́жк-
-- алжы́рац -> алжы́рц-
-- міні́стар -> міні́стр-
letter = ""
else
local is_upper = rfind(post, "%u")
if export.ends_in_vowel(pre) then
-- аўстралі́ец -> аўстралі́йц-
-- аўстры́ец -> аўстры́йц-
-- еўрапе́ец -> еўрапе́йц
letter = is_upper and "Й" or "й"
elseif rfind(post, "[йЙ]") then
if rfind(pre, "[вВ]$") then
-- салаве́й -> салаў-
letter = ""
elseif rfind(pre, "[uбБпПфФмМ]$") then
-- верабе́й -> вераб'-
letter = "'"
elseif is_upper then
letter = usub(pre, -1)
else
-- вуле́й -> вулл-
letter = ulower(usub(pre, -1))
end
post = ""
elseif rfind(post, export.velar_c .. "$") and rfind(pre, export.cons_except_always_hard_or_ts_c .. "$") or
rfind(post, "[^йЙ" .. export.velar .. "]$") and rfind(pre, "[лЛ]$") then
-- For the first part: князёк -> князьк-
-- For the second part: алёс -> альс-, відэ́лец -> відэ́льц-
-- Both at once: матылёк -> матыльк-
letter = is_upper and "Ь" or "ь"
else
-- пёс -> пс-
-- асёл -> асл-, бу́сел -> бу́сл-
-- бабёр -> бабр-, шва́гер -> шва́гр-
-- італья́нец -> італья́нц-
letter = ""
end
-- адзёр -> адр-
-- ірла́ндзец -> ірла́ндц-
pre = rsub(pre, "([Дд])[Зз]$", "%1")
-- кацёл -> катл-, ве́цер -> ве́тр-
pre = rsub(pre, "ц$", "т")
pre = rsub(pre, "Ц$", "Т")
end
-- ало́вак -> ало́ўк-, авёс -> аўс-, чо́вен -> чо́ўн-, ядло́вец -> ядло́ўц-
-- NOTE: любо́ў -> любв- but we need to handle this elsewhere as it also applies
-- to non-reduced nouns, e.g. во́страў -> во́страв-
pre = rsub(pre, "в$", "ў")
pre = rsub(pre, "В$", "Ў")
return pre .. letter .. post
end
-- Add an epenthetic vowel between the last two consonants of the stem.
-- Used especially in feminine and neuter nouns to generate the genitive
-- plural. `epenthetic_stress` is true if the inserted vowel should bear
-- the stress according to the accent pattern of the noun. This is based
-- on the corresponding function in [[Module:ru-common]], adapted for
-- Belarusian phonology and orthography.
function export.dereduce(stem, epenthetic_stress)
if epenthetic_stress then
stem = export.remove_accents(stem)
end
-- FIXME, any cases where we have to dereduce a sequence Cдз -> CVдз?
local pre, letter, post = rmatch(stem, "^(.*)(" .. export.cons_c .. ")(" .. export.cons_c .. ")$")
if not pre then
return nil
end
local epvowel
local is_upper = rfind(post, "%u")
if post == "'" then
-- сям'я́ "family" -> сяме́й
post = "й"
epvowel = "е"
elseif rfind(letter, "[ьйЬЙ]") then
-- аўстралі́йка "Australian woman" -> аўстралі́ек
letter = ""
if rfind(post, "[цЦ]") or not epenthetic_stress then
epvowel = "е"
else
epvowel = "ё"
end
elseif rfind(letter, export.cons_except_always_hard_or_ts_c) and rfind(post, export.velar_c) or rfind(letter, export.velar_c) then
if epenthetic_stress then
epvowel = "о"
else
epvowel = "а"
end
elseif rfind(post, "[цЦ]") then
if export.ends_always_hard(letter) then
if epenthetic_stress then
-- FIXME, is this right?
epvowel = "э"
else
epvowel = "а"
end
else
epvowel = "е"
end
elseif epenthetic_stress then
if export.ends_always_hard_or_ts(letter) then
epvowel = "о"
else
epvowel = "ё"
end
elseif export.ends_always_hard_or_ts(letter) then
epvowel = "а"
else
epvowel = "е"
end
if letter == "ў" then
letter = "в"
elseif letter == "Ў" then
letter = "В"
end
if rfind(epvowel, "[её]") then
if letter == "т" then
letter = "ц"
elseif letter == "Т" then
letter = "Ц"
elseif letter == "д" then
letter = "дз"
elseif letter == "Д" then
letter = is_upper and "ДЗ" or "Дз"
end
end
if is_upper then
epvowel = upper(epvowel)
end
if epenthetic_stress then
epvowel = epvowel .. AC
end
return pre .. letter .. epvowel .. post
end
-- Handles the alternation between initial і/у and й/ў.
function export.initial_alternation(word, previous)
if type(word) == "table" then
word, previous = word.args[1], word.args[2]
end
local prev_ends_in_vowel = export.ends_in_vowel(previous)
if rfind(word, "^[іІ][лр]" .. export.cons_c) and prev_ends_in_vowel then
if rfind(word, "^І") then
return rsub(word, "^І(.)", function(letter) return uupper(letter) end)
else
return rsub(word, "^і", "")
end
elseif rfind(word, "^[ЛРлр]" .. export.cons_c) and not prev_ends_in_vowel then
if rfind(word, "^[ЛР]") then
return "І" .. rsub(word, "^(.)", function(letter) return ulower(letter) end)
else
return "і" .. word
end
elseif rfind(word, "^[іІ]") or rfind(word, "^[йЙ]" .. export.non_vowel_c) then
if prev_ends_in_vowel then
return rsub(word, "^[іІ]", {["і"] = "й", ["І"] = "Й"})
else
return rsub(word, "^[йЙ]", {["й"] = "і", ["Й"] = "І"})
end
elseif rfind(word, "^[уУ]") or rfind(word, "^[ўЎ]" .. export.non_vowel_c) then
if prev_ends_in_vowel then
return rsub(word, "^[уУ]", {["у"] = "ў", ["У"] = "Ў"})
else
return rsub(word, "^[ўЎ]", {["ў"] = "у", ["Ў"] = "У"})
end
end
return word
end
function export.u_v_alternation_msg(frame)
local m_links = require("Module:links")
local lang = require("Module:languages").getByCode("be")
local params = {
[1] = {}
}
local parargs = frame:getParent().args
local args = require("Module:parameters").process(parargs, params)
local alternant = args[1] or mw.title.getCurrentTitle().text
local ualt, valt, ufirst
if rfind(alternant, "^[ўЎ]") then
valt = alternant
ualt = rsub(export.add_monosyllabic_stress(valt), "^([ўЎ])", {["ў"] = "у", ["Ў"] = "У"})
ufirst = false
else
ualt = alternant
valt = export.remove_monosyllabic_accents(rsub(ualt, "^([уУ])", {["у"] = "ў", ["У"] = "Ў"}))
ufirst = true
end
ualt = m_links.full_link({lang = lang, term = ualt}, "term") .. " (used after consonants or at the beginning of a clause)"
valt = m_links.full_link({lang = lang, term = valt}, "term") .. " (used after vowels)"
local first, second
if ufirst then
first, second = ualt, valt
else
first, second = valt, ualt
end
return "The forms " .. first .. " and " .. second .. " differ in pronunciation but are considered variants of the same word."
end
return export
