scriptconv 0.0.3a17__tar.gz → 0.0.3a19__tar.gz

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.3a17
+Version: 0.0.3a19
 Summary: Zero-dependency script & phoneme-notation core — ISO-15924 detection & metadata, IPA↔ARPABET/X-SAMPA/Lexique/Kirshenbaum/Cotovía/RFE, Buckwalter↔Arabic, Hangul→jamo, kana
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/TigreGotico/scriptconv
@@ -296,7 +296,8 @@ below describes the per-converter default.
 |----------|----------------------------------|----------------------------------|-------------------------|
 | **ARPABET** | **Lossless with `stress=True`** (digits ↔ IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0` — stable from the IPA side). Default `stress=False` drops digits and merges `AH0`↔`AX` | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped; other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
-| **Buckwalter ↔ Arabic** | Exact (the `^` shadda alias normalises to canonical `~`; precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Passed through unchanged |
+| **Buckwalter ↔ Arabic** | Exact (precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Follows `errors=` (default: passed through) |
+| **Mantoq → IPA** | One-directional (gemination/word markers consumed; no IPA→Mantoq) | — | Follows `errors=` (default: passed through) |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both → `ə`; reverse always → `°`) | Exact | Passed through unchanged |
 | **Kirshenbaum ↔ IPA** | Exact | **Lossy** — restricted ASCII inventory; IPA outside it passes through | Passed through unchanged |
 | **Cotovía ↔ IPA** | Exact except the three `L`/`Z`/`jj` symbols for `ʎ` normalise to `L` | **Lossy** — Galician/Spanish inventory; IPA outside it passes through | Passed through unchanged |

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/README.md

@@ -179,7 +179,8 @@ below describes the per-converter default.
 |----------|----------------------------------|----------------------------------|-------------------------|
 | **ARPABET** | **Lossless with `stress=True`** (digits ↔ IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0` — stable from the IPA side). Default `stress=False` drops digits and merges `AH0`↔`AX` | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped; other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
-| **Buckwalter ↔ Arabic** | Exact (the `^` shadda alias normalises to canonical `~`; precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Passed through unchanged |
+| **Buckwalter ↔ Arabic** | Exact (precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Follows `errors=` (default: passed through) |
+| **Mantoq → IPA** | One-directional (gemination/word markers consumed; no IPA→Mantoq) | — | Follows `errors=` (default: passed through) |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both → `ə`; reverse always → `°`) | Exact | Passed through unchanged |
 | **Kirshenbaum ↔ IPA** | Exact | **Lossy** — restricted ASCII inventory; IPA outside it passes through | Passed through unchanged |
 | **Cotovía ↔ IPA** | Exact except the three `L`/`Z`/`jj` symbols for `ʎ` normalise to `L` | **Lossy** — Galician/Spanish inventory; IPA outside it passes through | Passed through unchanged |

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/scriptconv/graph.py

@@ -170,6 +170,8 @@ REPRESENTATIONS: Dict[str, Representation] = {r.id: r for r in (
     Representation("kirshenbaum", "notation", reference="Kirshenbaum ASCII-IPA"),
     Representation("cotovia", "notation", reference="Cotovía (Galician TTS)"),
     Representation("rfe", "notation", reference="Revista de Filología Española"),
+    Representation("mantoq", "notation", system="mantoq",
+                   reference="Halabi Arabic-Phonetiser phoneme inventory"),
     Representation("buckwalter", "notation", script="Latn",
                    reference="Buckwalter Arabic transliteration"),
     Representation("arabic", "orthography", script="Arab",

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/scriptconv/notation.py

@@ -56,7 +56,8 @@ class Notation(str, Enum):
     LEXIQUE = "lexique"  # Lexique one-char-per-phoneme French notation
     KIRSHENBAUM = "kirshenbaum"  # ASCII-IPA (espeak-ng native notation)
     COTOVIA = "cotovia"  # Universidade de Vigo Cotovía TTS notation (gl)
-    RFE = "rfe"  # Revista de Filología Española phonetic alphabet
+    RFE = "rfe"
+    MANTOQ = "mantoq"  # Revista de Filología Española phonetic alphabet
 
     def __repr__(self) -> str:
         return f"Notation.{self.name}"
@@ -523,7 +524,8 @@ _BW_TO_ARABIC: dict[str, str] = {
     "K": "ٍ",  # tanwin kasr
     # Special
     "_": "ـ",  # tatweel
-    "^": "ّ",  # shadda alias
+    "{": "ٱ",  # alef wasla
+    "`": "ٰ",  # dagger (superscript) alef
 }
 
 _ARABIC_TO_BW: dict[str, str] = {v: k for k, v in _BW_TO_ARABIC.items()}
@@ -532,9 +534,6 @@ _ARABIC_TO_BW["\uFEFB"] = "lA"   # لا  lam + alef ligature
 _ARABIC_TO_BW["\uFEF9"] = "l<"   # لإ  lam + alef hamza below
 _ARABIC_TO_BW["\uFEF7"] = "l>"   # لأ  lam + alef hamza above
 _ARABIC_TO_BW["\uFEF8"] = "l|"   # لآ  lam + alef madda
-# The reverse comprehension lets the "^" shadda alias win over canonical "~";
-# restore the standard Buckwalter shadda so round-trips stay faithful.
-_ARABIC_TO_BW["\u0651"] = "~"   # shadda -> canonical "~", not the "^" alias
 
 
 def buckwalter_to_arabic(bw: str, errors: str = "pass") -> str:
@@ -1005,6 +1004,118 @@ def ipa_to_rfe(ipa: str, errors: str = "pass") -> str:
     return "".join(result)
 
 
+
+# ---------------------------------------------------------------------------
+# Mantoq → IPA
+#
+# Mantoq is the phonetic alphabet of Nawar Halabi's Arabic-Phonetiser (the
+# inventory emitted by the mantoq G2P pipeline): an ASCII phoneme notation
+# with Buckwalter-derived consonant letters (deviating where the phoneme set
+# requires — "^" is θ here, "v" a loan phoneme), stress/emphatic-free short
+# and long vowels ("a"/"aa"/"aaaa"), a gemination marker ``_dbl_`` and a word
+# separator ``_+_``.  The token→IPA mapping below is authored in-house from
+# the inventory's phonetic values — the phonetiser CODE is CC BY-NC and lives
+# elsewhere; a factual symbol table is not encumbered by it.  Published
+# models trained on mantoq sequences make this notation worth transcoding.
+# One-directional: IPA → mantoq is not defined.
+# ---------------------------------------------------------------------------
+
+_MANTOQ_CONSONANTS: dict[str, str] = {
+    "b": "b", "t": "t", "^": "θ", "j": "d͡ʒ", "H": "ħ", "x": "x",
+    "d": "d", "*": "ð", "r": "r", "z": "z", "s": "s", "$": "ʃ",
+    "S": "sˤ", "D": "dˤ", "T": "tˤ", "Z": "ðˤ", "E": "ʕ", "g": "ɣ",
+    "f": "f", "q": "q", "k": "k", "l": "l", "m": "m", "n": "n",
+    "h": "h", "w": "w", "y": "j", "v": "v",
+}
+
+_MANTOQ_VOWELS: dict[str, str] = {
+    "a": "a", "aa": "aː", "aaaa": "aːː",
+    "i": "i", "ii": "iː",
+    "u": "u", "uu": "uː",
+}
+
+_MANTOQ_MULTI = ("_dbl_", "_+_", "_sil_", "_eos_", "_pad_",
+                 "aaaa", "aa", "ii", "uu")
+
+
+def _tokenize_mantoq(text: str) -> list[str]:
+    tokens = []
+    i = 0
+    while i < len(text):
+        for sym in _MANTOQ_MULTI:
+            if text.startswith(sym, i):
+                tokens.append(sym)
+                i += len(sym)
+                break
+        else:
+            tokens.append(text[i])
+            i += 1
+    return tokens
+
+
+def mantoq_to_ipa(mantoq: str, errors: str = "pass") -> str:
+    """Convert a Mantoq phoneme string to IPA.
+
+    ``_dbl_`` lengthens/geminates the preceding symbol (``ː``), ``_+_``
+    becomes a space, ``<`` is the glottal stop.  Unknown characters follow
+    the ``errors`` policy.
+
+    Examples
+    --------
+    >>> mantoq_to_ipa("s a l aa m")
+    's a l aː m'
+    >>> mantoq_to_ipa("b_dbl_a")
+    'bːa'
+
+    The inventory's special tokens are honoured: ``_sil_`` becomes a space,
+    ``_eos_``/``_pad_`` are dropped.
+    """
+    out: list[str] = []
+    last_tok = None
+    for pos, tok in enumerate(_tokenize_mantoq(mantoq)):
+        if tok == "_dbl_":
+            # upstream emits _dbl_ only by splitting a doubled CONSONANT
+            # (mantoq buck/tokenization.py: `phon not in vowels and
+            # phon[0] == phon[1]`); geminate it with a length mark.  A
+            # vowel+_dbl_ sequence does not occur in genuine mantoq output
+            # and is left unchanged.
+            if out and last_tok in _MANTOQ_CONSONANTS \
+                    and not out[-1].endswith("ː"):
+                out[-1] += "ː"
+            continue
+        if tok == "_sil_":
+            out.append(" ")
+            last_tok = None
+            continue
+        if tok in ("_eos_", "_pad_"):
+            last_tok = None
+            continue
+        if tok == "_+_":
+            out.append(" ")
+            last_tok = None
+            continue
+        if tok == "<":
+            out.append("ʔ")
+            last_tok = tok
+            continue
+        if tok in _MANTOQ_VOWELS:
+            out.append(_MANTOQ_VOWELS[tok])
+        elif tok in _MANTOQ_CONSONANTS:
+            out.append(_MANTOQ_CONSONANTS[tok])
+        elif tok.isspace() or tok in ".,;:!?()[]{}\"'":
+            out.append(tok)
+            last_tok = None
+            continue
+        else:
+            res = _unknown(tok, pos, "mantoq", errors)
+            if res:
+                out.append(res)
+            last_tok = None
+            continue
+        last_tok = tok
+    return "".join(out)
+
+
 # ---------------------------------------------------------------------------
 # convert — facade routing through IPA where no direct map exists
 # ---------------------------------------------------------------------------
@@ -1069,6 +1180,7 @@ def convert(text: str, src: str | Notation, dst: str | Notation,
 # ---------------------------------------------------------------------------
 
 _TO_IPA: dict[Notation, "callable"] = {
+    Notation.MANTOQ: mantoq_to_ipa,
     Notation.ARPA: arpa_to_ipa,
     Notation.XSAMPA: xsampa_to_ipa,
     Notation.LEXIQUE: lexique_to_ipa,
@@ -1194,6 +1306,12 @@ NOTATION_INFO: dict[Notation, NotationInfo] = {
         token_separated=False,
         reference="RFE phonetic alphabet (Revista de Filología Española, 1915)",
     ),
+    Notation.MANTOQ: NotationInfo(
+        Notation.MANTOQ, lossless_to_ipa=False, lossless_from_ipa=False,
+        token_separated=False,
+        reference="Phonetic alphabet of Nawar Halabi's Arabic-Phonetiser "
+                  "(mantoq G2P inventory); one-directional to IPA",
+    ),
     Notation.BUCKWALTER: NotationInfo(
         Notation.BUCKWALTER, lossless_to_ipa=True, lossless_from_ipa=False,
         token_separated=False,

scriptconv-0.0.3a19/scriptconv/phonemizers/_thirdparty/bw2ipa.py

@@ -0,0 +1,2 @@
+"""Compatibility shim — the Mantoq → IPA converter lives in scriptconv.notation."""
+from scriptconv.notation import mantoq_to_ipa  # noqa: F401

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/scriptconv/phonemizers/enums.py

@@ -27,7 +27,8 @@ class Alphabet(str, Enum):
     ERAAB = "eraab" # fa
     COTOVIA = "cotovia" # gl
     HANZI = "hanzi" # zh
-    BUCKWALTER = "buckwalter" # ar
+    BUCKWALTER = "buckwalter"
+    MANTOQ = "mantoq"  # ar — Halabi Arabic-Phonetiser inventory # ar
     CANGJIE = "cangjie" # zh (Cangjie input method)
     GRAPHEMES = "graphemes"  # plain text / grapheme input (user-side)
 

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/scriptconv/version.py

@@ -2,7 +2,7 @@
 VERSION_MAJOR = 0
 VERSION_MINOR = 0
 VERSION_BUILD = 3
-VERSION_ALPHA = 17
+VERSION_ALPHA = 19
 # END_VERSION_BLOCK
 
 VERSION_STR = f"{VERSION_MAJOR}.{VERSION_MINOR}.{VERSION_BUILD}"

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/scriptconv.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: scriptconv
-Version: 0.0.3a17
+Version: 0.0.3a19
 Summary: Zero-dependency script & phoneme-notation core — ISO-15924 detection & metadata, IPA↔ARPABET/X-SAMPA/Lexique/Kirshenbaum/Cotovía/RFE, Buckwalter↔Arabic, Hangul→jamo, kana
 License: Apache-2.0
 Project-URL: Homepage, https://github.com/TigreGotico/scriptconv
@@ -296,7 +296,8 @@ below describes the per-converter default.
 |----------|----------------------------------|----------------------------------|-------------------------|
 | **ARPABET** | **Lossless with `stress=True`** (digits ↔ IPA `ˈ`/`ˌ` before the stressed vowel; residues: extended-ARPABET `AX` normalises to CMUdict's `AH0` spelling, and `AH0 R` fuses to the r-colored `AXR0` — stable from the IPA side). Default `stress=False` drops digits and merges `AH0`↔`AX` | **Lossy** — ARPABET is an English-only inventory, so any IPA symbol outside it becomes the *unknown* placeholder | `arpa_to_ipa`: passed through unchanged. `ipa_to_arpa`: diacritics and suprasegmentals are dropped; other out-of-inventory symbols follow `errors=` (default `"replace"` → `?`) |
 | **X-SAMPA** | Exact for all canonical symbols | Exact except aliases (`f\`→ɸ, `&`→æ) normalise to their canonical spelling | Passed through unchanged |
-| **Buckwalter ↔ Arabic** | Exact (the `^` shadda alias normalises to canonical `~`; precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Passed through unchanged |
+| **Buckwalter ↔ Arabic** | Exact (precomposed lam-alef ligatures decompose to two chars, visually identical) | Exact | Follows `errors=` (default: passed through) |
+| **Mantoq → IPA** | One-directional (gemination/word markers consumed; no IPA→Mantoq) | — | Follows `errors=` (default: passed through) |
 | **Lexique ↔ IPA** | Exact except the `°`/`3` schwa pair (both → `ə`; reverse always → `°`) | Exact | Passed through unchanged |
 | **Kirshenbaum ↔ IPA** | Exact | **Lossy** — restricted ASCII inventory; IPA outside it passes through | Passed through unchanged |
 | **Cotovía ↔ IPA** | Exact except the three `L`/`Z`/`jj` symbols for `ʎ` normalise to `L` | **Lossy** — Galician/Spanish inventory; IPA outside it passes through | Passed through unchanged |

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/tests/test_notation.py

@@ -365,7 +365,7 @@ _BW_ARABIC_EXTENDED = [
     ("hamza on waw", "&", "ؤ"),
     ("hamza on ya", "}", "ئ"),
     ("alef madda", "|", "آ"),
-    ("shadda", "~", "ّ"),   # "~" is canonical Buckwalter shadda; "^" is an alias
+    ("shadda", "~", "ّ"),   # "~" is the canonical (and only) Buckwalter shadda
     ("fatha", "a", "َ"),
     ("damma", "u", "ُ"),
     ("kasra", "i", "ِ"),
@@ -825,10 +825,11 @@ def test_buckwalter_tatweel():
 
 
 def test_buckwalter_shadda_alias():
-    # Both "~" (canonical) and "^" (alias) map forward to shadda; the reverse
+    # "~" is the only shadda spelling; "^" is NOT Buckwalter (mantoq uses it
+    # for θ) and passes through as an unknown.
     # yields the canonical "~".
     assert buckwalter_to_arabic("~") == "ّ"
-    assert buckwalter_to_arabic("^") == "ّ"
+    assert buckwalter_to_arabic("^") == "^"
     assert arabic_to_buckwalter("ّ") == "~"
 
 
@@ -947,7 +948,7 @@ def test_notation_enum_values():
 
 
 def test_notation_enum_count():
-    assert len(Notation) == 9
+    assert len(Notation) == 10
 
 
 def test_notation_str():
@@ -1148,3 +1149,70 @@ def test_rfe_tap_trill_round_trip():
 def test_convert_routes_through_rfe():
     assert convert("š", "rfe", "x-sampa") == "S"
     assert convert("ʃ", "ipa", "rfe") == "š"
+
+
+# ---------------------------------------------------------------------------
+# Mantoq → IPA (Halabi Arabic-Phonetiser inventory; one-directional)
+# ---------------------------------------------------------------------------
+
+from scriptconv.notation import mantoq_to_ipa, UnknownSymbolError  # noqa: E402
+
+def test_mantoq_basic_word():
+    assert mantoq_to_ipa("salaam") == "salaːm"
+
+
+def test_mantoq_theta_is_caret_not_shadda():
+    # mantoq's "^" is θ — the same character is NOT a Buckwalter shadda here
+    assert mantoq_to_ipa("^") == "θ"
+
+
+def test_mantoq_gemination_marker():
+    assert mantoq_to_ipa("b_dbl_a") == "bːa"
+
+
+def test_mantoq_dbl_after_vowel_is_inert():
+    # upstream only emits _dbl_ after consonants (tokenization.py splits
+    # doubled consonant phonemes); a vowel+_dbl_ input is left unchanged
+    assert mantoq_to_ipa("aa_dbl_") == "aː"
+
+
+def test_mantoq_special_tokens():
+    # inventory special tokens: _sil_ -> pause (space), _eos_/_pad_ dropped —
+    # and never shredded into letter phonemes
+    assert mantoq_to_ipa("m_sil_n") == "m n"
+    assert mantoq_to_ipa("m a_eos_") == "m a"
+    assert mantoq_to_ipa("_pad_b") == "b"
+
+
+def test_mantoq_word_separator_and_glottal():
+    assert mantoq_to_ipa("m_+_<a") == "m ʔa"
+
+
+def test_mantoq_emphatics_and_superlong():
+    assert mantoq_to_ipa("SaaaaD") == "sˤaːːdˤ"
+
+
+def test_mantoq_via_convert_facade():
+    assert convert("salaam", "mantoq", "ipa") == "salaːm"
+    assert can_convert("mantoq", "ipa") is True
+    assert can_convert("ipa", "mantoq") is False
+
+
+def test_mantoq_chains_to_xsampa_via_graph():
+    # mantoq -> ipa -> x-sampa multi-hop through the conversion graph
+    out = convert("salaam", "mantoq", "x-sampa")
+    assert "a:" in out
+
+
+def test_mantoq_errors_strict():
+    import pytest as _pytest
+    with _pytest.raises(UnknownSymbolError):
+        mantoq_to_ipa("Q", errors="strict")
+
+
+def test_buckwalter_wasla_and_dagger_alef():
+    from scriptconv.notation import arabic_to_buckwalter, buckwalter_to_arabic
+    assert buckwalter_to_arabic("{") == "ٱ"
+    assert buckwalter_to_arabic("`") == "ٰ"
+    assert arabic_to_buckwalter("رحمٰن") == "rHm`n"
+    assert arabic_to_buckwalter("ٱ") == "{"

{scriptconv-0.0.3a17 → scriptconv-0.0.3a19}/tests/test_phonemizers_base.py

@@ -23,7 +23,7 @@ class TestEnums(unittest.TestCase):
         self.assertEqual(Phonemizer.KOG2PK.value, "kog2p")
         self.assertEqual(Alphabet.XSAMPA.value, "x-sampa")
         self.assertEqual(len(list(Phonemizer)), 41)
-        self.assertEqual(len(list(Alphabet)), 20)
+        self.assertEqual(len(list(Alphabet)), 21)  # incl. MANTOQ
 
 
 class TestRegistryCompleteness(unittest.TestCase):

scriptconv-0.0.3a17/scriptconv/phonemizers/_thirdparty/bw2ipa.py

@@ -1,207 +0,0 @@
-# translate.py
-# Deterministic Mantoq → IPA converter
-# Assumes the input is already tokenized using the Mantoq inventory.
-
-# ---------------------------------------------------------------------------
-# Token → IPA maps
-# ---------------------------------------------------------------------------
-
-CONSONANTS = {
-    "b":  "b",
-    "t":  "t",
-    "^":  "θ",
-    "j":  "d͡ʒ",
-    "H":  "ħ",
-    "x":  "x",
-    "d":  "d",
-    "*":  "ð",
-    "r":  "r",
-    "z":  "z",
-    "s":  "s",
-    "$":  "ʃ",
-    "S":  "sˤ",
-    "D":  "dˤ",
-    "T":  "tˤ",
-    "Z":  "ðˤ",
-    "E":  "ʕ",
-    "g":  "ɣ",
-    "f":  "f",
-    "q":  "q",
-    "k":  "k",
-    "l":  "l",
-    "m":  "m",
-    "n":  "n",
-    "h":  "h",
-    "w":  "w",
-    "y":  "j",
-    "v":  "v"
-}
-
-VOWELS = {
-    "a":    "a",
-    "aa":   "aː",
-    "aaaa": "aːː",
-    "i":    "i",
-    "ii":   "iː",
-    "u":    "u",
-    "uu":   "uː",
-}
-
-
-# Punctuation is passed through unchanged:
-PUNCTUATION = set(list(".,;:!?()[]{}\"'"))
-
-# ---------------------------------------------------------------------------
-# Tokenizer
-# ---------------------------------------------------------------------------
-
-def tokenize_mantoq(text):
-    """
-    Tokenize Mantoq string deterministically.
-
-    Priority:
-        1. _dbl_
-        2. aaaa
-        3. ii / uu / aa
-        4. single char tokens
-        5. punctuation and raw chars are passed through
-    """
-    tokens = []
-    i = 0
-    L = len(text)
-
-    while i < L:
-
-        # doubling marker
-        if text.startswith("_dbl_", i):
-            tokens.append("_dbl_")
-            i += 5
-            continue
-
-        # word separator
-        if text.startswith("_+_", i):
-            tokens.append("_+_")
-            i += 3
-            continue
-
-        # longest vowel first
-        if text.startswith("aaaa", i):
-            tokens.append("aaaa")
-            i += 4
-            continue
-
-        if text.startswith("aa", i):
-            tokens.append("aa")
-            i += 2
-            continue
-
-        if text.startswith("ii", i):
-            tokens.append("ii")
-            i += 2
-            continue
-
-        if text.startswith("uu", i):
-            tokens.append("uu")
-            i += 2
-            continue
-
-        # single-character consonant or vowel
-        ch = text[i]
-
-        if ch in CONSONANTS or ch in VOWELS:
-            tokens.append(ch)
-            i += 1
-            continue
-        if ch == "<":
-            tokens.append("ʔ")
-            i += 1
-            continue
-
-        # punctuation
-        if ch in PUNCTUATION:
-            tokens.append(ch)
-            i += 1
-            continue
-
-        # fallback: pass through unknown characters
-        tokens.append(ch)
-        i += 1
-
-    return tokens
-
-# ---------------------------------------------------------------------------
-# IPA Assembly
-# ---------------------------------------------------------------------------
-
-def apply_doubling(prev_token, prev_ipa):
-    """
-    Mantoq doubling rule:
-       - If previous token is a vowel token: lengthen it.
-       - If previous token is a consonant: mark gemination using ː.
-    """
-    if prev_token in VOWELS:
-        # ensure single long marker; long tokens already contain ː
-        if prev_ipa.endswith("ː"):
-            return prev_ipa + "ː"
-        return prev_ipa + "ː"
-
-    if prev_token in CONSONANTS:
-        # consonant gemination: use length mark, not duplication
-        if prev_ipa.endswith("ː"):
-            return prev_ipa  # already geminated
-        return prev_ipa + "ː"
-
-    return prev_ipa
-
-
-def mantoq_to_ipa(text):
-    tokens = tokenize_mantoq(text)
-
-    ipa_out = []
-    last_token = None
-    last_ipa = None
-
-    for tok in tokens:
-
-        # doubling applies to the previous symbol
-        if tok == "_dbl_":
-            if last_token is None:
-                continue
-            new_ipa = apply_doubling(last_token, last_ipa)
-            ipa_out[-1] = new_ipa
-            last_ipa = new_ipa
-            continue
-
-        # explicit word separation
-        if tok == "_+_":
-            ipa_out.append(" ")
-            last_token = tok
-            last_ipa = " "
-            continue
-
-        # vowels
-        if tok in VOWELS:
-            ipa_val = VOWELS[tok]
-            ipa_out.append(ipa_val)
-            last_token = tok
-            last_ipa = ipa_val
-            continue
-
-        # consonants
-        if tok in CONSONANTS:
-            ipa_val = CONSONANTS[tok]
-            ipa_out.append(ipa_val)
-            last_token = tok
-            last_ipa = ipa_val
-            continue
-
-        # punctuation and fallthrough
-        ipa_out.append(tok)
-        last_token = tok
-        last_ipa = tok
-
-    return "".join(ipa_out)
-
-
-# backwards compat alias
-bw2ipa = mantoq_to_ipa