main.v

module vouconv

pub enum EncodingStyle {
	circled
	circled_neg
	fullwidth
	math_bold
	math_bold_fraktur
	math_bold_italic
	math_bold_script
	math_double_struck
	math_monospace
	math_sans
	math_sans_bold
	math_sans_bold_italic
	math_sans_italic
	parenthesized
	regional_indicator
	squared
	squared_neg
	a_cute
	cjk_thai
	curvy1
	curvy2
	curvy3
	faux_cyrillic
	faux_ethiopic
	math_fraktur
	rock_dots
	small_caps
	stroked
	subscript
	superscript
	inverted
	inverted_backward
	reversed
	reversed_backward
}

pub fn convert_to_exotic(s string, style EncodingStyle) string {
	match style {
		.circled { return convert_to_circled(s) }
		.circled_neg { return convert_to_circled_neg(s) }
		.fullwidth { return convert_to_fullwidth(s) }
		.math_bold { return convert_to_math_bold(s) }
		.math_bold_fraktur { return convert_to_math_bold_fraktur(s) }
		.math_bold_italic { return convert_to_math_bold_italic(s) }
		.math_bold_script { return convert_to_math_bold_script(s) }
		.math_double_struck { return convert_to_math_double_struck(s) }
		.math_monospace { return convert_to_math_monospace(s) }
		.math_sans { return convert_to_math_sans(s) }
		.math_sans_bold { return convert_to_math_sans_bold(s) }
		.math_sans_bold_italic { return convert_to_math_sans_bold_italic(s) }
		.math_sans_italic { return convert_to_math_sans_italic(s) }
		.parenthesized { return convert_to_parenthesized(s) }
		.regional_indicator { return convert_to_regional_indicator(s) }
		.squared { return convert_to_squared(s) }
		.squared_neg { return convert_to_squared_neg(s) }
		.a_cute { return convert_to_a_cute(s) }
		.cjk_thai { return convert_to_cjk_thai(s) }
		.curvy1 { return convert_to_curvy1(s) }
		.curvy2 { return convert_to_curvy2(s) }
		.curvy3 { return convert_to_curvy3(s) }
		.faux_cyrillic { return convert_to_faux_cyrillic(s) }
		.faux_ethiopic { return convert_to_faux_ethiopic(s) }
		.math_fraktur { return convert_to_math_fraktur(s) }
		.rock_dots { return convert_to_rock_dots(s) }
		.small_caps { return convert_to_small_caps(s) }
		.stroked { return convert_to_stroked(s) }
		.subscript { return convert_to_subscript(s) }
		.superscript { return convert_to_superscript(s) }
		.inverted { return convert_to_inverted(s) }
		.inverted_backward { return convert_to_inverted_backward(s) }
		.reversed { return convert_to_reversed(s) }
		.reversed_backward { return convert_to_reversed_backward(s) }
	}
}

pub fn convert_to_circled(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to circled uppercase (Ⓐ-Ⓩ)
			result += rune(0x24B6 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to circled lowercase (ⓐ-ⓩ)
			result += rune(0x24D0 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			if c == `0` {
				// Circled zero is different
				result += '0'
			} else {
				// Convert digits 1-9 to circled digits (①-⑨)
				result += rune(0x2460 + (c - `1`)).str()
			}
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_circled_neg(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to negative circled uppercase (🅐-🅩)
			result += rune(0x1F150 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to negative circled lowercase (using uppercase symbols)
			result += rune(0x1F150 + (c - `a`)).str()
		} else if c == `0` {
			// Negative circled zero
			result += '⓿'
		} else if c >= `1` && c <= `9` {
			// Keep digits 1-9 as regular characters
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_fullwidth(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to fullwidth uppercase (Ａ-Ｚ)
			result += rune(0xFF21 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to fullwidth lowercase (ａ-ｚ)
			result += rune(0xFF41 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Convert digits to fullwidth digits (０-９)
			result += rune(0xFF10 + (c - `0`)).str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_bold(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math bold uppercase (𝐀-𝐙)
			result += rune(0x1D400 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math bold lowercase (𝐚-𝐳)
			result += rune(0x1D41A + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Convert digits to math bold digits (𝟎-𝟗)
			result += rune(0x1D7CE + (c - `0`)).str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_bold_fraktur(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math bold fraktur uppercase (𝕬-𝖅)
			result += rune(0x1D56C + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math bold fraktur lowercase (𝖆-𝖟)
			result += rune(0x1D586 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is (based on test)
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_bold_italic(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math bold italic uppercase (𝑨-𝒁)
			result += rune(0x1D468 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math bold italic lowercase (𝒂-𝒛)
			result += rune(0x1D482 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is (based on test)
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_bold_script(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math bold script uppercase (𝓐-𝓩)
			result += rune(0x1D4D0 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math bold script lowercase (𝓪-𝔃)
			result += rune(0x1D4EA + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is (based on test)
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_double_struck(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math double-struck uppercase (𝔸-ℤ)
			// Special cases for C, H, N, P, Q, R, Z which have different code points
			match c {
				`C` { result += 'ℂ' }
				`H` { result += 'ℍ' }
				`N` { result += 'ℕ' }
				`P` { result += 'ℙ' }
				`Q` { result += 'ℚ' }
				`R` { result += 'ℝ' }
				`Z` { result += 'ℤ' }
				else { result += rune(0x1D538 + (c - `A`)).str() }
			}
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math double-struck lowercase (𝕒-𝕫)
			result += rune(0x1D552 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Convert digits to math double-struck digits (𝟘-𝟡)
			result += rune(0x1D7D8 + (c - `0`)).str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_monospace(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math monospace uppercase (𝙰-𝚉)
			result += rune(0x1D670 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math monospace lowercase (𝚊-𝚣)
			result += rune(0x1D68A + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Convert digits to math monospace digits (𝟶-𝟿)
			result += rune(0x1D7F6 + (c - `0`)).str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_sans(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math sans uppercase (𝖠-𝖹)
			result += rune(0x1D5A0 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math sans lowercase (𝖺-𝗓)
			result += rune(0x1D5BA + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Convert digits to math sans digits (𝟢-𝟫)
			result += rune(0x1D7E2 + (c - `0`)).str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_sans_bold(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math sans bold uppercase (𝗔-𝗭)
			result += rune(0x1D5D4 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math sans bold lowercase (𝗮-𝘇)
			result += rune(0x1D5EE + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Convert digits to math sans bold digits (𝟬-𝟵)
			result += rune(0x1D7EC + (c - `0`)).str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_sans_bold_italic(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math sans bold italic uppercase (𝘼-𝙕)
			result += rune(0x1D63C + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math sans bold italic lowercase (𝙖-𝙯)
			result += rune(0x1D656 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is (based on test)
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_math_sans_italic(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math sans italic uppercase (𝘈-𝘡)
			result += rune(0x1D608 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math sans italic lowercase (𝘢-𝘻)
			result += rune(0x1D622 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is (based on test)
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_parenthesized(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Uppercase letters - convert to lowercase parenthesized (⒜-⒵)
			result += rune(0x249C + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Lowercase letters to parenthesized (⒜-⒵)
			result += rune(0x249C + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			if c == `0` {
				// Regular 0 for zero
				result += '0'
			} else {
				// Parenthesized numbers 1-9 (⑴-⑼)
				result += rune(0x2474 + (c - `1`)).str()
			}
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_regional_indicator(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Uppercase letters to regional indicators (🇦-🇿)
			result += rune(0x1F1E6 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Lowercase letters also to regional indicators (same as uppercase)
			result += rune(0x1F1E6 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_squared(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Uppercase letters to squared (🄰-🅉)
			result += rune(0x1F130 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Lowercase letters to squared (same as uppercase)
			result += rune(0x1F130 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_squared_neg(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Uppercase letters to negative squared (🅰-🆉)
			result += rune(0x1F170 + (c - `A`)).str()
		} else if c >= `a` && c <= `z` {
			// Lowercase letters to negative squared (same as uppercase)
			result += rune(0x1F170 + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as is
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_a_cute(s string) string {
	// Updated mapping based on the test assertion
	mappings := {
		`A`: 'Á'
		`B`: 'B'
		`C`: 'Ć'
		`D`: 'D'
		`E`: 'É'
		`F`: 'F'
		`G`: 'Ǵ'
		`H`: 'H'
		`I`: 'í'
		`J`: 'J'
		`K`: 'Ḱ'
		`L`: 'Ĺ'
		`M`: 'Ḿ'
		`N`: 'Ń'
		`O`: 'Ő'
		`P`: 'Ṕ'
		`Q`: 'Q'
		`R`: 'Ŕ'
		`S`: 'ś'
		`T`: 'T'
		`U`: 'Ű'
		`V`: 'V'
		`W`: 'Ẃ'
		`X`: 'X'
		`Y`: 'Ӳ'
		`Z`: 'Ź'
		`a`: 'á'
		`b`: 'b'
		`c`: 'ć'
		`d`: 'd'
		`e`: 'é'
		`f`: 'f'
		`g`: 'ǵ'
		`h`: 'h'
		`i`: 'í'
		`j`: 'j'
		`k`: 'ḱ'
		`l`: 'ĺ'
		`m`: 'ḿ'
		`n`: 'ń'
		`o`: 'ő'
		`p`: 'ṕ'
		`q`: 'q'
		`r`: 'ŕ'
		`s`: 'ś'
		`t`: 't'
		`u`: 'ú'
		`v`: 'v'
		`w`: 'ẃ'
		`x`: 'x'
		`y`: 'ӳ'
		`z`: 'ź'
	}

	mut result := ''

	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep digits and other chars as is
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_cjk_thai(s string) string {
	// Based on the test, this maps to a mix of CJK and Thai characters
	mappings := {
		`A`: 'ﾑ'
		`B`: '乃'
		`C`: 'c'
		`D`: 'd'
		`E`: '乇'
		`F`: 'ｷ'
		`G`: 'g'
		`H`: 'ん'
		`I`: 'ﾉ'
		`J`: 'ﾌ'
		`K`: 'ズ'
		`L`: 'ﾚ'
		`M`: 'ﾶ'
		`N`: '刀'
		`O`: 'o'
		`P`: 'ｱ'
		`Q`: 'q'
		`R`: '尺'
		`S`: '丂'
		`T`: 'ｲ'
		`U`: 'u'
		`V`: '√'
		`W`: 'w'
		`X`: 'ﾒ'
		`Y`: 'ﾘ'
		`Z`: '乙'
		`a`: 'ﾑ'
		`b`: '乃'
		`c`: 'c'
		`d`: 'd'
		`e`: '乇'
		`f`: 'ｷ'
		`g`: 'g'
		`h`: 'ん'
		`i`: 'ﾉ'
		`j`: 'ﾌ'
		`k`: 'ズ'
		`l`: 'ﾚ'
		`m`: 'ﾶ'
		`n`: '刀'
		`o`: 'o'
		`p`: 'ｱ'
		`q`: 'q'
		`r`: '尺'
		`s`: '丂'
		`t`: 'ｲ'
		`u`: 'u'
		`v`: '√'
		`w`: 'w'
		`x`: 'ﾒ'
		`y`: 'ﾘ'
		`z`: '乙'
	}

	mut result := ''

	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep digits and other chars as is
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_curvy1(s string) string {
	// First curvy style based on test
	mappings := {
		`A`: 'ค'
		`B`: '๒'
		`C`: 'ƈ'
		`D`: 'ɗ'
		`E`: 'ﻉ'
		`F`: 'ि'
		`G`: 'ﻭ'
		`H`: 'ɦ'
		`I`: 'ٱ'
		`J`: 'ﻝ'
		`K`: 'ᛕ'
		`L`: 'ɭ'
		`M`: '๓'
		`N`: 'ก'
		`O`: 'ѻ'
		`P`: 'ρ'
		`Q`: '۹'
		`R`: 'ɼ'
		`S`: 'ร'
		`T`: 'Շ'
		`U`: 'પ'
		`V`: '۷'
		`W`: 'ฝ'
		`X`: 'ซ'
		`Y`: 'ץ'
		`Z`: 'չ'
		`a`: 'ค'
		`b`: '๒'
		`c`: 'ƈ'
		`d`: 'ɗ'
		`e`: 'ﻉ'
		`f`: 'ि'
		`g`: 'ﻭ'
		`h`: 'ɦ'
		`i`: 'ٱ'
		`j`: 'ﻝ'
		`k`: 'ᛕ'
		`l`: 'ɭ'
		`m`: '๓'
		`n`: 'ก'
		`o`: 'ѻ'
		`p`: 'ρ'
		`q`: '۹'
		`r`: 'ɼ'
		`s`: 'ร'
		`t`: 'Շ'
		`u`: 'પ'
		`v`: '۷'
		`w`: 'ฝ'
		`x`: 'ซ'
		`y`: 'ץ'
		`z`: 'չ'
	}

	mut result := ''

	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep digits and other chars as is
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_curvy2(s string) string {
	// Second curvy style based on test
	mappings := {
		`A`: 'α'
		`B`: 'в'
		`C`: '¢'
		`D`: '∂'
		`E`: 'є'
		`F`: 'ƒ'
		`G`: 'ﻭ'
		`H`: 'н'
		`I`: 'ι'
		`J`: 'נ'
		`K`: 'к'
		`L`: 'ℓ'
		`M`: 'м'
		`N`: 'η'
		`O`: 'σ'
		`P`: 'ρ'
		`Q`: '۹'
		`R`: 'я'
		`S`: 'ѕ'
		`T`: 'т'
		`U`: 'υ'
		`V`: 'ν'
		`W`: 'ω'
		`X`: 'χ'
		`Y`: 'у'
		`Z`: 'չ'
		`a`: 'α'
		`b`: 'в'
		`c`: '¢'
		`d`: '∂'
		`e`: 'є'
		`f`: 'ƒ'
		`g`: 'ﻭ'
		`h`: 'н'
		`i`: 'ι'
		`j`: 'נ'
		`k`: 'к'
		`l`: 'ℓ'
		`m`: 'м'
		`n`: 'η'
		`o`: 'σ'
		`p`: 'ρ'
		`q`: '۹'
		`r`: 'я'
		`s`: 'ѕ'
		`t`: 'т'
		`u`: 'υ'
		`v`: 'ν'
		`w`: 'ω'
		`x`: 'χ'
		`y`: 'у'
		`z`: 'չ'
	}

	mut result := ''

	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep digits and other chars as is
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_curvy3(s string) string {
	// Updated mapping based on the test assertion
	mappings := {
		`A`: 'ค'
		`B`: '๒'
		`C`: 'ς'
		`D`: '๔'
		`E`: 'є'
		`F`: 'Ŧ'
		`G`: 'ﻮ'
		`H`: 'ђ'
		`I`: 'เ'
		`J`: 'ן'
		`K`: 'к'
		`L`: 'ɭ'
		`M`: '๓'
		`N`: 'ภ'
		`O`: '๏'
		`P`: 'ק'
		`Q`: 'ợ'
		`R`: 'г'
		`S`: 'ร'
		`T`: 'Շ'
		`U`: 'ย'
		`V`: 'ש'
		`W`: 'ฬ'
		`X`: 'א'
		`Y`: 'ץ'
		`Z`: 'չ'
		`a`: 'ค'
		`b`: '๒'
		`c`: 'ς'
		`d`: '๔'
		`e`: 'є'
		`f`: 'Ŧ'
		`g`: 'ﻮ'
		`h`: 'ђ'
		`i`: 'เ'
		`j`: 'ן'
		`k`: 'к'
		`l`: 'ɭ'
		`m`: '๓'
		`n`: 'ภ'
		`o`: '๏'
		`p`: 'ק'
		`q`: 'ợ'
		`r`: 'г'
		`s`: 'ร'
		`t`: 'Շ'
		`u`: 'ย'
		`v`: 'ש'
		`w`: 'ฬ'
		`x`: 'א'
		`y`: 'ץ'
		`z`: 'չ'
	}

	mut result := ''

	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep digits and other chars as is
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_faux_cyrillic(s string) string {
	// Updated mapping based on the test assertion
	mappings := {
		`A`: 'Д'
		`B`: 'Б'
		`C`: 'Ҁ'
		`D`: 'ↁ'
		`E`: 'Є'
		`F`: 'F'
		`G`: 'Б'
		`H`: 'Н'
		`I`: 'І'
		`J`: 'Ј'
		`K`: 'Ќ'
		`L`: 'L'
		`M`: 'М'
		`N`: 'И'
		`O`: 'Ф'
		`P`: 'Р'
		`Q`: 'Q'
		`R`: 'Я'
		`S`: 'Ѕ'
		`T`: 'Г'
		`U`: 'Ц'
		`V`: 'V'
		`W`: 'Щ'
		`X`: 'Ж'
		`Y`: 'Ч'
		`Z`: 'Z'
		`a`: 'а'
		`b`: 'ъ'
		`c`: 'с'
		`d`: 'ↁ'
		`e`: 'э'
		`f`: 'f'
		`g`: 'Б'
		`h`: 'Ђ'
		`i`: 'і'
		`j`: 'ј'
		`k`: 'к'
		`l`: 'l'
		`m`: 'м'
		`n`: 'и'
		`o`: 'о'
		`p`: 'р'
		`q`: 'q'
		`r`: 'ѓ'
		`s`: 'ѕ'
		`t`: 'т'
		`u`: 'ц'
		`v`: 'v'
		`w`: 'ш'
		`x`: 'х'
		`y`: 'Ў'
		`z`: 'z'
	}

	mut result := ''
	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_faux_ethiopic(s string) string {
	// Updated mapping based on the test assertion
	mappings := {
		`A`: 'ል'
		`B`: 'ጌ'
		`C`: 'ር'
		`D`: 'ዕ'
		`E`: 'ቿ'
		`F`: 'ቻ'
		`G`: 'ኗ'
		`H`: 'ዘ'
		`I`: 'ጎ'
		`J`: 'ጋ'
		`K`: 'ጕ'
		`L`: 'ረ'
		`M`: 'ጠ'
		`N`: 'ክ'
		`O`: 'ዐ'
		`P`: 'የ'
		`Q`: 'ዒ'
		`R`: 'ዪ'
		`S`: 'ነ'
		`T`: 'ፕ'
		`U`: 'ሁ'
		`V`: 'ሀ'
		`W`: 'ሠ'
		`X`: 'ሸ'
		`Y`: 'ሃ'
		`Z`: 'ጊ'
		`a`: 'ል'
		`b`: 'ጌ'
		`c`: 'ር'
		`d`: 'ዕ'
		`e`: 'ቿ'
		`f`: 'ቻ'
		`g`: 'ኗ'
		`h`: 'ዘ'
		`i`: 'ጎ'
		`j`: 'ጋ'
		`k`: 'ጕ'
		`l`: 'ረ'
		`m`: 'ጠ'
		`n`: 'ክ'
		`o`: 'ዐ'
		`p`: 'የ'
		`q`: 'ዒ'
		`r`: 'ዪ'
		`s`: 'ነ'
		`t`: 'ፕ'
		`u`: 'ሁ'
		`v`: 'ሀ'
		`w`: 'ሠ'
		`x`: 'ሸ'
		`y`: 'ሃ'
		`z`: 'ጊ'
	}

	mut result := ''
	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_math_fraktur(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to math fraktur uppercase (𝔄-𝔜)
			// Note: Some letters have special codepoints
			match c {
				`C` { result += 'ℭ' }
				`H` { result += 'ℌ' }
				`I` { result += 'ℑ' }
				`R` { result += 'ℜ' }
				`Z` { result += 'ℨ' }
				else { result += rune(0x1D504 + (c - `A`)).str() }
			}
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to math fraktur lowercase (𝔞-𝔷)
			result += rune(0x1D51E + (c - `a`)).str()
		} else if c >= `0` && c <= `9` {
			// Keep digits as regular characters
			result += c.ascii_str()
		} else {
			// Keep other characters unchanged
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_rock_dots(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to dotted uppercase
			match c {
				`A` { result += 'Ä' }
				`B` { result += 'Ḅ' }
				`C` { result += 'Ċ' }
				`D` { result += 'Ḋ' }
				`E` { result += 'Ё' }
				`F` { result += 'Ḟ' }
				`G` { result += 'Ġ' }
				`H` { result += 'Ḧ' }
				`I` { result += 'Ї' }
				`J` { result += 'J' }
				`K` { result += 'Ḳ' }
				`L` { result += 'Ḷ' }
				`M` { result += 'Ṁ' }
				`N` { result += 'Ṅ' }
				`O` { result += 'Ö' }
				`P` { result += 'Ṗ' }
				`Q` { result += 'Q' }
				`R` { result += 'Ṛ' }
				`S` { result += 'Ṡ' }
				`T` { result += 'Ṫ' }
				`U` { result += 'Ü' }
				`V` { result += 'Ṿ' }
				`W` { result += 'Ẅ' }
				`X` { result += 'Ẍ' }
				`Y` { result += 'Ÿ' }
				`Z` { result += 'Ż' }
				else { result += c.str() }
			}
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to dotted lowercase
			match c {
				`a` { result += 'ä' }
				`b` { result += 'ḅ' }
				`c` { result += 'ċ' }
				`d` { result += 'ḋ' }
				`e` { result += 'ë' }
				`f` { result += 'ḟ' }
				`g` { result += 'ġ' }
				`h` { result += 'ḧ' }
				`i` { result += 'ï' }
				`j` { result += 'j' }
				`k` { result += 'ḳ' }
				`l` { result += 'ḷ' }
				`m` { result += 'ṁ' }
				`n` { result += 'ṅ' }
				`o` { result += 'ö' }
				`p` { result += 'ṗ' }
				`q` { result += 'q' }
				`r` { result += 'ṛ' }
				`s` { result += 'ṡ' }
				`t` { result += 'ẗ' }
				`u` { result += 'ü' }
				`v` { result += 'ṿ' }
				`w` { result += 'ẅ' }
				`x` { result += 'ẍ' }
				`y` { result += 'ÿ' }
				`z` { result += 'ż' }
				else { result += c.ascii_str() }
			}
		} else if c >= `0` && c <= `9` {
			// Convert digits where possible
			match c {
				`3` { result += 'ӟ' }
				else { result += c.ascii_str() }
			}
		} else {
			result += c.ascii_str()
		}
	}
	return result
}

pub fn convert_to_small_caps(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase to small caps
			match c {
				`A` { result += 'ᴀ' }
				`B` { result += 'ʙ' }
				`C` { result += 'ᴄ' }
				`D` { result += 'ᴅ' }
				`E` { result += 'ᴇ' }
				`F` { result += 'ꜰ' }
				`G` { result += 'ɢ' }
				`H` { result += 'ʜ' }
				`I` { result += 'ɪ' }
				`J` { result += 'ᴊ' }
				`K` { result += 'ᴋ' }
				`L` { result += 'ʟ' }
				`M` { result += 'ᴍ' }
				`N` { result += 'ɴ' }
				`O` { result += 'ᴏ' }
				`P` { result += 'ᴩ' }
				`Q` { result += 'Q' }
				`R` { result += 'ʀ' }
				`S` { result += 'ꜱ' }
				`T` { result += 'ᴛ' }
				`U` { result += 'ᴜ' }
				`V` { result += 'ᴠ' }
				`W` { result += 'ᴡ' }
				`X` { result += 'x' }
				`Y` { result += 'Y' }
				`Z` { result += 'ᴢ' }
				else { result += c.str() }
			}
		} else if c >= `a` && c <= `z` {
			// Convert lowercase to small caps
			match c {
				`a` { result += 'ᴀ' }
				`b` { result += 'ʙ' }
				`c` { result += 'ᴄ' }
				`d` { result += 'ᴅ' }
				`e` { result += 'ᴇ' }
				`f` { result += 'ꜰ' }
				`g` { result += 'ɢ' }
				`h` { result += 'ʜ' }
				`i` { result += 'ɪ' }
				`j` { result += 'ᴊ' }
				`k` { result += 'ᴋ' }
				`l` { result += 'ʟ' }
				`m` { result += 'ᴍ' }
				`n` { result += 'ɴ' }
				`o` { result += 'ᴏ' }
				`p` { result += 'ᴩ' }
				`q` { result += 'q' }
				`r` { result += 'ʀ' }
				`s` { result += 'ꜱ' }
				`t` { result += 'ᴛ' }
				`u` { result += 'ᴜ' }
				`v` { result += 'ᴠ' }
				`w` { result += 'ᴡ' }
				`x` { result += 'x' }
				`y` { result += 'y' }
				`z` { result += 'ᴢ' }
				else { result += c.str() }
			}
		} else if c >= `0` && c <= `9` {
			// Keep digits as is
			result += c.ascii_str()
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_stroked(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase to stroked uppercase
			match c {
				`A` { result += 'Ⱥ' }
				`B` { result += 'Ƀ' }
				`C` { result += 'Ȼ' }
				`D` { result += 'Đ' }
				`E` { result += 'Ɇ' }
				`F` { result += 'F' }
				`G` { result += 'Ǥ' }
				`H` { result += 'Ħ' }
				`I` { result += 'Ɨ' }
				`J` { result += 'Ɉ' }
				`K` { result += 'Ꝁ' }
				`L` { result += 'Ł' }
				`M` { result += 'M' }
				`N` { result += 'N' }
				`O` { result += 'Ø' }
				`P` { result += 'Ᵽ' }
				`Q` { result += 'Ꝗ' }
				`R` { result += 'Ɍ' }
				`S` { result += 'S' }
				`T` { result += 'Ŧ' }
				`U` { result += 'ᵾ' }
				`V` { result += 'V' }
				`W` { result += 'W' }
				`X` { result += 'X' }
				`Y` { result += 'Ɏ' }
				`Z` { result += 'Ƶ' }
				else { result += c.str() }
			}
		} else if c >= `a` && c <= `z` {
			// Convert lowercase to stroked lowercase
			match c {
				`a` { result += 'Ⱥ' }
				`b` { result += 'ƀ' }
				`c` { result += 'ȼ' }
				`d` { result += 'đ' }
				`e` { result += 'ɇ' }
				`f` { result += 'f' }
				`g` { result += 'ǥ' }
				`h` { result += 'ħ' }
				`i` { result += 'ɨ' }
				`j` { result += 'ɉ' }
				`k` { result += 'ꝁ' }
				`l` { result += 'ł' }
				`m` { result += 'm' }
				`n` { result += 'n' }
				`o` { result += 'ø' }
				`p` { result += 'ᵽ' }
				`q` { result += 'ꝗ' }
				`r` { result += 'ɍ' }
				`s` { result += 's' }
				`t` { result += 'ŧ' }
				`u` { result += 'ᵾ' }
				`v` { result += 'v' }
				`w` { result += 'w' }
				`x` { result += 'x' }
				`y` { result += 'ɏ' }
				`z` { result += 'ƶ' }
				else { result += c.str() }
			}
		} else if c >= `0` && c <= `9` {
			// Convert digits according to expected output
			match c {
				`0` { result += '0' }
				`1` { result += '1' }
				`2` { result += 'ƻ' }
				`3` { result += '3' }
				`4` { result += '4' }
				`5` { result += '5' }
				`6` { result += '6' }
				`7` { result += '7' }
				`8` { result += '8' }
				`9` { result += '9' }
				else { result += c.str() }
			}
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_subscript(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to subscript where available
			match c {
				`A` { result += 'ₐ' }
				`B` { result += 'B' }
				`C` { result += 'C' }
				`D` { result += 'D' }
				`E` { result += 'ₑ' }
				`F` { result += 'F' }
				`G` { result += 'G' }
				`H` { result += 'ₕ' }
				`I` { result += 'ᵢ' }
				`J` { result += 'ⱼ' }
				`K` { result += 'ₖ' }
				`L` { result += 'ₗ' }
				`M` { result += 'ₘ' }
				`N` { result += 'ₙ' }
				`O` { result += 'ₒ' }
				`P` { result += 'ₚ' }
				`Q` { result += 'Q' }
				`R` { result += 'ᵣ' }
				`S` { result += 'ₛ' }
				`T` { result += 'ₜ' }
				`U` { result += 'ᵤ' }
				`V` { result += 'ᵥ' }
				`W` { result += 'W' }
				`X` { result += 'ₓ' }
				`Y` { result += 'Y' }
				`Z` { result += 'Z' }
				else { result += c.str() }
			}
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to subscript where available
			match c {
				`a` { result += 'ₐ' }
				`b` { result += 'b' }
				`c` { result += 'c' }
				`d` { result += 'd' }
				`e` { result += 'ₑ' }
				`f` { result += 'f' }
				`g` { result += 'g' }
				`h` { result += 'ₕ' }
				`i` { result += 'ᵢ' }
				`j` { result += 'ⱼ' }
				`k` { result += 'ₖ' }
				`l` { result += 'ₗ' }
				`m` { result += 'ₘ' }
				`n` { result += 'ₙ' }
				`o` { result += 'ₒ' }
				`p` { result += 'ₚ' }
				`q` { result += 'q' }
				`r` { result += 'ᵣ' }
				`s` { result += 'ₛ' }
				`t` { result += 'ₜ' }
				`u` { result += 'ᵤ' }
				`v` { result += 'ᵥ' }
				`w` { result += 'w' }
				`x` { result += 'ₓ' }
				`y` { result += 'y' }
				`z` { result += 'z' }
				else { result += c.str() }
			}
		} else if c >= `0` && c <= `9` {
			// Convert digits to subscript
			match c {
				`0` { result += '₀' }
				`1` { result += '₁' }
				`2` { result += '₂' }
				`3` { result += '₃' }
				`4` { result += '₄' }
				`5` { result += '₅' }
				`6` { result += '₆' }
				`7` { result += '₇' }
				`8` { result += '₈' }
				`9` { result += '₉' }
				else { result += c.str() }
			}
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_superscript(s string) string {
	mut result := ''

	for c in s {
		if c >= `A` && c <= `Z` {
			// Convert uppercase letters to superscript where available
			match c {
				`A` { result += 'ᴬ' }
				`B` { result += 'ᴮ' }
				`C` { result += 'ᶜ' }
				`D` { result += 'ᴰ' }
				`E` { result += 'ᴱ' }
				`F` { result += 'ᶠ' }
				`G` { result += 'ᴳ' }
				`H` { result += 'ᴴ' }
				`I` { result += 'ᴵ' }
				`J` { result += 'ᴶ' }
				`K` { result += 'ᴷ' }
				`L` { result += 'ᴸ' }
				`M` { result += 'ᴹ' }
				`N` { result += 'ᴺ' }
				`O` { result += 'ᴼ' }
				`P` { result += 'ᴾ' }
				`Q` { result += 'Q' }
				`R` { result += 'ᴿ' }
				`S` { result += 'ˢ' }
				`T` { result += 'ᵀ' }
				`U` { result += 'ᵁ' }
				`V` { result += 'ⱽ' }
				`W` { result += 'ᵂ' }
				`X` { result += 'ˣ' }
				`Y` { result += 'ʸ' }
				`Z` { result += 'ᶻ' }
				else { result += c.str() }
			}
		} else if c >= `a` && c <= `z` {
			// Convert lowercase letters to superscript where available
			match c {
				`a` { result += 'ᵃ' }
				`b` { result += 'ᵇ' }
				`c` { result += 'ᶜ' }
				`d` { result += 'ᵈ' }
				`e` { result += 'ᵉ' }
				`f` { result += 'ᶠ' }
				`g` { result += 'ᵍ' }
				`h` { result += 'ʰ' }
				`i` { result += 'ⁱ' }
				`j` { result += 'ʲ' }
				`k` { result += 'ᵏ' }
				`l` { result += 'ˡ' }
				`m` { result += 'ᵐ' }
				`n` { result += 'ⁿ' }
				`o` { result += 'ᵒ' }
				`p` { result += 'ᵖ' }
				`q` { result += 'q' }
				`r` { result += 'ʳ' }
				`s` { result += 'ˢ' }
				`t` { result += 'ᵗ' }
				`u` { result += 'ᵘ' }
				`v` { result += 'ᵛ' }
				`w` { result += 'ʷ' }
				`x` { result += 'ˣ' }
				`y` { result += 'ʸ' }
				`z` { result += 'ᶻ' }
				else { result += c.str() }
			}
		} else if c >= `0` && c <= `9` {
			// Convert digits to superscript
			match c {
				`0` { result += '⁰' }
				`1` { result += '¹' }
				`2` { result += '²' }
				`3` { result += '³' }
				`4` { result += '⁴' }
				`5` { result += '⁵' }
				`6` { result += '⁶' }
				`7` { result += '⁷' }
				`8` { result += '⁸' }
				`9` { result += '⁹' }
				else { result += c.str() }
			}
		} else if c == ` ` {
			// Preserve spaces as-is
			result += ' '
		} else {
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_inverted(s string) string {
	// Mapping for inverted characters
	mappings := {
		`A`: 'ꓯ'
		`B`: 'ꓭ'
		`C`: 'Ↄ'
		`D`: 'ꓷ'
		`E`: 'Ǝ'
		`F`: 'Ⅎ'
		`G`: '⅁'
		`H`: 'ɥ'
		`I`: 'ı'
		`J`: 'ᒋ'
		`K`: 'ꓘ'
		`L`: '⅂'
		`M`: 'W'
		`N`: 'u'
		`O`: 'O'
		`P`: 'ꓒ'
		`Q`: 'Ò'
		`R`: 'ꓤ'
		`S`: 'S'
		`T`: 'ꓕ'
		`U`: 'ꓵ'
		`V`: '𐌡'
		`W`: 'M'
		`X`: 'X'
		`Y`: '⅄'
		`Z`: 'Z'
		`a`: 'ɐ'
		`b`: 'q'
		`c`: 'ɔ'
		`d`: 'p'
		`e`: 'ǝ'
		`f`: 'ɟ'
		`g`: 'ƃ'
		`h`: 'ɥ'
		`i`: 'ı'
		`j`: 'ɾ'
		`k`: 'ʞ'
		`l`: 'ן'
		`m`: 'ɯ'
		`n`: 'u'
		`o`: 'o'
		`p`: 'd'
		`q`: 'b'
		`r`: 'ɹ'
		`s`: 's'
		`t`: 'ʇ'
		`u`: 'n'
		`v`: 'ʌ'
		`w`: 'ʍ'
		`x`: 'x'
		`y`: 'ʎ'
		`z`: 'z'
		`0`: '0'
		`1`: 'Ɩ'
		`2`: '↊'
		`3`: '↋'
		`4`: 'Һ'
		`5`: 'ꞔ'
		`6`: '9'
		`7`: '∠'
		`8`: '8'
		`9`: '6'
		` `: ' '
	}

	mut result := ''

	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_inverted_backward(s string) string {
	// Mapping for inverted and backward characters
	mappings := {
		`A`: 'ꓯ'
		`B`: 'ꓭ'
		`C`: 'Ↄ'
		`D`: 'ꓷ'
		`E`: 'Ǝ'
		`F`: 'Ⅎ'
		`G`: '⅁'
		`H`: 'ɥ'
		`I`: 'ı'
		`J`: 'ᒋ'
		`K`: 'ꓘ'
		`L`: '⅂'
		`M`: 'W'
		`N`: 'u'
		`O`: 'O'
		`P`: 'ꓒ'
		`Q`: 'Ò'
		`R`: 'ꓤ'
		`S`: 'S'
		`T`: 'ꓕ'
		`U`: 'ꓵ'
		`V`: '𐌡'
		`W`: 'M'
		`X`: 'X'
		`Y`: '⅄'
		`Z`: 'Z'
		`a`: 'ɐ'
		`b`: 'q'
		`c`: 'ɔ'
		`d`: 'p'
		`e`: 'ǝ'
		`f`: 'ɟ'
		`g`: 'ƃ'
		`h`: 'ɥ'
		`i`: 'ı'
		`j`: 'ɾ'
		`k`: 'ʞ'
		`l`: 'ן'
		`m`: 'ɯ'
		`n`: 'u'
		`o`: 'o'
		`p`: 'd'
		`q`: 'b'
		`r`: 'ɹ'
		`s`: 's'
		`t`: 'ʇ'
		`u`: 'n'
		`v`: 'ʌ'
		`w`: 'ʍ'
		`x`: 'x'
		`y`: 'ʎ'
		`z`: 'z'
		`0`: '0'
		`1`: 'Ɩ'
		`2`: '↊'
		`3`: '↋'
		`4`: 'Һ'
		`5`: 'ꞔ'
		`6`: '9'
		`7`: '∠'
		`8`: '8'
		`9`: '6'
	}

	mut result := ''
	// Process the string in reverse order
	for i := s.len - 1; i >= 0; i-- {
		c := s[i]
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep other characters unchanged
			result += rune(c).str()
		}
	}
	return result
}

pub fn convert_to_reversed(s string) string {
	// Mapping for reversed characters
	mappings := {
		`A`: 'A'
		`B`: 'd'
		`C`: 'Ↄ'
		`D`: 'b'
		`E`: 'Ǝ'
		`F`: 'ꟻ'
		`G`: 'G'
		`H`: 'H'
		`I`: 'I'
		`J`: 'J'
		`K`: 'K'
		`L`: '⅃'
		`M`: 'M'
		`N`: 'ᴎ'
		`O`: 'O'
		`P`: 'ꟼ'
		`Q`: 'p'
		`R`: 'ᴙ'
		`S`: 'Ꙅ'
		`T`: 'T'
		`U`: 'U'
		`V`: 'V'
		`W`: 'W'
		`X`: 'X'
		`Y`: 'Y'
		`Z`: 'Z'
		`a`: 'A'
		`b`: 'd'
		`c`: 'ↄ'
		`d`: 'b'
		`e`: 'ɘ'
		`f`: 'ꟻ'
		`g`: 'g'
		`h`: 'H'
		`i`: 'i'
		`j`: 'j'
		`k`: 'k'
		`l`: 'l'
		`m`: 'm'
		`n`: 'ᴎ'
		`o`: 'o'
		`p`: 'q'
		`q`: 'p'
		`r`: 'ᴙ'
		`s`: 'ꙅ'
		`t`: 'T'
		`u`: 'U'
		`v`: 'v'
		`w`: 'w'
		`x`: 'x'
		`y`: 'Y'
		`z`: 'z'
		`0`: '0'
		`1`: '߁'
		`2`: '2'
		`3`: '3'
		`4`: '4'
		`5`: '5'
		`6`: '6'
		`7`: '7'
		`8`: '8'
		`9`: '9'
		` `: ' '
	}

	mut result := ''

	for c in s {
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep other characters unchanged
			result += c.str()
		}
	}
	return result
}

pub fn convert_to_reversed_backward(s string) string {
	// Mapping for reversed characters, displayed in reverse order
	mappings := {
		`A`: 'A'
		`B`: 'd'
		`C`: 'Ↄ'
		`D`: 'b'
		`E`: 'Ǝ'
		`F`: 'ꟻ'
		`G`: 'G'
		`H`: 'H'
		`I`: 'I'
		`J`: 'J'
		`K`: 'K'
		`L`: '⅃'
		`M`: 'M'
		`N`: 'ᴎ'
		`O`: 'O'
		`P`: 'ꟼ'
		`Q`: 'p'
		`R`: 'ᴙ'
		`S`: 'Ꙅ'
		`T`: 'T'
		`U`: 'U'
		`V`: 'V'
		`W`: 'W'
		`X`: 'X'
		`Y`: 'Y'
		`Z`: 'Z'
		`a`: 'A'
		`b`: 'd'
		`c`: 'ↄ'
		`d`: 'b'
		`e`: 'ɘ'
		`f`: 'ꟻ'
		`g`: 'g'
		`h`: 'H'
		`i`: 'i'
		`j`: 'j'
		`k`: 'k'
		`l`: 'l'
		`m`: 'm'
		`n`: 'ᴎ'
		`o`: 'o'
		`p`: 'q'
		`q`: 'p'
		`r`: 'ᴙ'
		`s`: 'ꙅ'
		`t`: 'T'
		`u`: 'U'
		`v`: 'v'
		`w`: 'w'
		`x`: 'x'
		`y`: 'Y'
		`z`: 'z'
		`0`: '0'
		`1`: '߁'
		`2`: '2'
		`3`: '3'
		`4`: '4'
		`5`: '5'
		`6`: '6'
		`7`: '7'
		`8`: '8'
		`9`: '9'
	}

	mut result := ''
	
	// Process the string in reverse order
	for i := s.len - 1; i >= 0; i-- {
		c := s[i]
		if c in mappings {
			result += mappings[c]
		} else {
			// Keep other characters unchanged
			result += rune(c).str()
		}
	}
	return result
}