Module:hrx-pron

From Wiktionary, the free dictionary
Jump to navigation Jump to search

This module is not to be directly used. It is used by Template:hrx-pr, see there for usage.


--Adapted from [[Module:es-pronunc]] by [[User:Benwing2]]

--[==[
FIXME:
1. Add unstressed words.
2. Clean up the code.
3. <aai> = /ɔːɪ̯/
4. Intervocalic <d> = /ɾ/?
8. Assimilation of nasals before stops
]==]

local export = {}

local m_IPA = require("Module:IPA")
local m_table = require("Module:table")
local audio_module = "Module:audio"
local put_module = "Module:parse utilities"

local force_cat = false -- for testing

local lang = require("Module:languages").getByCode("hrx")

local u = mw.ustring.char
local rfind = mw.ustring.find
local rsubn = mw.ustring.gsub
local rmatch = mw.ustring.match
local rsplit = mw.text.split
local ulower = mw.ustring.lower
local uupper = mw.ustring.upper
local usub = mw.ustring.sub
local ulen = mw.ustring.len
local unfd = mw.ustring.toNFD
local unfc = mw.ustring.toNFC

local AC = u(0x0301) -- acute =  ́
local GR = u(0x0300) -- grave =  ̀
local CFLEX = u(0x0302) -- circumflex =  ̂
local DIA = u(0x0308) -- diaeresis =  ̈
local BREVE = u(0x0306) --breve

local SYLDIV = u(0xFFF0) -- used to represent a user-specific syllable divider (.) so we won't change it
local vowel = "aeəiouàáéíóőúɔɛäëïÄËÏAIOU" -- vowels
local V = "[" .. vowel .. "]" -- vowel class
local Vo = "[" .. vowel .. u(0xFFF1) .. u(0xFFF2) .. u(0xFFF3) .. u(0xFFF4) .. u(0xFFF5) .. u(0xFFF6) .. 
	u(0xFFF9) .. u(0xFFFA) .. u(0xFFFB) .. u(0xFFFC) .. u(0x0400) .. u(0x0401) .. u(0x0402) .. u(0x0403) .. "]" --the extra characters stand for the long vowels in the hyphenation function
local accent = AC .. GR .. CFLEX
local accent_c = "[" .. accent .. "]"
local stress = AC .. GR
local stress_c = "[" .. AC .. GR .. "]"
local ipa_stress = "ˈˌ"
local ipa_stress_c = "[" .. ipa_stress .. "]"
local sylsep = "%-." .. SYLDIV -- hyphen included for syllabifying from spelling
local sylsep_c = "[" .. sylsep .. "]"
local wordsep = "# "
local separator_not_wordsep = accent .. ipa_stress .. sylsep
local separator = separator_not_wordsep .. wordsep
local separator_c = "[" .. separator .. "]"
local C = "[^" .. vowel .. separator .. "]" -- consonant class
local C_OR_WORDSEP = "[^" .. vowel .. separator_not_wordsep .. "]" -- consonant class, or word separator

local unstressed_words = require("Module:table").listToSet({ 
	"ab", "de", 
})

-- 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

-- version of rsubn() that returns a 2nd argument boolean indicating whether
-- a substitution was made.
local function rsubb(term, foo, bar)
	local retval, nsubs = rsubn(term, foo, bar)
	return retval, nsubs > 0
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 function decompose(text, remove_gr)
	-- decompose everything but ä, ë, ï
	text = unfd(text)
	text = rsub(text, ".[" .. DIA .. BREVE .. "]", {
		["a" .. DIA] = "ä",
		["A" .. DIA] = "Ä",
		["e" .. DIA] = "ë",
		["E" .. DIA] = "Ë",
		["i" .. DIA] = "ï",
		["I" .. DIA] = "Ï",
		["u" .. BREVE] = "ŭ",
		["U" .. BREVE] = "Ŭ",
		["i" .. BREVE] = "ĭ",
		["I" .. BREVE] = "Ĭ",
	})
	if remove_gr then
		text = rsub(text, "a" .. GR, "ä")
		text = rsub(text, "ĭ", "i")
		text = rsub(text, "ŭ", "u")
	end
	return text
end


local function split_on_comma(term)
	if term:find(",%s") then
		return require(put_module).split_on_comma(term)
	else
		return rsplit(term, ",")
	end
end

-- Remove any HTML from the formatted text and resolve links, since the extra characters don't contribute to the
-- displayed length.
local function convert_to_raw_text(text)
	text = rsub(text, "<.->", "")
	if text:find("%[%[") then
		text = require("Module:links").remove_links(text)
	end
	return text
end

-- Return the approximate displayed length in characters.
local function textual_len(text)
	return ulen(convert_to_raw_text(text))
end

-- Main syllable-division algorithm
local function syllabify_from_spelling_or_pronun(text, is_spelling)
	text = rsub(text, "##", "@@")
	text = rsub(text, "# #", "@ @")
	text = rsub(text, "#", ".")
    -- Part 1: Divide before the last consonant in a cluster of consonants between vowels
	text = rsub_repeatedly(text, "(" .. Vo .. accent_c .. "*)(" .. C .. Vo .. ")", "%1.%2")
	text = rsub_repeatedly(text, "(" .. Vo .. accent_c .. "*" .. C .. "+)(" .. C .. Vo .. ")", "%1.%2")

	-- Don't divide Cl or Cr where C is a stop or fricative, except for dl.
	text = rsub(text, "([pbfvkctgɡ])%.([lr])", ".%1%2")
	-- Don't divide ch
	text = rsub(text, "c%.h", ".ch")

	-- Part 2: Divide hiatuses (handling ai, ei, au, eu)
	text = rsub(text,"([aeAE])([ui])", "%1&%2")
	text = rsub_repeatedly(text, "(" .. Vo .. accent_c .. "*)(" .. Vo .. ")", "%1.%2")
	text = rsub(text, "&", "")
	
	--other fixes
	text = rsub(text, "@@", "##")
	text = rsub(text, "@ @", "# #")

	return text
end

local function syllabify_from_spelling(text)
	text = decompose(text)
	-- start at FFF1 because FFF0 is used for SYLDIV
	-- Temporary replacements for characters we want treated as default consonants. The C and related consonant regexes
	-- treat all unknown characters as consonants (vowels have been added manually to Vo)
	local TEMP_aa = u(0xFFF1)
	local TEMP_Aa = u(0xFFF2)
	local TEMP_ee = u(0xFFF4)
	local TEMP_Ee = u(0xFFF5)
	local TEMP_ie = u(0xFFF3)
	local TEMP_Ie = u(0xFFF6)
	local TEMP_Sch = u(0xFFF7)
	local TEMP_sch = u(0xFFF8)
	local TEMP_Tsch = u(0x0404)
	local TEMP_tsch = u(0x0405)
	local TEMP_AEae = u(0xFFF9)
	local TEMP_aeae = u(0xFFFA)
	local TEMP_Ii = u(0xFFFB)
	local TEMP_ii = u(0xFFFC)
	local TEMP_Oo = u(0x0400)
	local TEMP_oo = u(0x0401)
	local TEMP_Uu = u(0x0402)
	local TEMP_uu = u(0x0403)

	--vowel+h (by default, VhV will be interpreted as long vowel+vowel)
	text = rsub(text, "([aeiouäAEIOUÄ])h([aeiouä])", "%1h.%2")
	
	--substitutions
	text = rsub(text, "aa", TEMP_aa)
	text = rsub(text, "Aa", TEMP_Aa)
	text = rsub(text, "ee", TEMP_ee)
	text = rsub(text, "Ee", TEMP_Ee)
	text = rsub(text, "ii", TEMP_ii)
	text = rsub(text, "Ii", TEMP_Ii)
	text = rsub(text, "oo", TEMP_oo)
	text = rsub(text, "Oo", TEMP_Oo)
	text = rsub(text, "uu", TEMP_uu)
	text = rsub(text, "Uu", TEMP_Uu)
	text = rsub(text, "Ää", TEMP_AEae)
	text = rsub(text, "ää", TEMP_aeae)
	text = rsub(text, "tsch", TEMP_tsch)
	text = rsub(text, "Tsch", TEMP_Tsch)
	text = rsub(text, "sch", TEMP_sch)
	text = rsub(text, "Sch", TEMP_Sch)

	
	--diphthongs (ai, ei, au, eu + falling dipthongs respelled with <ĭŭ>)
	text = rsub(text, "([ĬĭŬŭ])(" .. Vo .. ")", "%1.%2")
	text = rsub(text,"([aeAE])([ui])(" .. Vo .. ")", "%1%2.%3")
	text = rsub(text, "ie", TEMP_ie)
	text = rsub(text, "Ie", TEMP_Ie)
	
	--the u in qu isn't a vowel
	text = rsub(text, "([Qq])u", "%1w")

	text = text:gsub("%.", SYLDIV)
	text = text:gsub("#", SYLDIV)
	text = syllabify_from_spelling_or_pronun(text, "is spelling")
		
	-- Change user-specified . into SYLDIV so we don't shuffle it around when dividing into syllables.
	text = text:gsub(SYLDIV, ".")
	text = text:gsub("qw", "qu")
	text = text:gsub("Qw", "Qu")
	text = text:gsub(TEMP_aa, "aa")
	text = text:gsub(TEMP_Aa, "Aa")
	text = text:gsub(TEMP_ee, "ee")
	text = text:gsub(TEMP_Ee, "Ee")
	text = text:gsub(TEMP_ie, "ie")
	text = text:gsub(TEMP_Ie, "Ie")
	text = text:gsub(TEMP_ii, "ii")
	text = text:gsub(TEMP_Ii, "Ii")
	text = text:gsub(TEMP_oo, "oo")
	text = text:gsub(TEMP_Oo, "Oo")
	text = text:gsub(TEMP_uu, "uu")
	text = text:gsub(TEMP_Uu, "Uu")
	text = text:gsub(TEMP_AEae, "Ää")
	text = text:gsub(TEMP_aeae, "ää")
	text = text:gsub(TEMP_sch, "sch")
	text = text:gsub(TEMP_Sch, "Sch")
	text = text:gsub(TEMP_tsch, "tsch")
	text = text:gsub(TEMP_Tsch, "Tsch")
	
	text = unfc(text)
	return text
end


-- Generate the IPA of a given respelling
function export.IPA(text)
	local debug = {}
	
	text = ulower(text or mw.title.getCurrentTitle().text)
	-- decompose everything but ä, ë, ï
	text = decompose(text)
	-- convert commas and en/en dashes to IPA foot boundaries
	text = rsub(text, "%s*[,–—]%s*", " | ")
	-- question mark or exclamation point in the middle of a sentence -> IPA foot boundary
	text = rsub(text, "([^%s])%s*[¡!¿?]%s*([^%s])", "%1 | %2")

	-- canonicalize multiple spaces and remove leading and trailing spaces
	local function canon_spaces(text)
		text = rsub(text, "%s+", " ")
		text = rsub(text, "^ ", "")
		text = rsub(text, " $", "")
		return text
	end

	text = canon_spaces(text)

	-- Make prefixes unstressed unless they have an explicit stress marker; also make certain
	-- monosyllabic words without stress marks be unstressed.
	local words = rsplit(text, " ")
	for i, word in ipairs(words) do
		if rfind(word, "%-$") and not rfind(word, accent_c) or unstressed_words[word] then
			-- add CFLEX to the last vowel not the first one, or we will mess up 'que' by
			-- adding the CFLEX after the 'u'
			words[i] = rsub(word, "^(.*" .. V .. ")", "%1" .. CFLEX)
		end
	end
	text = table.concat(words, " ")

	-- Convert hyphens to spaces
	text = rsub(text, "%-", " ")
	-- canonicalize multiple spaces again, which may have been introduced by hyphens
	text = canon_spaces(text)
	-- now eliminate punctuation
	text = rsub(text, "[¡!¿?']", "")
	-- put # at word beginning and end and double ## at text/foot boundary beginning/end
	text = rsub(text, " | ", "# | #")
	text = "##" .. rsub(text, " ", "# #") .. "##"
	
	--x/ç
	text = rsub(text, "x", "X") --the character <x>
	text = rsub(text, "auch", "auxx")
	text = rsub(text, "([aou])(" .. accent_c .. "?)ch", "%1%2xx")
	text = rsub(text, "eich", "eiçç")
	text = rsub(text, "euch", "euçç")
	text = rsub(text, "äich", "eiçç")
	text = rsub(text, "([äei])(" .. accent_c .. "?)ch", "%1%2çç")

	text = rsub(text, "augh", "aux")
	text = rsub(text, "([aou])(" .. accent_c .. "?)gh", "%1%2x")
	text = rsub(text, "eigh", "eiç")
	text = rsub(text, "eugh", "euç")
	text = rsub(text, "äigh", "eiç")
	text = rsub(text, "([äei])(" .. accent_c .. "?)gh", "%1%2ç")
	
	--c, ng, qu
	text = rsub(text, "tsch", "čč")
	text = rsub(text, "sch", "ʃʃ")
	text = rsub(text, "#ch", "ʃ")
	text = rsub(text, "ck", "kk")
	text = rsub(text, "c([ei])", "s%1")
	text = rsub(text, "c", "k")
	text = rsub(text, "ng", "ŋŋ")
	text = rsub(text, "qu", "kW") --fake symbol used to distinguish this sound from the usual /v/ written as <w>
	
	--diphthongs/n-phthongs
	text = rsub(text, "ieh", "í" .. AC)
	text = rsub(text, "ih", "í" .. AC)
	text = rsub(text, "eu", "ɔ" .. AC .. "ɪ̯")
	text = rsub(text, "ai", "a" .. AC .. "ɪ̯")
	text = rsub(text, "ei", "a" .. AC .. "ɪ̯")
	text = rsub(text, "aai", "ő" .. AC .. "ɪ̯")
	text = rsub(text, "au", "a" .. AC .. "ʊ̯")
	text = rsub(text, "oi", "o" .. AC .. "ɪ̯")
	text = rsub(text, "ĭ", "ɪ̯")
	text = rsub(text, "ŭ",  "ʊ̯")

	-- double vowels (we will handle them with a single character)
	text = rsub(text, "aa", "ő" .. AC)
	text = rsub(text, "ää", "à" .. AC)
	text = rsub(text, "äh", "à" .. AC)
	text = rsub(text, "a" .. GR, "ä" .. AC) --note that <à> is used internally for long ä=/ɛː/

	text = rsub(text, "e", "ə")
	text = rsub(text, "əh", "é" .. AC)
	text = rsub(text, "əər#", "é" .. AC .. "a#")
	text = rsub(text, "əə", "é" .. AC)
	text = rsub(text, "ëə", "é" .. AC .. "ə")
	text = rsub(text, "ër", "ɚ")
	text = rsub(text, "ë", "e")
		
	text = rsub(text, "iə", "í" .. AC)
	text = rsub(text, "ïə", "í" .. AC .. "ə")
	text = rsub(text, "ə" .. AC, "e" .. AC)
	text = rsub(text, "ii", "í" .. AC) --not really used, probably unnecesary

	text = rsub(text, "oo", "ó" .. AC)
	text = rsub(text, "oh", "ó" .. AC)
	text = rsub(text, "uu", "ú" .. AC)
	text = rsub(text, "uh", "ú" .. AC)
	
	text = rsub(text, "ï", "i")
	
	--consonants
	text = rsub(text, "w", "vv")
	text = rsub(text, "W", "w")
	text = rsub(text, "tz", "zz")
	text = rsub(text, "khə#", "çə#") --the suffix -che (note that c has been changed to k in a previous step)
	text = rsub(text, "s([ptk])", "ʃ%1") --palatalize s before (orthographic) fortis stops (this doesn't affect borrowings with <x>)
	text = rsub(text, "X", "ks")

	--<ptk> represent plain consonants word-initially only when followed by a vowel
	text = rsub(text, "#p(" .. V .. ")", "#P%1")
	text = rsub(text, "#t(" .. V .. ")", "#T%1")
	text = rsub(text, "#k(" .. V .. ")", "#K%1")
	fortis_lenis_conv = {["P"] = "p", ["T"] = "t", ["K"] = "k", ["p"] = "b", ["t"] = "d", ["k"] = "g"}
	text = rsub(text, "[PTKptk]", fortis_lenis_conv)
	
	--word finally, <v> devoices to /f/
	text = rsub(text, "v#", "f#")
	
	--Sequence äer
	text = rsub(text, "äər", "à" .. AC .. "a")
	
	-- accent all words (if no accent is found, it is added after the first vowel)
	local words = rsplit(text, " ")
	for j, word in ipairs(words) do
		if not rfind(word, accent_c) then
			words[j] = rsub(word, "^(.-" .. V .. ")", "%1" .. AC)
		end
	end
	text = table.concat(words, " ")
	
	--Ending -er when pronounced /-ˈɛa/ and -for when pronounced /ˈfɔa/
	text = rsub(text, "[eə]" .. AC .. "r#", "ɛ" .. AC .. "a#")
	text = rsub(text, "#fo" .. AC .. "r#", "#fɔ" .. AC .. "a#")

	--Orthographically short and phonologically long vowels, convert stressed /ə/ into /e/
	local short_long_v = {{"a", "á"}, {"ä", "à"}, {"e", "é"}, {"ə", "é"}, {"i", "í"}, {"o", "ó"}, {"u", "ú"}}
	for _, pair in ipairs(short_long_v) do
    	text = rsub(text, pair[1] .. AC .. "(" .. C .. "?)" .. "#", pair[2] .. AC .. "%1#")
    	text = rsub(text, pair[1] .. AC .. "(" .. C .. "?)" .. "(" .. V .. ")", pair[2] .. AC .. "%1%2")
	end
	text = rsub(text, "ə" .. AC, "e" .. AC)
	
	--Rhotics
	text = rsub(text, "o" .. AC .. "ər#", "ó" .. AC .. "a#")
	text = rsub(text, "([eə])" .. AC .. "([mnŋr])" .. "(" .. C .. ")", "ä" .. AC .. "%2%3")
	text = rsub(text, "o" .. AC .. "([mnŋr])" .. "(" .. C .. ")", "ɔ" .. AC .. "%1%2")
	text = rsub(text, "ər#", "a#")
	text = rsub(text, "ő" .. AC .. "r#", "ő" .. AC)
	text = rsub(text, "rr#", "r#")
	text = rsub(text, "r([dlnsʃčtz])", "%1%1")
	text = rsub(text, "ɚ", "er")
	
	--n -> ŋ before velar stops
	text = rsub(text, "n(%.*[gk])", "ŋ%1")

	--syllable division
	text = syllabify_from_spelling_or_pronun(text, false)

	--stress
	local accent_to_stress_mark = { [AC] = "ˈ", [GR] = "ˌ", [CFLEX] = "" }
	local words = rsplit(text, " ")
	for j, word in ipairs(words) do
		local syllables = rsplit(word, "%.")
		for i = 1, #syllables do
				syllables[i] = rsub(syllables[i], "^(.*)(" .. accent_c .. ")(.*)$",
					function(pre, accent, post) return accent_to_stress_mark[accent] .. pre .. post end
				)
		end
		words[j] = table.concat(syllables, ".")
		-- suppress syllable mark before IPA stress indicator
		words[j] = rsub(words[j], "%.(" .. ipa_stress_c .. ")", "%1")
		--make all primary stresses but the last one be secondary
		words[j] = rsub_repeatedly(words[j], "ˈ(.+)ˈ", "ˈ%1ˌ")
	end
	
	text = table.concat(words, " ")
	
	--final conversions
	final_conversions={ 
		["g"] = "k", ["k"] = "kʰ", 
		["b"] = "p", ["p"] = "pʰ", 
		["d"] = "t", ["t"] = "tʰ", 
		["ő"] = "ɔː", ["á"] = "aː", ["ä"] = "ɛ", ["à"] = "ɛː", ["é"] = "eː", ["í"] = "iː", ["ó"]= "oː", ["ú"] = "uː"}
	text = rsub(text, "[gkbpdtőáäàéíóú]",final_conversions)

	text = rsub(text, "#", "")

	text = rsub_repeatedly(text, "(" .. C .. ")%1", "%1") --remove double consonants
	text = rsub_repeatedly(text, "(" .. C .. ")([%.ˈˌ])%1", "%2%1") --remove double consonants
	text = rsub(text, "z", "t͡s")
	text = rsub(text, "č", "t͡ʃ")
	text = rsub(text, "ˌ" .. u(0x032F), u(0x032F) .. "ˌ")
	
	text = unfc(text)

	return {text = text}

end

local function express_all_styles(dodialect)
	local ret = {
		pronun = {},
		expressed_styles = {},
	}

	dodialect(ret)

	table.insert(ret.expressed_styles, {
			styles = {{pronun = ret.pronun,}},
		})
	
	return ret
end


local function format_all_styles(expressed_styles, format_style)
	for i, style_group in ipairs(expressed_styles) do
		style_group.formatted, style_group.formatted_len =
				format_style(style_group.styles[1].tag, style_group.styles[1], i == 1)
	end
	local lines = {}
	for i, style_group in ipairs(expressed_styles) do
		table.insert(lines, style_group.formatted)
	end
	return table.concat(lines, "\n")
end


local function dodialect_pronun(args, ret)
	ret.pronun = {}
	for i, term in ipairs(args.terms) do
		local phonemic
		if term.raw then
			phonemic = term.raw_phonemic
		else
			phonemic = export.IPA(term.term)
			phonemic = phonemic.text
		end
		local refs
		if not term.ref then
			refs = nil
		else
			refs = {}
			for _, refspec in ipairs(term.ref) do
				local this_refs = require("Module:references").parse_references(refspec)
				for _, this_ref in ipairs(this_refs) do
					table.insert(refs, this_ref)
				end
			end
		end

		ret.pronun[i] = {
			raw = term.raw,
			phonemic = phonemic,
			refs = refs,
			q = term.q,
			qq = term.qq,
			a = term.a,
			aa = term.aa,
		}
	end
end

local function generate_pronun(args)
	local function this_dodialect_pronun(ret)
		dodialect_pronun(args, ret)
	end

	local ret = express_all_styles(this_dodialect_pronun)

	local function format_style(tag, expressed_style, is_first)
		local pronunciations = {}
		local formatted_pronuns = {}

		local function ins(formatted_part)
			table.insert(formatted_pronuns, formatted_part)
		end

		-- Loop through each pronunciation.
		for j, pronun in ipairs(expressed_style.pronun) do
			-- Add tag to left qualifiers if first one
			-- FIXME: Consider using accent qualifier for the tag instead.
			local qs = pronun.q
			if j == 1 and tag then
				if qs then
					qs = m_table.deepcopy(qs)
					table.insert(qs, tag)
				else
					qs = {tag}
				end
			end

			local first_pronun = #pronunciations + 1

			if not pronun.phonemic then
				error("Internal error: Saw neither phonemic nor phonetic pronunciation")
			end

			if pronun.phonemic then
				local slash_pron = "/" .. pronun.phonemic:gsub("%.", "") .. "/"
				table.insert(pronunciations, {
					pron = slash_pron,
				})
				ins(slash_pron)
			end

			local last_pronun = #pronunciations

			if qs then
				pronunciations[first_pronun].q = qs
			end
			if pronun.a then
				pronunciations[first_pronun].a = pronun.a
			end
			if j > 1 then
				pronunciations[first_pronun].separator = ", "
				ins(", ")
			end
			if pronun.qq then
				pronunciations[last_pronun].qq = pronun.qq
			end
			if pronun.aa then
				pronunciations[last_pronun].aa = pronun.aa
			end
			if qs or pronun.qq or pronun.a or pronun.aa then
				-- Note: This inserts the actual formatted qualifier text, including HTML and such, but the later call
				-- to textual_len() removes all HTML and reduces links.
				ins(require("Module:pron qualifier").format_qualifiers {
					lang = lang,
					text = "",
					q = qs,
					qq = pronun.qq,
					a = pronun.a,
					aa = pronun.aa,
				})
			end

			if pronun.refs then
				pronunciations[last_pronun].refs = pronun.refs
				-- Approximate the reference using a footnote notation. This will be slightly inaccurate if there are
				-- more than nine references but that is rare.
				ins(string.rep("[1]", #pronun.refs))
			end
			if first_pronun ~= last_pronun then
				pronunciations[last_pronun].separator = " "
				ins(" ")
			end
		end

		local bullet = string.rep("*", args.bullets) .. " "
		-- Here we construct the formatted line in `formatted`, and also try to construct the equivalent without HTML
		-- and wiki markup in `formatted_for_len`, so we can compute the approximate textual length for use in sizing
		-- the toggle box with the "more" button on the right.
		local pre = is_first and args.pre and args.pre .. " " or ""
		local post = is_first and args.post and " " .. args.post or ""
		local formatted = bullet .. pre .. m_IPA.format_IPA_full { lang = lang, items = pronunciations, separator = "" } .. post
		local formatted_for_len = bullet .. pre .. "IPA(key): " .. table.concat(formatted_pronuns) .. post
		return formatted, textual_len(formatted_for_len)
	end

	ret.text = format_all_styles(ret.expressed_styles, format_style)

	return ret
end


local function parse_respelling(respelling, pagename, parse_err)
	local raw_respelling = respelling:match("^raw:(.*)$")
	if raw_respelling then
		local raw_phonemic = raw_respelling:match("^/(.*)/ %[(.*)%]$")
		if not raw_phonemic then
			raw_phonemic = raw_respelling:match("^/(.*)/$")
		end
		if not raw_phonemic then
			parse_err(("Unable to parse raw respelling '%s', should be one of /.../, [...] or /.../ [...]")
				:format(raw_respelling))
		end
		return {
			raw = true,
			raw_phonemic = raw_phonemic,
		}
	end
	if respelling == "+" then
		respelling = pagename
	end
	return {term = respelling}
end


-- Return the number of syllables of a phonemic representation, which should have syllable dividers in it but no hyphens.
local function get_num_syl_from_phonemic(phonemic)
	-- Maybe we should just count vowels instead of the below code.
	phonemic = rsub(phonemic, "|", " ") -- remove IPA foot boundaries
	local words = rsplit(phonemic, " +")
	for i, word in ipairs(words) do
		-- IPA stress marks are syllable divisions if between characters; otherwise just remove.
		word = rsub(word, "(.)[ˌˈ](.)", "%1.%2")
		word = rsub(word, "[ˌˈ]", "")
		words[i] = word
	end
	-- There should be a syllable boundary between words.
	phonemic = table.concat(words, ".")
	return ulen(rsub(phonemic, "[^.]", "")) + 1
end


-- Get the rhyme by truncating everything up through the last stress mark + any following consonants, and remove
-- syllable boundary markers.
local function convert_phonemic_to_rhyme(phonemic)
	return rsub(rsub(phonemic, ".*[ˌˈ]", ""), "^[^" .. vowel .. "]*", ""):gsub("%.", ""):gsub("t͡s", "ts")
end


local function split_syllabified_spelling(spelling)
	return rsplit(spelling, "%.")
end


-- "Align" syllabification to original spelling by matching character-by-character, allowing for extra syllable and
-- accent markers in the syllabification. If we encounter an extra syllable marker (.#), we allow and keep it. If we
-- encounter an extra accent marker in the syllabification, we drop it. In any other case, we return nil indicating
-- the alignment failed.
local function align_syllabification_to_spelling(syllab, spelling)
	local result = {}
	local syll_chars = rsplit(decompose(syllab, true), "")
	local spelling_chars = rsplit(decompose(spelling), "")
	local i = 1
	local j = 1
	while i <= #syll_chars or j <= #spelling_chars do
		local ci = syll_chars[i]
		local cj = spelling_chars[j]
		if ci == cj then
			table.insert(result, ci)
			i = i + 1
			j = j + 1
		elseif ci == "." or ci == "#" then
			table.insert(result, ci)
			i = i + 1
		elseif ci == AC or ci == CFLEX then
			-- skip character
			i = i + 1
		else
			-- non-matching character
			return nil
		end
	end
	if i <= #syll_chars or j <= #spelling_chars then
		-- left-over characters on one side or the other
		return nil
	end
	return unfc(table.concat(result))
end


local function generate_hyph_obj(term)
	return {syllabification = term, hyph = split_syllabified_spelling(term)}
end


-- Word should already be decomposed.
local function word_has_vowels(word)
	return rfind(word, V)
end


local function all_words_have_vowels(term)
	local words = rsplit(decompose(term), "[ %-]")
	for i, word in ipairs(words) do
		-- Allow empty word; this occurs with prefixes and suffixes.
		if word ~= "" and not word_has_vowels(word) then
			return false
		end
	end
	return true
end


local function should_generate_rhyme_from_respelling(term)
	local words = rsplit(decompose(term), " +")
	return #words == 1 and -- no if multiple words
		not words[1]:find(".%-.") and -- no if word is composed of hyphenated parts
		not words[1]:find("%-$") and -- no if word is a prefix
		not (words[1]:find("^%-") and words[1]:find(CFLEX)) and -- no if word is an unstressed suffix
		word_has_vowels(words[1]) -- no if word has no vowels (e.g. a single letter)
end


local function should_generate_rhyme_from_ipa(ipa)
	return not ipa:find("%s") and word_has_vowels(decompose(ipa))
end


local function dodialect_specified_rhymes(rhymes, hyphs, parsed_respellings, rhyme_ret)
	rhyme_ret.pronun = {}
	for _, rhyme in ipairs(rhymes) do
		local num_syl = rhyme.num_syl
		local no_num_syl = false

		-- If user explicitly gave the rhyme but didn't explicitly specify the number of syllables, try to take it from
		-- the hyphenation.
		if not num_syl then
			num_syl = {}
			for _, hyph in ipairs(hyphs) do
				if should_generate_rhyme_from_respelling(hyph.syllabification) then
					local this_num_syl = 1 + ulen(rsub(hyph.syllabification, "[^.]", ""))
					m_table.insertIfNot(num_syl, this_num_syl)
				else
					no_num_syl = true
					break
				end
			end
			if no_num_syl or #num_syl == 0 then
				num_syl = nil
			end
		end

		-- If that fails and term is single-word, try to take it from the phonemic.
		if not no_num_syl and not num_syl then
			for _, parsed in ipairs(parsed_respellings) do
				for dialect, pronun in pairs(parsed.pronun.pronun) do
					-- Check that pronun.phonemic exists (it may not if raw phonetic-only pronun is given).
					if pronun.phonemic then
						if not should_generate_rhyme_from_ipa(pronun.phonemic) then
							no_num_syl = true
							break
						end
						-- Count number of syllables by looking at syllable boundaries (including stress marks).
						local this_num_syl = get_num_syl_from_phonemic(pronun.phonemic)
						m_table.insertIfNot(num_syl, this_num_syl)
					end
				end
				if no_num_syl then
					break
				end
			end
			if no_num_syl or #num_syl == 0 then
				num_syl = nil
			end
		end

		table.insert(rhyme_ret.pronun, {
			rhyme = rhyme.rhyme,
			num_syl = num_syl,
			qualifiers = rhyme.qualifiers,
		})
	end
end


local function parse_pron_modifier(arg, parse_err, generate_obj, param_mods, no_split_on_comma)
	local retval = {}

	if arg:find("<") then
		local insert = { store = "insert" }
		param_mods.q = insert
		param_mods.qq = insert
		param_mods.a = insert
		param_mods.aa = insert
		return require(put_module).parse_inline_modifiers(arg, {
			param_mods = param_mods,
			generate_obj = generate_obj,
			parse_err = parse_err,
			splitchar = not no_split_on_comma and "," or nil,
		})
	elseif no_split_on_comma then
		table.insert(retval, generate_obj(arg))
	else
		for _, term in ipairs(split_on_comma(arg)) do
			table.insert(retval, generate_obj(term))
		end
	end

	return retval
end


local function parse_rhyme(arg, parse_err)
	local function generate_obj(term)
		return {rhyme = term}
	end
	local param_mods = {
		s = {
			item_dest = "num_syl",
			convert = function(arg, parse_err)
				local nsyls = rsplit(arg, ",")
				for i, nsyl in ipairs(nsyls) do
					if not nsyl:find("^[0-9]+$") then
						parse_err("Number of syllables '" .. nsyl .. "' should be numeric")
					end
					nsyls[i] = tonumber(nsyl)
				end
				return nsyls
			end,
		},
	}

	return parse_pron_modifier(arg, parse_err, generate_obj, param_mods)
end


local function parse_hyph(arg, parse_err)
	-- None other than qualifiers
	local param_mods = {}

	return parse_pron_modifier(arg, parse_err, generate_hyph_obj, param_mods)
end


local function parse_homophone(arg, parse_err)
	local function generate_obj(term)
		return {term = term}
	end
	local param_mods = {
		t = {
			-- We need to store the <t:...> inline modifier into the "gloss" key of the parsed term,
			-- because that is what [[Module:links]] (called from [[Module:homophones]]) expects.
			item_dest = "gloss",
		},
		gloss = {},
		pos = {},
		alt = {},
		lit = {},
		id = {},
		g = {
			-- We need to store the <g:...> inline modifier into the "genders" key of the parsed term,
			-- because that is what [[Module:links]] (called from [[Module:homophones]]) expects.
			item_dest = "genders",
			convert = function(arg)
				return rsplit(arg, ",")
			end,
		},
	}

	return parse_pron_modifier(arg, parse_err, generate_obj, param_mods)
end


local function generate_audio_obj(arg)
	local file, gloss
	if arg:find("#") then
		file, gloss = arg:match("^(.-)%s*#%s*(.*)$")
	else
		file, gloss = arg:match("^(.-)%s*;%s*(.*)$")
	end
	if not file then
		file = arg
		gloss = "Audio"
	end
	return {file = file, gloss = gloss}
end


local function parse_audio(arg, parse_err)
	-- None other than qualifiers
	local param_mods = {}

	-- Don't split on comma because some filenames have embedded commas not followed by a space
	-- (typically followed by an underscore).
	return parse_pron_modifier(arg, parse_err, generate_audio_obj, param_mods, "no split on comma")
end


-- External entry point for {{fax-pr}}.
function export.show_pr(frame)
	local params = {
		[1] = {list = true},
		["rhyme"] = {},
		["hyph"] = {},
		["hmp"] = {},
		["audio"] = {list = true},
		["pagename"] = {},
	}
	local parargs = frame:getParent().args
	local args = require("Module:parameters").process(parargs, params)
	local pagename = args.pagename or mw.title.getCurrentTitle().subpageText

	-- Parse the arguments.
	local respellings = #args[1] > 0 and args[1] or {"+"}
	local parsed_respellings = {}
	local function overall_parse_err(msg, arg, val)
		error(msg .. ": " .. arg .. "= " .. val)
	end
	local overall_rhyme = args.rhyme and
		parse_rhyme(args.rhyme, function(msg) overall_parse_err(msg, "rhyme", args.rhyme) end) or nil
	local overall_hyph = args.hyph and
		parse_hyph(args.hyph, function(msg) overall_parse_err(msg, "hyph", args.hyph) end) or nil
	local overall_hmp = args.hmp and
		parse_homophone(args.hmp, function(msg) overall_parse_err(msg, "hmp", args.hmp) end) or nil
	local overall_audio
	if args.audio then
		overall_audio = {}
		for _, audio in ipairs(args.audio) do
			local parsed_audio = parse_audio(audio, function(msg) overall_parse_err(msg, "audio", audio) end)
			if #parsed_audio > 1 then
				error("Internal error: Saw more than one object returned from parse_audio")
			end
			table.insert(overall_audio, parsed_audio[1])
		end
	end
	for i, respelling in ipairs(respellings) do
		if respelling:find("<") then
			local param_mods = {
				pre = { overall = true },
				post = { overall = true },
				bullets = {
					overall = true,
					convert = function(arg, parse_err)
						if not arg:find("^[0-9]+$") then
							parse_err("Modifier 'bullets' should have a number as argument, but saw '" .. arg .. "'")
						end
						return tonumber(arg)
					end,
				},
				rhyme = {
					overall = true,
					store = "insert-flattened",
					convert = parse_rhyme,
				},
				hyph = {
					overall = true,
					store = "insert-flattened",
					convert = parse_hyph,
				},
				hmp = {
					overall = true,
					store = "insert-flattened",
					convert = parse_homophone,
				},
				audio = {
					overall = true,
					store = "insert-flattened",
					convert = parse_audio,
				},
				ref = { store = "insert" },
				q = { store = "insert" },
				qq = { store = "insert" },
				a = { store = "insert" },
				aa = { store = "insert" },
			}

			local parsed = require(put_module).parse_inline_modifiers(respelling, {
				paramname = i,
				param_mods = param_mods,
				generate_obj = function(term, parse_err)
					return parse_respelling(term, pagename, parse_err)
				end,
				splitchar = ",",
				outer_container = {
					audio = {}, rhyme = {}, hyph = {}, hmp = {}
				}
			})
			if not parsed.bullets then
				parsed.bullets = 1
			end
			table.insert(parsed_respellings, parsed)
		else
			local termobjs = {}
			local function parse_err(msg)
				error(msg .. ": " .. i .. "= " .. respelling)
			end
			for _, term in ipairs(split_on_comma(respelling)) do
				table.insert(termobjs, parse_respelling(term, pagename, parse_err))
			end
			table.insert(parsed_respellings, {
				terms = termobjs,
				audio = {},
				rhyme = {},
				hyph = {},
				hmp = {},
				bullets = 1,
			})
		end
	end

	if overall_hyph then
		local hyphs = {}
		for _, hyph in ipairs(overall_hyph) do
			if hyph.syllabification == "+" then
				hyph.syllabification = syllabify_from_spelling(pagename)
				hyph.hyph = split_syllabified_spelling(hyph.syllabification)
			elseif hyph.syllabification == "-" then
				overall_hyph = {}
				break
			end
		end
	end

	-- Loop over individual respellings, processing each.
	for _, parsed in ipairs(parsed_respellings) do
		parsed.pronun = generate_pronun(parsed)
		local no_auto_rhyme = false
		for _, term in ipairs(parsed.terms) do
			if term.raw then
				if not should_generate_rhyme_from_ipa(term.raw_phonemic) then
					no_auto_rhyme = true
					break
				end
			elseif not should_generate_rhyme_from_respelling(term.term) then
				no_auto_rhyme = true
				break
			end
		end

		if #parsed.hyph == 0 then
			if not overall_hyph and all_words_have_vowels(pagename) then
				for _, term in ipairs(parsed.terms) do
					if not term.raw then
						local syllabification = syllabify_from_spelling(term.term)
						local aligned_syll = align_syllabification_to_spelling(syllabification, pagename)
						if aligned_syll then
							m_table.insertIfNot(parsed.hyph, generate_hyph_obj(aligned_syll))
						end
					end
				end
			end
		else
			for _, hyph in ipairs(parsed.hyph) do
				if hyph.syllabification == "+" then
					hyph.syllabification = syllabify_from_spelling(pagename)
					hyph.hyph = split_syllabified_spelling(hyph.syllabification)
				elseif hyph.syllabification == "-" then
					parsed.hyph = {}
					break
				end
			end
		end

		-- Generate the rhymes.
		local function dodialect_rhymes_from_pronun(rhyme_ret)
			rhyme_ret.pronun = {}
			for _, pronun in ipairs(parsed.pronun.pronun) do
				-- We should have already excluded multiword terms and terms without vowels from rhyme generation (see
				-- `no_auto_rhyme` below). But make sure to check that pronun.phonemic exists (it may not if raw
				-- phonetic-only pronun is given).
				if pronun.phonemic then
					-- Count number of syllables by looking at syllable boundaries (including stress marks).
					local num_syl = get_num_syl_from_phonemic(pronun.phonemic)
					-- Get the rhyme by truncating everything up through the last stress mark + any following
					-- consonants, and remove syllable boundary markers.
					local rhyme = convert_phonemic_to_rhyme(pronun.phonemic)
					local saw_already = false
					for _, existing in ipairs(rhyme_ret.pronun) do
						if existing.rhyme == rhyme then
							saw_already = true
							-- We already saw this rhyme but possibly with a different number of syllables,
							-- e.g. if the user specified two pronunciations 'biología' (4 syllables) and
							-- 'bi.ología' (5 syllables), both of which have the same rhyme /ia/.
							m_table.insertIfNot(existing.num_syl, num_syl)
							break
						end
					end
					if not saw_already then
						table.insert(rhyme_ret.pronun, {
							rhyme = rhyme,
							num_syl = {num_syl},
						})
					end
				end
			end
		end

		if #parsed.rhyme == 0 then
			if overall_rhyme or no_auto_rhyme then
				parsed.rhyme = nil
			else
				parsed.rhyme = express_all_styles(dodialect_rhymes_from_pronun)
			end
		else
			local no_rhyme = false
			for _, rhyme in ipairs(parsed.rhyme) do
				if rhyme.rhyme == "-" then
					no_rhyme = true
					break
				end
			end
			if no_rhyme then
				parsed.rhyme = nil
			else
				local function this_dodialect(rhyme_ret, dialect)
					return dodialect_specified_rhymes(parsed.rhyme, parsed.hyph, {parsed}, rhyme_ret)
				end
				parsed.rhyme = express_all_styles(this_dodialect)
			end
		end
	end

	if overall_rhyme then
		local no_overall_rhyme = false
		for _, orhyme in ipairs(overall_rhyme) do
			if orhyme.rhyme == "-" then
				no_overall_rhyme = true
				break
			end
		end
		if no_overall_rhyme then
			overall_rhyme = nil
		else
			local all_hyphs
			if overall_hyph then
				all_hyphs = overall_hyph
			else
				all_hyphs = {}
				for _, parsed in ipairs(parsed_respellings) do
					for _, hyph in ipairs(parsed.hyph) do
						m_table.insertIfNot(all_hyphs, hyph)
					end
				end
			end
			local function dodialect_overall_rhyme(rhyme_ret, dialect)
				return dodialect_specified_rhymes(overall_rhyme, all_hyphs, parsed_respellings, rhyme_ret)
			end
			overall_rhyme = express_all_styles(dodialect_overall_rhyme)
		end
	end

	-- If all sets of pronunciations have the same rhymes, display them only once at the bottom.
	-- Otherwise, display rhymes beneath each set, indented.
	local first_rhyme_ret
	local all_rhyme_sets_eq = true
	for j, parsed in ipairs(parsed_respellings) do
		if j == 1 then
			first_rhyme_ret = parsed.rhyme
		elseif not m_table.deepEquals(first_rhyme_ret, parsed.rhyme) then
			all_rhyme_sets_eq = false
			break
		end
	end

	local function format_rhyme(rhyme_ret, num_bullets)
		local function format_rhyme_style(tag, expressed_style, is_first)
			local pronunciations = {}
			local rhymes = {}
			for _, pronun in ipairs(expressed_style.pronun) do
				table.insert(rhymes, pronun)
			end
			local data = {
				lang = lang,
				rhymes = rhymes,
				qualifiers = tag and {tag} or nil,
				force_cat = force_cat,
			}
			local bullet = string.rep("*", num_bullets) .. " "
			local formatted = bullet .. require("Module:rhymes").format_rhymes(data)
			local formatted_for_len_parts = {}
			table.insert(formatted_for_len_parts, bullet .. "Rhymes: " .. (tag and "(" .. tag .. ") " or ""))
			for j, pronun in ipairs(expressed_style.pronun) do
				if j > 1 then
					table.insert(formatted_for_len_parts, ", ")
				end
				if pronun.qualifiers then
					table.insert(formatted_for_len_parts, "(" .. table.concat(pronun.qualifiers, ", ") .. ") ")
				end
				table.insert(formatted_for_len_parts, "-" .. pronun.rhyme)
			end
			return formatted, textual_len(table.concat(formatted_for_len_parts))
		end

		return format_all_styles(rhyme_ret.expressed_styles, format_rhyme_style)
	end

	-- If all sets of pronunciations have the same hyphenations, display them only once at the bottom.
	-- Otherwise, display hyphenations beneath each set, indented.
	local first_hyphs
	local all_hyph_sets_eq = true
	for j, parsed in ipairs(parsed_respellings) do
		if j == 1 then
			first_hyphs = parsed.hyph
		elseif not m_table.deepEquals(first_hyphs, parsed.hyph) then
			all_hyph_sets_eq = false
			break
		end
	end

	local function format_hyphenations(hyphs, num_bullets)
		local hyphtext = require("Module:hyphenation").format_hyphenations { lang = lang, hyphs = hyphs, caption = "Syllabification" }
		return string.rep("*", num_bullets) .. " " .. hyphtext
	end

	-- If all sets of pronunciations have the same homophones, display them only once at the bottom.
	-- Otherwise, display homophones beneath each set, indented.
	local first_hmps
	local all_hmp_sets_eq = true
	for j, parsed in ipairs(parsed_respellings) do
		if j == 1 then
			first_hmps = parsed.hmp
		elseif not m_table.deepEquals(first_hmps, parsed.hmp) then
			all_hmp_sets_eq = false
			break
		end
	end

	local function format_homophones(hmps, num_bullets)
		local hmptext = require("Module:homophones").format_homophones { lang = lang, homophones = hmps }
		return string.rep("*", num_bullets) .. " " .. hmptext
	end

	local function format_audio(audios, num_bullets)
		local ret = {}
		for i, audio in ipairs(audios) do
			local text = require(audio_module).format_audio {
				lang = lang,
				file = audio.file,
				caption = audio.gloss,
				q = audio.q,
				qq = audio.qq,
				a = audio.a,
				aa = audio.aa,
			}
			table.insert(ret, string.rep("*", num_bullets) .. " " .. text)
		end
		return table.concat(ret, "\n")
	end

	local textparts = {}
	local min_num_bullets = 9999
	for j, parsed in ipairs(parsed_respellings) do
		if parsed.bullets < min_num_bullets then
			min_num_bullets = parsed.bullets
		end
		if j > 1 then
			table.insert(textparts, "\n")
		end
		table.insert(textparts, parsed.pronun.text)
		if #parsed.audio > 0 then
			table.insert(textparts, "\n")
			-- If only one pronunciation set, add the audio with the same number of bullets, otherwise
			-- indent audio by one more bullet.
			table.insert(textparts, format_audio(parsed.audio,
				#parsed_respellings == 1 and parsed.bullets or parsed.bullets + 1))
		end
		if not all_rhyme_sets_eq and parsed.rhyme then
			table.insert(textparts, "\n")
			table.insert(textparts, format_rhyme(parsed.rhyme, parsed.bullets + 1))
		end
		if not all_hyph_sets_eq and #parsed.hyph > 0 then
			table.insert(textparts, "\n")
			table.insert(textparts, format_hyphenations(parsed.hyph, parsed.bullets + 1))
		end
		if not all_hmp_sets_eq and #parsed.hmp > 0 then
			table.insert(textparts, "\n")
			table.insert(textparts, format_homophones(parsed.hmp, parsed.bullets + 1))
		end
	end
	if overall_audio and #overall_audio > 0 then
		table.insert(textparts, "\n")
		table.insert(textparts, format_audio(overall_audio, min_num_bullets))
	end
	if all_rhyme_sets_eq and first_rhyme_ret then
		table.insert(textparts, "\n")
		table.insert(textparts, format_rhyme(first_rhyme_ret, min_num_bullets))
	end
	if overall_rhyme then
		table.insert(textparts, "\n")
		table.insert(textparts, format_rhyme(overall_rhyme, min_num_bullets))
	end
	if all_hyph_sets_eq and #first_hyphs > 0 then
		table.insert(textparts, "\n")
		table.insert(textparts, format_hyphenations(first_hyphs, min_num_bullets))
	end
	if overall_hyph and #overall_hyph > 0 then
		table.insert(textparts, "\n")
		table.insert(textparts, format_hyphenations(overall_hyph, min_num_bullets))
	end
	if all_hmp_sets_eq and #first_hmps > 0 then
		table.insert(textparts, "\n")
		table.insert(textparts, format_homophones(first_hmps, min_num_bullets))
	end
	if overall_hmp and #overall_hmp > 0 then
		table.insert(textparts, "\n")
		table.insert(textparts, format_homophones(overall_hmp, min_num_bullets))
	end

	return table.concat(textparts)
end

return export