axorn 0.1.0__tar.gz

axorn-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Korakot Chaovavanich
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

axorn-0.1.0/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: axorn
+Version: 0.1.0
+Summary: Pāli script converter, roman ↔ Thai, for Python and JS from one shared table
+License-Expression: MIT
+Project-URL: Repository, https://github.com/korakot/axorn
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# axorn
+
+**English** | [ไทย](README.th.md)
+
+Pāli script converter, roman ↔ Thai (อักษร), for Python and JS from one shared table.
+
+Pāli has no script of its own, so the same text is written in roman (*evaṃ me sutaṃ*) and in Thai script (เอวํ เม สุตํ). axorn converts between the two, both ways, and gives exactly the same output in Python (for backends) and JS (for web pages). It follows the conventions of the VRI Tipiṭaka (tipitaka.org), and is tested against VRI's own files.
+
+## Use
+
+**Try it in the browser:** <https://korakot.github.io/axorn/> — paste roman or Thai and the other follows as you type. It runs the same `axorn.js`, entirely in your browser.
+
+Python:
+
+```python
+from axorn import roman_to_thai, thai_to_roman
+
+roman_to_thai("Evaṃ me sutaṃ.")   # 'เอวํ เม สุตํฯ'
+thai_to_roman("เอวํ เม สุตํฯ")     # 'evaṃ me sutaṃ.'
+```
+
+JavaScript (ES module, Node 22+ or a recent browser):
+
+```js
+import { romanToThai, thaiToRoman } from "./axorn/axorn.js";
+
+romanToThai("Evaṃ me sutaṃ.");  // "เอวํ เม สุตํฯ"
+thaiToRoman("เอวํ เม สุตํฯ");    // "evaṃ me sutaṃ."
+```
+
+Command line: `python3 -m axorn thai < roman.txt > thai.txt` (or `roman` for the other way).
+
+Options:
+
+- `ue` (roman → Thai): write -iṃ as ึ, as many Thai prints do (กึ), instead of VRI's ิํ (กิํ).
+- `punct` (both ways, on by default): convert digits (12 ↔ ๑๒) and full stops (. ↔ ฯ). Turn it off to convert letters only.
+
+## Conventions
+
+Thai-script Pāli is written in more than one way. axorn writes the VRI way and reads all the common ones:
+
+| | axorn writes (VRI) | axorn also reads |
+|---|---|---|
+| -iṃ, e.g. *kiṃ* | กิํ | กึ |
+| e/o before a consonant cluster, e.g. *tumhe* | ตุมฺเห (before the last consonant) | ตุเมฺห (before the whole cluster) |
+| *ṭ* | ฏ | ฎ |
+| virama (the dot under a consonant) | ฺ (phinthu) | ๎ (yamakkan) |
+| niggahita | ṃ | ṁ, ŋ in roman input |
+
+Two Pāli facts the converter relies on:
+
+- **a + i and a + u are two vowels.** Pāli has no *ai* or *au* diphthong, so *sauddesaṃ* (sa-uddesaṃ) is สอุทฺเทสํ, not เสาทฺเทสํ.
+- **A vowel that starts a syllable takes อ**, e.g. *okkāka* → โอกฺกาก.
+
+**Full stops.** VRI's master text is in Devanagari, which has two marks where roman has one dot. The full stop (।) is ฯ in Thai, while the abbreviation sign (॰) stays "." in Thai, as in *dī. ni.* (ที. นิ.). Going roman → Thai, axorn treats a dot as an abbreviation when it:
+
+- touches a digit ("12.", "1.7");
+- sits inside parentheses;
+- comes before ")" or ",";
+- is followed by a number or another short abbreviation;
+- or ends a chain of them ("sī. pī. potthakesu").
+
+Every other dot is a full stop. The elision mark *…pe…* is written …เป.… in Thai.
+
+Thai has no capital letters, so Thai → roman returns lower case.
+
+## Tested on
+
+`tests/vri_check.py` converts every paragraph of a VRI book roman → Thai and Thai → roman, compares each with VRI's file in the other script, and checks that Python and JS agree. On 14 Oct 2026:
+
+| Book | Paragraphs | Words | Mismatches (of 2 × paragraphs) |
+|---|---:|---:|---:|
+| Dīgha Nikāya 1 (s0101m) | 1,046 | 45,891 | 2 |
+| DN 1 commentary (s0101a) | 1,477 | 61,232 | 4 |
+| Jātaka verses 1 (s0513m) | 10,473 | 53,074 | 6 |
+| Majjhima Nikāya 1 (s0201m) | 1,785 | 85,305 | 5 |
+| Dhammasaṅgaṇī (abh01m) | 2,436 | 53,189 | 2 |
+| Vinaya, Pārājika (vin01m) | 2,465 | 72,253 | 4 |
+
+Python and JS gave identical output on all of them, and every letter matched. The 23 mismatches are all punctuation and spacing, most of them inconsistencies inside VRI's own files. For example, the Thai file has a ฯ before the *Namo tassa* title that the roman file lacks, and *…pe…* is sometimes written …เป… without the dot.
+
+Running the tests:
+
+```
+python3 tests/test_cases.py            # 18 fixed cases, Python and JS
+git clone --depth 1 --filter=blob:none --sparse https://github.com/VipassanaTech/tipitaka-xml vri
+git -C vri sparse-checkout set --no-cone /romn/s0101m.mul.xml /thai/s0101m.mul.xml
+python3 tests/vri_check.py vri s0101m.mul
+```
+
+## Design
+
+`axorn/thai.json` holds the letters: consonants, vowels (with their position before or after the consonant), virama, niggahita, digits and punctuation. `__init__.py` and `axorn.js` both read it and mirror each other line for line, so a fix to the table reaches both languages at once.
+
+Roman is the hub. Other scripts (Myanmar, Sinhala, …) can be added later as one table each, and any script → any script goes through roman. The reasoning, history and plan are in [wiki/](wiki/index.md).
+
+## Credits
+
+axorn was written by Claude (Anthropic) for Korakot Chaovavanich in 2026. Its design builds on Korakot's 2018 notebook, a Python port of the [pitaka.lk](https://pitaka.lk/converter.html) JavaScript converter. Two ideas carry over from it: spelling each Thai syllable from a consonant + vowel pair, with เ/โ placed before the consonant, and the consonant table itself. Korakot's notebook already matched VRI exactly on DN 1, letter for letter.
+
+[Aksharamukha](https://github.com/virtualvinodh/aksharamukha-python) served as a cross-check during development.
+
+## License
+
+MIT

axorn-0.1.0/README.md

@@ -0,0 +1,105 @@
+# axorn
+
+**English** | [ไทย](README.th.md)
+
+Pāli script converter, roman ↔ Thai (อักษร), for Python and JS from one shared table.
+
+Pāli has no script of its own, so the same text is written in roman (*evaṃ me sutaṃ*) and in Thai script (เอวํ เม สุตํ). axorn converts between the two, both ways, and gives exactly the same output in Python (for backends) and JS (for web pages). It follows the conventions of the VRI Tipiṭaka (tipitaka.org), and is tested against VRI's own files.
+
+## Use
+
+**Try it in the browser:** <https://korakot.github.io/axorn/> — paste roman or Thai and the other follows as you type. It runs the same `axorn.js`, entirely in your browser.
+
+Python:
+
+```python
+from axorn import roman_to_thai, thai_to_roman
+
+roman_to_thai("Evaṃ me sutaṃ.")   # 'เอวํ เม สุตํฯ'
+thai_to_roman("เอวํ เม สุตํฯ")     # 'evaṃ me sutaṃ.'
+```
+
+JavaScript (ES module, Node 22+ or a recent browser):
+
+```js
+import { romanToThai, thaiToRoman } from "./axorn/axorn.js";
+
+romanToThai("Evaṃ me sutaṃ.");  // "เอวํ เม สุตํฯ"
+thaiToRoman("เอวํ เม สุตํฯ");    // "evaṃ me sutaṃ."
+```
+
+Command line: `python3 -m axorn thai < roman.txt > thai.txt` (or `roman` for the other way).
+
+Options:
+
+- `ue` (roman → Thai): write -iṃ as ึ, as many Thai prints do (กึ), instead of VRI's ิํ (กิํ).
+- `punct` (both ways, on by default): convert digits (12 ↔ ๑๒) and full stops (. ↔ ฯ). Turn it off to convert letters only.
+
+## Conventions
+
+Thai-script Pāli is written in more than one way. axorn writes the VRI way and reads all the common ones:
+
+| | axorn writes (VRI) | axorn also reads |
+|---|---|---|
+| -iṃ, e.g. *kiṃ* | กิํ | กึ |
+| e/o before a consonant cluster, e.g. *tumhe* | ตุมฺเห (before the last consonant) | ตุเมฺห (before the whole cluster) |
+| *ṭ* | ฏ | ฎ |
+| virama (the dot under a consonant) | ฺ (phinthu) | ๎ (yamakkan) |
+| niggahita | ṃ | ṁ, ŋ in roman input |
+
+Two Pāli facts the converter relies on:
+
+- **a + i and a + u are two vowels.** Pāli has no *ai* or *au* diphthong, so *sauddesaṃ* (sa-uddesaṃ) is สอุทฺเทสํ, not เสาทฺเทสํ.
+- **A vowel that starts a syllable takes อ**, e.g. *okkāka* → โอกฺกาก.
+
+**Full stops.** VRI's master text is in Devanagari, which has two marks where roman has one dot. The full stop (।) is ฯ in Thai, while the abbreviation sign (॰) stays "." in Thai, as in *dī. ni.* (ที. นิ.). Going roman → Thai, axorn treats a dot as an abbreviation when it:
+
+- touches a digit ("12.", "1.7");
+- sits inside parentheses;
+- comes before ")" or ",";
+- is followed by a number or another short abbreviation;
+- or ends a chain of them ("sī. pī. potthakesu").
+
+Every other dot is a full stop. The elision mark *…pe…* is written …เป.… in Thai.
+
+Thai has no capital letters, so Thai → roman returns lower case.
+
+## Tested on
+
+`tests/vri_check.py` converts every paragraph of a VRI book roman → Thai and Thai → roman, compares each with VRI's file in the other script, and checks that Python and JS agree. On 14 Oct 2026:
+
+| Book | Paragraphs | Words | Mismatches (of 2 × paragraphs) |
+|---|---:|---:|---:|
+| Dīgha Nikāya 1 (s0101m) | 1,046 | 45,891 | 2 |
+| DN 1 commentary (s0101a) | 1,477 | 61,232 | 4 |
+| Jātaka verses 1 (s0513m) | 10,473 | 53,074 | 6 |
+| Majjhima Nikāya 1 (s0201m) | 1,785 | 85,305 | 5 |
+| Dhammasaṅgaṇī (abh01m) | 2,436 | 53,189 | 2 |
+| Vinaya, Pārājika (vin01m) | 2,465 | 72,253 | 4 |
+
+Python and JS gave identical output on all of them, and every letter matched. The 23 mismatches are all punctuation and spacing, most of them inconsistencies inside VRI's own files. For example, the Thai file has a ฯ before the *Namo tassa* title that the roman file lacks, and *…pe…* is sometimes written …เป… without the dot.
+
+Running the tests:
+
+```
+python3 tests/test_cases.py            # 18 fixed cases, Python and JS
+git clone --depth 1 --filter=blob:none --sparse https://github.com/VipassanaTech/tipitaka-xml vri
+git -C vri sparse-checkout set --no-cone /romn/s0101m.mul.xml /thai/s0101m.mul.xml
+python3 tests/vri_check.py vri s0101m.mul
+```
+
+## Design
+
+`axorn/thai.json` holds the letters: consonants, vowels (with their position before or after the consonant), virama, niggahita, digits and punctuation. `__init__.py` and `axorn.js` both read it and mirror each other line for line, so a fix to the table reaches both languages at once.
+
+Roman is the hub. Other scripts (Myanmar, Sinhala, …) can be added later as one table each, and any script → any script goes through roman. The reasoning, history and plan are in [wiki/](wiki/index.md).
+
+## Credits
+
+axorn was written by Claude (Anthropic) for Korakot Chaovavanich in 2026. Its design builds on Korakot's 2018 notebook, a Python port of the [pitaka.lk](https://pitaka.lk/converter.html) JavaScript converter. Two ideas carry over from it: spelling each Thai syllable from a consonant + vowel pair, with เ/โ placed before the consonant, and the consonant table itself. Korakot's notebook already matched VRI exactly on DN 1, letter for letter.
+
+[Aksharamukha](https://github.com/virtualvinodh/aksharamukha-python) served as a cross-check during development.
+
+## License
+
+MIT

axorn-0.1.0/axorn/__init__.py

@@ -0,0 +1,164 @@
+"""axorn — Pāli script converter, roman ↔ Thai.
+
+    >>> from axorn import roman_to_thai, thai_to_roman
+    >>> roman_to_thai("Evaṃ me sutaṃ.")
+    'เอวํ เม สุตํฯ'
+    >>> thai_to_roman("เอวํ เม สุตํฯ")
+    'evaṃ me sutaṃ.'
+
+Both directions read the same table (thai.json), which axorn.js also
+reads, so the Python and JS versions give the same output.
+The defaults follow the VRI (tipitaka.org) Thai edition; see README.md.
+"""
+import json
+import re
+import unicodedata
+from pathlib import Path
+
+__all__ = ["roman_to_thai", "thai_to_roman"]
+
+_T = json.loads((Path(__file__).with_name("thai.json")).read_text(encoding="utf-8"))
+
+_R2T_CONS = {r: t for r, t in _T["consonants"]}
+_T2R_CONS = {t: r for r, t in _T["consonants"]} | _T["consonants_thai_alt"]
+_R2T_VOW = {r: (pre, post) for r, pre, post in _T["vowels"]}
+_PRE = {pre: r for r, pre, post in _T["vowels"] if pre}      # เ -> e
+_POST = {post: r for r, pre, post in _T["vowels"] if post}   # า -> ā
+_CARRIER = _T["vowel_carrier"]
+_VIRAMA = _T["virama"]
+_VIRAMAS = {_VIRAMA, *_T["virama_thai_alt"]}
+_NIG_R, _NIG_T = _T["niggahita"]
+_NIG_R_ALL = [_NIG_R, *_T["niggahita_roman_alt"]]
+_UE = _T["i_niggahita_ligature"]
+_DIG_R, _DIG_T = _T["digits"]
+_STOP_R, _STOP_T = _T["full_stop"]
+_PE_R, _PE_T = _T["peyyala"]  # the elision mark "…pe…", also "… pe…"
+_PE_RE_R = re.compile(r"(…\s?)" + re.escape(_PE_R))
+_PE_RE_T = re.compile(r"(…\s?)" + re.escape(_PE_T))
+
+# Longest letters first, so "kh" wins over "k".
+_letters = sorted([*_R2T_CONS, *_R2T_VOW, *_NIG_R_ALL], key=len, reverse=True)
+_R_TOKEN = re.compile("|".join(map(re.escape, _letters)) + "|.", re.S)
+
+
+def roman_to_thai(text: str, *, ue: bool = False, punct: bool = True) -> str:
+    """Roman Pāli -> Thai script.
+
+    ue    -- write -iṃ as ึ (common in Thai prints) instead of ิํ (VRI).
+    punct -- digits -> Thai digits, and a sentence-ending full stop -> ฯ
+             (abbreviation dots stay "."; see _thai_punct).
+    """
+    text = unicodedata.normalize("NFC", text).lower()
+    if punct:
+        text = _thai_punct(text)
+    toks = _R_TOKEN.findall(text)
+    out = []
+    i = 0
+    while i < len(toks):
+        tok = toks[i]
+        if tok in _R2T_CONS:
+            nxt = toks[i + 1] if i + 1 < len(toks) else ""
+            if nxt in _R2T_VOW:
+                pre, post = _R2T_VOW[nxt]
+                out.append(pre + _R2T_CONS[tok] + post)
+                i += 1
+            else:
+                out.append(_R2T_CONS[tok] + _VIRAMA)
+        elif tok in _R2T_VOW:
+            pre, post = _R2T_VOW[tok]
+            out.append(pre + _CARRIER + post)
+        elif tok in _NIG_R_ALL:
+            if ue and out and out[-1].endswith("ิ"):
+                out[-1] = out[-1][:-1] + _UE
+            else:
+                out.append(_NIG_T)
+        else:
+            out.append(tok)
+        i += 1
+    return "".join(out)
+
+
+_NEXT_IS_ABBREV = re.compile(r"\s*\d|\s+[^\W\d_]{1,4}\.")
+_PREV_IS_ABBREV = re.compile(r"[\s(][^\W\d_]{1,4}\.\s+[^\W\d_]{1,4}$")
+
+
+def _thai_punct(s: str) -> str:
+    """Roman "." is two marks in VRI's Devanagari master: a full stop (।),
+    written ฯ in Thai, and an abbreviation sign (॰), kept as "." in Thai.
+    A dot counts as an abbreviation when it touches a digit ("12.", "1.7"),
+    sits inside parentheses ("(sī. syā.)"), comes before ")" or ",", or is
+    followed by a number or another short abbreviation ("dī. ni. 1.1"),
+    or ends a chain of them ("sī. pī. potthakesu").
+    Every other dot is a full stop."""
+    out = []
+    depth = 0
+    for i, c in enumerate(s):
+        if c == "(":
+            depth += 1
+        elif c == ")":
+            depth = max(depth - 1, 0)
+        if c in _DIG_R:
+            out.append(_DIG_T[_DIG_R.index(c)])
+        elif c == _STOP_R:
+            prev = s[i - 1] if i else ""
+            nxt = s[i + 1] if i + 1 < len(s) else ""
+            abbrev = (prev.isdigit() or nxt.isdigit() or (nxt != "" and nxt in "),")
+                      or depth > 0 or _NEXT_IS_ABBREV.match(s, i + 1)
+                      or _PREV_IS_ABBREV.search((" " if i < 30 else "") + s[max(0, i - 30):i]))
+            out.append(_STOP_R if abbrev else _STOP_T)
+        else:
+            out.append(c)
+    return _PE_RE_R.sub(lambda m: m.group(1) + _PE_T, "".join(out))
+
+
+def thai_to_roman(text: str, *, punct: bool = True) -> str:
+    """Thai-script Pāli -> roman (lower case; Thai has no capitals).
+
+    Reads both conventions for -iṃ (ิํ and ึ) and both placements of
+    เ/โ in a cluster (ตุมฺเห and ตุเมฺห).
+    punct -- Thai digits -> 0-9, and ฯ -> full stop.
+    """
+    if punct:
+        text = _PE_RE_T.sub(lambda m: m.group(1) + _PE_R, text)
+    out = []
+    pending = ""  # a prefix vowel (เ/โ) waiting for its consonant
+    n = len(text)
+    i = 0
+    while i < n:
+        c = text[i]
+        if c in _PRE:
+            pending = _PRE[c]
+        elif c in _T2R_CONS or c == _CARRIER:
+            base = _T2R_CONS.get(c, "")
+            nxt = text[i + 1] if i + 1 < n else ""
+            if nxt in _VIRAMAS:
+                out.append(base)       # pending vowel belongs to a later consonant
+                i += 1
+            elif nxt in _POST:
+                out.append(base + _POST[nxt])
+                pending = ""
+                i += 1
+            elif nxt == _UE:
+                out.append(base + "i" + _NIG_R)
+                pending = ""
+                i += 1
+            else:
+                out.append(base + (pending or "a"))
+                pending = ""
+        else:
+            if pending:                # a stray เ/โ with no consonant after it
+                out.append(pending)
+                pending = ""
+            if c == _NIG_T:
+                out.append(_NIG_R)
+            elif punct and c in _DIG_T:
+                out.append(_DIG_R[_DIG_T.index(c)])
+            elif punct and c == _STOP_T:
+                out.append(_STOP_R)
+            else:
+                out.append(c)
+        i += 1
+    if pending:
+        out.append(pending)
+    return "".join(out)
+

axorn-0.1.0/axorn/__main__.py

@@ -0,0 +1,6 @@
+"""python3 -m axorn thai < roman.txt > thai.txt   (or: roman)"""
+import sys
+from . import roman_to_thai, thai_to_roman
+
+f = {"thai": roman_to_thai, "roman": thai_to_roman}[sys.argv[1]]
+sys.stdout.write(f(sys.stdin.read()))

axorn-0.1.0/axorn/thai.json

@@ -0,0 +1,25 @@
+{
+  "about": "Pāli letters in roman and Thai script. The single source of truth for __init__.py and axorn.js. Roman is the hub: one table per script.",
+  "consonants": [
+    ["k", "ก"], ["kh", "ข"], ["g", "ค"], ["gh", "ฆ"], ["ṅ", "ง"],
+    ["c", "จ"], ["ch", "ฉ"], ["j", "ช"], ["jh", "ฌ"], ["ñ", "ญ"],
+    ["ṭ", "ฏ"], ["ṭh", "ฐ"], ["ḍ", "ฑ"], ["ḍh", "ฒ"], ["ṇ", "ณ"],
+    ["t", "ต"], ["th", "ถ"], ["d", "ท"], ["dh", "ธ"], ["n", "น"],
+    ["p", "ป"], ["ph", "ผ"], ["b", "พ"], ["bh", "ภ"], ["m", "ม"],
+    ["y", "ย"], ["r", "ร"], ["l", "ล"], ["v", "ว"], ["s", "ส"], ["h", "ห"], ["ḷ", "ฬ"]
+  ],
+  "consonants_thai_alt": {"ฎ": "ṭ"},
+  "vowels": [
+    ["a", "", ""], ["ā", "", "า"], ["i", "", "ิ"], ["ī", "", "ี"],
+    ["u", "", "ุ"], ["ū", "", "ู"], ["e", "เ", ""], ["o", "โ", ""]
+  ],
+  "vowel_carrier": "อ",
+  "virama": "ฺ",
+  "virama_thai_alt": ["๎"],
+  "niggahita": ["ṃ", "ํ"],
+  "niggahita_roman_alt": ["ṁ", "ŋ"],
+  "i_niggahita_ligature": "ึ",
+  "digits": ["0123456789", "๐๑๒๓๔๕๖๗๘๙"],
+  "full_stop": [".", "ฯ"],
+  "peyyala": ["pe…", "เป.…"]
+}

axorn-0.1.0/axorn.egg-info/PKG-INFO

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: axorn
+Version: 0.1.0
+Summary: Pāli script converter, roman ↔ Thai, for Python and JS from one shared table
+License-Expression: MIT
+Project-URL: Repository, https://github.com/korakot/axorn
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# axorn
+
+**English** | [ไทย](README.th.md)
+
+Pāli script converter, roman ↔ Thai (อักษร), for Python and JS from one shared table.
+
+Pāli has no script of its own, so the same text is written in roman (*evaṃ me sutaṃ*) and in Thai script (เอวํ เม สุตํ). axorn converts between the two, both ways, and gives exactly the same output in Python (for backends) and JS (for web pages). It follows the conventions of the VRI Tipiṭaka (tipitaka.org), and is tested against VRI's own files.
+
+## Use
+
+**Try it in the browser:** <https://korakot.github.io/axorn/> — paste roman or Thai and the other follows as you type. It runs the same `axorn.js`, entirely in your browser.
+
+Python:
+
+```python
+from axorn import roman_to_thai, thai_to_roman
+
+roman_to_thai("Evaṃ me sutaṃ.")   # 'เอวํ เม สุตํฯ'
+thai_to_roman("เอวํ เม สุตํฯ")     # 'evaṃ me sutaṃ.'
+```
+
+JavaScript (ES module, Node 22+ or a recent browser):
+
+```js
+import { romanToThai, thaiToRoman } from "./axorn/axorn.js";
+
+romanToThai("Evaṃ me sutaṃ.");  // "เอวํ เม สุตํฯ"
+thaiToRoman("เอวํ เม สุตํฯ");    // "evaṃ me sutaṃ."
+```
+
+Command line: `python3 -m axorn thai < roman.txt > thai.txt` (or `roman` for the other way).
+
+Options:
+
+- `ue` (roman → Thai): write -iṃ as ึ, as many Thai prints do (กึ), instead of VRI's ิํ (กิํ).
+- `punct` (both ways, on by default): convert digits (12 ↔ ๑๒) and full stops (. ↔ ฯ). Turn it off to convert letters only.
+
+## Conventions
+
+Thai-script Pāli is written in more than one way. axorn writes the VRI way and reads all the common ones:
+
+| | axorn writes (VRI) | axorn also reads |
+|---|---|---|
+| -iṃ, e.g. *kiṃ* | กิํ | กึ |
+| e/o before a consonant cluster, e.g. *tumhe* | ตุมฺเห (before the last consonant) | ตุเมฺห (before the whole cluster) |
+| *ṭ* | ฏ | ฎ |
+| virama (the dot under a consonant) | ฺ (phinthu) | ๎ (yamakkan) |
+| niggahita | ṃ | ṁ, ŋ in roman input |
+
+Two Pāli facts the converter relies on:
+
+- **a + i and a + u are two vowels.** Pāli has no *ai* or *au* diphthong, so *sauddesaṃ* (sa-uddesaṃ) is สอุทฺเทสํ, not เสาทฺเทสํ.
+- **A vowel that starts a syllable takes อ**, e.g. *okkāka* → โอกฺกาก.
+
+**Full stops.** VRI's master text is in Devanagari, which has two marks where roman has one dot. The full stop (।) is ฯ in Thai, while the abbreviation sign (॰) stays "." in Thai, as in *dī. ni.* (ที. นิ.). Going roman → Thai, axorn treats a dot as an abbreviation when it:
+
+- touches a digit ("12.", "1.7");
+- sits inside parentheses;
+- comes before ")" or ",";
+- is followed by a number or another short abbreviation;
+- or ends a chain of them ("sī. pī. potthakesu").
+
+Every other dot is a full stop. The elision mark *…pe…* is written …เป.… in Thai.
+
+Thai has no capital letters, so Thai → roman returns lower case.
+
+## Tested on
+
+`tests/vri_check.py` converts every paragraph of a VRI book roman → Thai and Thai → roman, compares each with VRI's file in the other script, and checks that Python and JS agree. On 14 Oct 2026:
+
+| Book | Paragraphs | Words | Mismatches (of 2 × paragraphs) |
+|---|---:|---:|---:|
+| Dīgha Nikāya 1 (s0101m) | 1,046 | 45,891 | 2 |
+| DN 1 commentary (s0101a) | 1,477 | 61,232 | 4 |
+| Jātaka verses 1 (s0513m) | 10,473 | 53,074 | 6 |
+| Majjhima Nikāya 1 (s0201m) | 1,785 | 85,305 | 5 |
+| Dhammasaṅgaṇī (abh01m) | 2,436 | 53,189 | 2 |
+| Vinaya, Pārājika (vin01m) | 2,465 | 72,253 | 4 |
+
+Python and JS gave identical output on all of them, and every letter matched. The 23 mismatches are all punctuation and spacing, most of them inconsistencies inside VRI's own files. For example, the Thai file has a ฯ before the *Namo tassa* title that the roman file lacks, and *…pe…* is sometimes written …เป… without the dot.
+
+Running the tests:
+
+```
+python3 tests/test_cases.py            # 18 fixed cases, Python and JS
+git clone --depth 1 --filter=blob:none --sparse https://github.com/VipassanaTech/tipitaka-xml vri
+git -C vri sparse-checkout set --no-cone /romn/s0101m.mul.xml /thai/s0101m.mul.xml
+python3 tests/vri_check.py vri s0101m.mul
+```
+
+## Design
+
+`axorn/thai.json` holds the letters: consonants, vowels (with their position before or after the consonant), virama, niggahita, digits and punctuation. `__init__.py` and `axorn.js` both read it and mirror each other line for line, so a fix to the table reaches both languages at once.
+
+Roman is the hub. Other scripts (Myanmar, Sinhala, …) can be added later as one table each, and any script → any script goes through roman. The reasoning, history and plan are in [wiki/](wiki/index.md).
+
+## Credits
+
+axorn was written by Claude (Anthropic) for Korakot Chaovavanich in 2026. Its design builds on Korakot's 2018 notebook, a Python port of the [pitaka.lk](https://pitaka.lk/converter.html) JavaScript converter. Two ideas carry over from it: spelling each Thai syllable from a consonant + vowel pair, with เ/โ placed before the consonant, and the consonant table itself. Korakot's notebook already matched VRI exactly on DN 1, letter for letter.
+
+[Aksharamukha](https://github.com/virtualvinodh/aksharamukha-python) served as a cross-check during development.
+
+## License
+
+MIT

axorn-0.1.0/axorn.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+LICENSE
+README.md
+pyproject.toml
+axorn/__init__.py
+axorn/__main__.py
+axorn/thai.json
+axorn.egg-info/PKG-INFO
+axorn.egg-info/SOURCES.txt
+axorn.egg-info/dependency_links.txt
+axorn.egg-info/top_level.txt
+tests/test_cases.py

axorn-0.1.0/axorn.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

axorn-0.1.0/axorn.egg-info/top_level.txt

@@ -0,0 +1 @@
+axorn

axorn-0.1.0/pyproject.toml

@@ -0,0 +1,20 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "axorn"
+version = "0.1.0"
+description = "Pāli script converter, roman ↔ Thai, for Python and JS from one shared table"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+
+[project.urls]
+Repository = "https://github.com/korakot/axorn"
+
+[tool.setuptools]
+packages = ["axorn"]
+
+[tool.setuptools.package-data]
+axorn = ["thai.json"]

axorn-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

axorn-0.1.0/tests/test_cases.py

@@ -0,0 +1,37 @@
+"""Fixed cases from tests/cases.json, run on both Python and JS.  python3 tests/test_cases.py"""
+import json, subprocess, sys
+from pathlib import Path
+HERE = Path(__file__).resolve().parent
+sys.path.insert(0, str(HERE.parent))
+from axorn import roman_to_thai, thai_to_roman
+
+JS = """
+import { romanToThai, thaiToRoman } from "../axorn/axorn.js";
+import cases from "./cases.json" with { type: "json" };
+console.log(JSON.stringify(cases.map(c => [
+  romanToThai(c.roman, { ue: !!c.ue }), thaiToRoman(c.thai)])));
+"""
+
+def main():
+    cases = json.loads((HERE / "cases.json").read_text(encoding="utf-8"))
+    tmp = HERE / "_cases_run.mjs"
+    tmp.write_text(JS, encoding="utf-8")
+    try:
+        js = json.loads(subprocess.run(["node", str(tmp)], capture_output=True, text=True, check=True).stdout)
+    finally:
+        tmp.unlink()
+    fails = 0
+    for c, (js_t, js_r) in zip(cases, js):
+        checks = []
+        if not c.get("reverse_only"):
+            checks += [("py r→t", roman_to_thai(c["roman"], ue=c.get("ue", False)), c["thai"]), ("js r→t", js_t, c["thai"])]
+        if not c.get("oneway"):
+            checks += [("py t→r", thai_to_roman(c["thai"]), c["roman"]), ("js t→r", js_r, c["roman"])]
+        for name, got, want in checks:
+            if got != want:
+                fails += 1
+                print(f"FAIL {name}: {got!r} != {want!r}  ({c.get('note', '')})")
+    print(f"{len(cases)} cases, {fails} failures")
+    sys.exit(1 if fails else 0)
+
+main()