@kensio/pinyinjs 0.1.0-beta.0 → 1.0.0

package/dist/transcription/ipa.js

@@ -0,0 +1,221 @@
+import { NEUTRAL_TONE, toneFromNotation } from "../tone/tone.js";
+import { indexInventory, readIndexed } from "./spelling-index.js";
+/**
+ * The symbol each initial is transcribed with.
+ *
+ * The aspiration series is where pinyin's letters mislead most: pinyin b is
+ * [p], and pinyin p is [pʰ]. Nothing in Mandarin is voiced here, which is what
+ * both Wade-Giles and Yale are working around in their own directions.
+ */
+const INITIAL_SYMBOLS = new Map([
+    ["b", "p"],
+    ["p", "pʰ"],
+    ["m", "m"],
+    ["f", "f"],
+    ["d", "t"],
+    ["t", "tʰ"],
+    ["n", "n"],
+    ["l", "l"],
+    ["g", "k"],
+    ["k", "kʰ"],
+    ["h", "x"],
+    ["j", "tɕ"],
+    ["q", "tɕʰ"],
+    ["x", "ɕ"],
+    ["zh", "ʈʂ"],
+    ["ch", "ʈʂʰ"],
+    ["sh", "ʂ"],
+    ["r", "ʐ"],
+    ["z", "ts"],
+    ["c", "tsʰ"],
+    ["s", "s"],
+]);
+/**
+ * The symbols each final is transcribed with.
+ *
+ * The vowels are where the transcription and the spelling part company: pinyin
+ * writes one e for [ɤ], [ə] and [ɛ], and one i for [i] and [ɨ], because a
+ * spelling can let the context do the work and a transcription cannot. 天 tiān
+ * is [tʰiɛn] and 恩 ēn is [ən].
+ */
+const FINAL_SYMBOLS = {
+    a: "a",
+    o: "ɔ",
+    e: "ɤ",
+    ê: "ɛ",
+    er: "aɚ",
+    ai: "ai",
+    ei: "ei",
+    ao: "au",
+    ou: "ou",
+    an: "an",
+    en: "ən",
+    ang: "aŋ",
+    eng: "əŋ",
+    ong: "ʊŋ",
+    i: "i",
+    ia: "ia",
+    io: "iɔ",
+    ie: "ie",
+    iao: "iau",
+    iou: "iou",
+    ian: "iɛn",
+    in: "in",
+    iang: "iaŋ",
+    ing: "iŋ",
+    iong: "iʊŋ",
+    u: "u",
+    ua: "ua",
+    uo: "uo",
+    uai: "uai",
+    uei: "uei",
+    uan: "uan",
+    uen: "uən",
+    uang: "uaŋ",
+    ueng: "uəŋ",
+    ü: "y",
+    üe: "ye",
+    üan: "yɛn",
+    ün: "yn",
+    m: "m̩",
+    n: "n̩",
+    ng: "ŋ̍",
+};
+/**
+ * The initials after which the i final is the empty rhyme [ɨ].
+ */
+const EMPTY_RHYME_INITIALS = new Set([
+    "zh",
+    "ch",
+    "sh",
+    "r",
+    "z",
+    "c",
+    "s",
+]);
+/**
+ * The initials after which pinyin's -o final is [uo] rather than [ɔ].
+ */
+const LABIAL_INITIALS = new Set(["b", "p", "m", "f"]);
+/**
+ * What 儿化 adds.
+ *
+ * A suffix, and that is an approximation this module states rather than hides:
+ * a rhotacised syllable is not the plain one with [ɚ] after it. 玩儿 wánr is
+ * [wɑɚ̯] with the nasal gone, and 味儿 wèir keeps its glide while 事儿 shìr
+ * loses its empty rhyme entirely. Modelling that needs a rhyme-by-rhyme table
+ * of fused forms, which is a phonological claim rather than a transcription
+ * convention, and it is not made here.
+ */
+const ERHUA_SUFFIX = "ɚ";
+/**
+ * The Chao tone letter each tone is written with.
+ *
+ * The neutral tone has none: it has no contour of its own, taking its pitch
+ * from the syllable before it, and the transcription leaves it unwritten. That
+ * is bopomofo's problem in reverse — bopomofo cannot say "no tone", and this
+ * cannot say "neutral".
+ */
+const TONE_LETTERS = new Map([
+    [1, "˥"],
+    [2, "˧˥"],
+    [3, "˨˩˦"],
+    [4, "˥˩"],
+    [NEUTRAL_TONE, ""],
+]);
+/**
+ * The pitch value each tone is numbered with, in Chao's own notation.
+ */
+const TONE_NUMBERS = new Map([
+    [1, "55"],
+    [2, "35"],
+    [3, "214"],
+    [4, "51"],
+    [NEUTRAL_TONE, ""],
+]);
+/**
+ * How a final is transcribed after a given initial.
+ */
+function finalSymbols(initial, final) {
+    if (final === "i" && EMPTY_RHYME_INITIALS.has(initial)) {
+        return "ɨ";
+    }
+    if (final === "o" && LABIAL_INITIALS.has(initial)) {
+        return "uo";
+    }
+    return FINAL_SYMBOLS[final];
+}
+/**
+ * Transcribe a syllable without its tone: 就 jiù becomes `tɕiou`.
+ */
+export function writeIpaSymbols(syllable) {
+    const { initial, final } = syllable;
+    const suffix = syllable.erhua === true ? ERHUA_SUFFIX : "";
+    return `${INITIAL_SYMBOLS.get(initial) ?? ""}${finalSymbols(initial, final)}${suffix}`;
+}
+/**
+ * Transcribe a syllable in IPA: 就 jiù becomes `tɕiou˥˩`.
+ *
+ * Without brackets, since whether it is phonemic or phonetic is the caller's
+ * claim to make and not this table's.
+ */
+export function writeIpa(syllable, options = {}) {
+    const symbols = writeIpaSymbols(syllable);
+    const { tone } = syllable;
+    const { tones = "letters" } = options;
+    if (tone === undefined || tones === "none") {
+        return symbols;
+    }
+    const written = tones === "numbers" ? TONE_NUMBERS.get(tone) : TONE_LETTERS.get(tone);
+    /* c8 ignore next -- every tone is in both tables */
+    return `${symbols}${written ?? ""}`;
+}
+/**
+ * Transcribe a word, one syllable after another.
+ *
+ * Run together, as a transcription of connected speech is written. The tone
+ * letters mark where each syllable ends, so nothing is lost by it — except for
+ * the neutral tone, which writes nothing and so leaves a boundary unmarked.
+ */
+export function writeIpaWord(syllables, options = {}) {
+    return syllables.map((syllable) => writeIpa(syllable, options)).join("");
+}
+/**
+ * Every syllable each transcription stands for.
+ */
+const INDEX = indexInventory((syllable) => writeIpaSymbols(syllable));
+/**
+ * The tone each written form stands for, letters and pitch numerals alike.
+ */
+const TONES_BY_WRITTEN = new Map([...TONE_LETTERS, ...TONE_NUMBERS]
+    .filter(([, written]) => written !== "")
+    .map(([tone, written]) => [written, tone]));
+/**
+ * Take the tone off the end, however it was written.
+ *
+ * Tone letters, a pitch numeral, or the plain 1-to-5 digit this package uses
+ * everywhere else — the last is not IPA at all, but it costs nothing to accept
+ * and it is what somebody typing at a terminal will reach for.
+ */
+function splitTone(text) {
+    const found = /^(.*?)([˥˦˧˨˩]+|214|55|35|51|[0-5])$/u.exec(text);
+    const written = found?.[2];
+    if (written === undefined) {
+        return [text, undefined];
+    }
+    const tone = TONES_BY_WRITTEN.get(written) ?? toneFromNotation(Number(written));
+    return tone === undefined ? [text, undefined] : [found?.[1] ?? "", tone];
+}
+/**
+ * Read an IPA transcription back: `tɕiou˥˩` becomes 就 jiù.
+ *
+ * An index over the inventory, as everything here is, so a transcription of
+ * something Mandarin does not have reads as nothing rather than as a syllable
+ * nobody says. Returns an array for the same reason the other readers do,
+ * though IPA has less to be ambiguous about than any of them.
+ */
+export function readIpa(text) {
+    const [symbols, tone] = splitTone(text.trim().normalize("NFC"));
+    return readIndexed(INDEX, symbols, tone, ERHUA_SUFFIX);
+}
+//# sourceMappingURL=ipa.js.map

package/dist/transcription/ipa.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ipa.js","sourceRoot":"","sources":["../../src/transcription/ipa.ts"],"names":[],"mappings":"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"}

package/dist/transcription/spelling-index.d.ts

@@ -0,0 +1,23 @@
+import { type Syllable } from "../syllable/syllable.js";
+import type { Tone } from "../tone/tone.js";
+/**
+ * Every syllable a spelling stands for, which is one for all but a handful.
+ */
+export type SpellingIndex = ReadonlyMap<string, readonly Syllable[]>;
+/**
+ * Index the whole inventory by how `spell` writes each of its syllables.
+ *
+ * The syllables carry no tone: a spelling stands for a syllable, and the tone
+ * is read off the marks separately.
+ */
+export declare function indexInventory(spell: (syllable: Syllable) => string): SpellingIndex;
+/**
+ * Read a spelling out of an index, allowing for a 儿化 suffix on the end of it.
+ *
+ * The suffix is tried second and separately, because both readings can be real:
+ * Yale's `er` is 兒 ér, and it is also 餓儿 with the suffix on it. Returning
+ * both is the same answer Wade-Giles gives to an ambiguous spelling, and it is
+ * the caller's to narrow.
+ */
+export declare function readIndexed(index: SpellingIndex, spelling: string, tone: Tone | undefined, suffix: string): readonly Syllable[];
+//# sourceMappingURL=spelling-index.d.ts.map

package/dist/transcription/spelling-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spelling-index.d.ts","sourceRoot":"","sources":["../../src/transcription/spelling-index.ts"],"names":[],"mappings":"AAeA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACtE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAC;AAE5C;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC,CAAC;AAErE;;;;;GAKG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,CAAC,QAAQ,EAAE,QAAQ,KAAK,MAAM,GACpC,aAAa,CAiBf;AAED;;;;;;;GAOG;AACH,wBAAgB,WAAW,CACzB,KAAK,EAAE,aAAa,EACpB,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,IAAI,GAAG,SAAS,EACtB,MAAM,EAAE,MAAM,GACb,SAAS,QAAQ,EAAE,CAarB"}

package/dist/transcription/spelling-index.js

@@ -0,0 +1,61 @@
+/**
+ * An index from a written spelling to the syllables it can stand for.
+ *
+ * Every reader in this directory is an index over the attested inventory rather
+ * than a reverse rule, for the reason [wade-giles.ts](wade-giles.ts) records: a
+ * rule would happily read `shung` or `ki`, which are regular spellings of
+ * syllables Mandarin does not have. Building the index by *writing* every
+ * syllable also means a reader cannot drift from its writer — there is one
+ * table, and reading is what falls out of it backwards.
+ *
+ * Wade-Giles keeps its own version of this, because it needs two indexes and a
+ * per-mark repair for the apostrophes and diacritics real text drops. Yale and
+ * IPA drop nothing, so they share the plain one.
+ */
+import { DICTIONARY_SYLLABLES } from "../syllable/inventory.js";
+import { readSyllable } from "../syllable/syllable.js";
+/**
+ * Index the whole inventory by how `spell` writes each of its syllables.
+ *
+ * The syllables carry no tone: a spelling stands for a syllable, and the tone
+ * is read off the marks separately.
+ */
+export function indexInventory(spell) {
+    const index = new Map();
+    for (const pinyin of DICTIONARY_SYLLABLES) {
+        const syllable = readSyllable(pinyin);
+        /* c8 ignore next 3 -- inventory.test.ts holds the parser to the inventory */
+        if (syllable === undefined) {
+            continue;
+        }
+        const key = spell(syllable);
+        const found = index.get(key);
+        if (found === undefined) {
+            index.set(key, [syllable]);
+        }
+        else {
+            found.push(syllable);
+        }
+    }
+    return index;
+}
+/**
+ * Read a spelling out of an index, allowing for a 儿化 suffix on the end of it.
+ *
+ * The suffix is tried second and separately, because both readings can be real:
+ * Yale's `er` is 兒 ér, and it is also 餓儿 with the suffix on it. Returning
+ * both is the same answer Wade-Giles gives to an ambiguous spelling, and it is
+ * the caller's to narrow.
+ */
+export function readIndexed(index, spelling, tone, suffix) {
+    const found = (written, hasErhua) => (index.get(written) ?? []).map((syllable) => ({
+        ...syllable,
+        tone,
+        ...(hasErhua && { erhua: true }),
+    }));
+    const base = spelling !== suffix && spelling.endsWith(suffix)
+        ? spelling.slice(0, -suffix.length)
+        : "";
+    return [...found(spelling, false), ...(base === "" ? [] : found(base, true))];
+}
+//# sourceMappingURL=spelling-index.js.map

package/dist/transcription/spelling-index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"spelling-index.js","sourceRoot":"","sources":["../../src/transcription/spelling-index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAChE,OAAO,EAAE,YAAY,EAAiB,MAAM,yBAAyB,CAAC;AAQtE;;;;;GAKG;AACH,MAAM,UAAU,cAAc,CAC5B,KAAqC;IAErC,MAAM,KAAK,GAAG,IAAI,GAAG,EAAsB,CAAC;IAC5C,KAAK,MAAM,MAAM,IAAI,oBAAoB,EAAE,CAAC;QAC1C,MAAM,QAAQ,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC;QACtC,6EAA6E;QAC7E,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,SAAS;QACX,CAAC;QACD,MAAM,GAAG,GAAG,KAAK,CAAC,QAAQ,CAAC,CAAC;QAC5B,MAAM,KAAK,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QAC7B,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,KAAK,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC;QAC7B,CAAC;aAAM,CAAC;YACN,KAAK,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,WAAW,CACzB,KAAoB,EACpB,QAAgB,EAChB,IAAsB,EACtB,MAAc;IAEd,MAAM,KAAK,GAAG,CAAC,OAAe,EAAE,QAAiB,EAAuB,EAAE,CACxE,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;QAC5C,GAAG,QAAQ;QACX,IAAI;QACJ,GAAG,CAAC,QAAQ,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;KACjC,CAAC,CAAC,CAAC;IAEN,MAAM,IAAI,GACR,QAAQ,KAAK,MAAM,IAAI,QAAQ,CAAC,QAAQ,CAAC,MAAM,CAAC;QAC9C,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC;QACnC,CAAC,CAAC,EAAE,CAAC;IACT,OAAO,CAAC,GAAG,KAAK,CAAC,QAAQ,EAAE,KAAK,CAAC,EAAE,GAAG,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC;AAChF,CAAC"}

package/dist/transcription/wade-giles.d.ts

@@ -0,0 +1,108 @@
+import { type Syllable } from "../syllable/syllable.js";
+/**
+ * How a Wade-Giles syllable writes its tone.
+ *
+ * Wade-Giles writes it as a raised digit after the syllable, which is why
+ * `superscript` is the default; `numbers` writes the same digit on the line,
+ * which is what a plain-text field or a filename wants.
+ */
+export interface WadeGilesOptions {
+    readonly tones?: "superscript" | "numbers" | "none";
+}
+/**
+ * Spell a syllable in Wade-Giles without its tone.
+ */
+export declare function writeWadeGilesSpelling(syllable: Syllable): string;
+/**
+ * Write a syllable in Wade-Giles: 就 jiù becomes `chiu⁴`.
+ *
+ * Total over well-formed syllables, as the bopomofo writer is. An unwritten
+ * tone stays unwritten rather than being invented as a first tone, which is
+ * what lets the round trip come back exactly.
+ */
+export declare function writeWadeGiles(syllable: Syllable, options?: WadeGilesOptions): string;
+/**
+ * Write a word in Wade-Giles, hyphenating between its syllables.
+ *
+ * The hyphen is Wade's own convention and it is not decoration: `Tse-tung`
+ * written solid could be read as two syllables or as three, and the system has
+ * no 隔音符号 to fall back on. Pinyin writes the word solid and reaches for an
+ * apostrophe only where the boundary is genuinely ambiguous, which is the
+ * opposite default.
+ */
+export declare function writeWadeGilesWord(syllables: readonly Syllable[], options?: WadeGilesOptions): string;
+/**
+ * Read a Wade-Giles syllable exactly as it is written: `chiu⁴` becomes 就 jiù.
+ *
+ * Returns every syllable the spelling stands for, which is one for all but a
+ * handful of them — `lo` is both 羅 luó and 咯 lo, and `o` is both 俄 é and
+ * 哦 ó. Empty for anything that is not Wade-Giles at all.
+ */
+export declare function readWadeGiles(text: string): readonly Syllable[];
+/**
+ * The same, allowing for the marks real-world Wade-Giles drops.
+ *
+ * `chi` read exactly is 機 jī; read loosely it is jī or 七 qī, because a text
+ * that meant `chʻi` may simply never have typed the apostrophe. The exact
+ * readings come first, so a caller that wants to believe what was written can
+ * take the head of the list and one that wants every possibility can take the
+ * lot.
+ */
+export declare function readWadeGilesLoosely(text: string): readonly Syllable[];
+/**
+ * Split written Wade-Giles into syllables: `maotsetung` becomes three.
+ *
+ * **The hyphen is Wade's own boundary and is honoured where it is there.** What
+ * this is for is the text that dropped it, which is most of the Wade-Giles
+ * anybody meets — and there the system has nothing to fall back on, since its
+ * apostrophe marks aspiration rather than separation. Pinyin's 隔音符号 has no
+ * counterpart here.
+ *
+ * Longest-first, as `splitSyllables` is for pinyin, and measured on the same
+ * vocabulary the 52.07% ambiguity figure comes from — 411,956 multi-syllable
+ * words of the phrase corpus, written in Wade-Giles and run together:
+ *
+ * | | marks kept | marks dropped |
+ * | --- | ---: | ---: |
+ * | the boundary is found | 99.19% | 99.04% |
+ * | the word comes back | **99.45%** | **56.04%** |
+ *
+ * **Finding the boundary is not the hard part; saying which syllable it was
+ * is.** The boundary is found either way; what collapses is the reading, and
+ * only when the marks are gone, because 52.07% of written syllables then no
+ * longer say which syllable they were. See {@link readWadeGilesLoosely}.
+ *
+ * The true split is among the candidates 100.00% of the time and is the only
+ * candidate 17.08% of the time, at a mean of 5.23 candidates per word — so
+ * longest-first is a choice among real rivals rather than the only reading
+ * available. It comes back whole slightly *more* often than it finds the
+ * boundary, because two of the variant spellings read the same either way.
+ *
+ * The 0.81% of boundaries that are missed are one mechanism: Wade-Giles ends
+ * syllables in -n and -ng and begins them with vowels and n-, so `i-ti-hu-na`
+ * runs together as `itihuna` and comes back `i-ti-hun-a`. Of 3,317 misses,
+ * 53.39% swallow a syllable beginning with n- and 36.72% one beginning with a
+ * vowel. Pinyin is spared most of this by spelling a zero-initial i- as `yi-`;
+ * Wade-Giles writes 一 as `i`, and 960 of the misses — 28.94% — are a
+ * swallowed 一.
+ *
+ * Returns undefined for a run that does not split into Wade-Giles at all —
+ * which includes `Chungking` and `Tsingtao`, because those are Postal
+ * Romanisation rather than Wade-Giles and `king`, `tsing` and `pe` are not
+ * Wade-Giles syllables.
+ */
+export declare function splitWadeGiles(text: string): readonly string[] | undefined;
+/**
+ * Read a whole Wade-Giles word, splitting it first: `maotsetung` is 毛澤東.
+ *
+ * Takes the first candidate for each syllable rather than every combination,
+ * which is the same choice {@link readWadeGilesLoosely}'s ordering offers and
+ * for the same reason: a caller looking at a word cannot be handed the 5.23
+ * splits and the candidates under each of them and be said to have an answer.
+ * Measured over the phrase corpus, that recovers 99.45% of words written with
+ * their marks and 56.04% of words written without them.
+ *
+ * Undefined where the run does not split at all.
+ */
+export declare function readWadeGilesWord(text: string): readonly Syllable[] | undefined;
+//# sourceMappingURL=wade-giles.d.ts.map

package/dist/transcription/wade-giles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wade-giles.d.ts","sourceRoot":"","sources":["../../src/transcription/wade-giles.ts"],"names":[],"mappings":"AA6BA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AA6OtE;;;;;;GAMG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,KAAK,CAAC,EAAE,aAAa,GAAG,SAAS,GAAG,MAAM,CAAC;CACrD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,QAAQ,GAAG,MAAM,CAIjE;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAWR;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAC9B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAIR;AA+MD;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CAG/D;AAED;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CActE;AAsFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,SAAS,CA+B1E;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GACX,SAAS,QAAQ,EAAE,GAAG,SAAS,CAYjC"}