@kensio/pinyinjs 1.7.4 → 1.7.5

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

@@ -0,0 +1,61 @@
+import type { Syllable } from "../syllable/syllable.js";
+export { APOSTROPHE, APOSTROPHES } from "./wade-giles-tables.js";
+/**
+ * The 儿化 suffix, which Wade-Giles hangs off the syllable rather than fusing
+ * into it.
+ *
+ * So this is the one place a syllable is written with a hyphen in it: 花儿 huār
+ * is `hua¹-'rh`. Two things about that shape are worth stating, because both
+ * are decisions:
+ *
+ * - **The suffix is the reduced `'rh` rather than a full `êrh`.** 兒 as a
+ *   syllable of its own is `êrh`, and as a suffix it is written short. This is
+ *   the form en.wiktionary's Chinese entries use throughout, and it is what the
+ *   fixture in [test/fixtures/wiktionary.ts](../../test/fixtures/wiktionary.ts)
+ *   is checked against.
+ * - **The tone digit goes on the syllable, in front of the suffix.** The tone
+ *   is the base syllable's — 花儿 is a first-tone 花 with a suffix on it — and
+ *   Wade-Giles writes the digit after the syllable it belongs to. Writing
+ *   `hua-êrh¹` instead, as this module used to, says the 兒 carries a first
+ *   tone, which is not what anybody means by it.
+ *
+ * Pinyin's `r` suffix is the later convention and the two are not
+ * interchangeable.
+ */
+export declare const ERHUA_SUFFIX = "-'rh";
+/**
+ * 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.
+ *
+ * The digit goes in front of the 儿化 suffix rather than after it — 玩儿 wánr
+ * is `wan²-'rh` — for the reason {@link ERHUA_SUFFIX} gives.
+ */
+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;
+//# sourceMappingURL=wade-giles-spelling.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wade-giles-spelling.d.ts","sourceRoot":"","sources":["../../src/transcription/wade-giles-spelling.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAgBxD,OAAO,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAqCjE;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,YAAY,SAAqB,CAAC;AAE/C;;;;;;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;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAeR;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAC9B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAIR"}

package/dist/transcription/wade-giles-spelling.js

@@ -0,0 +1,107 @@
+import { SUPERSCRIPT_TONES } from "../tone/tone-mark.js";
+import { APOSTROPHE, FINAL_SPELLINGS, INITIAL_SPELLINGS, O_FOR_E_INITIALS, O_FOR_UO_INITIALS, RETROFLEX_INITIALS, SIBILANT_INITIALS, SIBILANT_SPELLINGS, UEI_INITIALS, ZERO_INITIAL_SPELLINGS, } from "./wade-giles-tables.js";
+export { APOSTROPHE, APOSTROPHES } from "./wade-giles-tables.js";
+/**
+ * How an initial is spelled in front of a given final.
+ */
+function initialSpelling(initial, final) {
+    const sibilant = final === "i" ? SIBILANT_SPELLINGS.get(initial) : undefined;
+    return sibilant ?? INITIAL_SPELLINGS.get(initial) ?? "";
+}
+/**
+ * How a final is spelled after a given initial.
+ */
+function finalSpelling(initial, final) {
+    if (initial === "") {
+        return ZERO_INITIAL_SPELLINGS[final];
+    }
+    if (final === "i") {
+        if (RETROFLEX_INITIALS.has(initial)) {
+            return "ih";
+        }
+        if (SIBILANT_INITIALS.has(initial)) {
+            return "ŭ";
+        }
+    }
+    if (final === "e" && O_FOR_E_INITIALS.has(initial)) {
+        return "o";
+    }
+    if (final === "uo" && O_FOR_UO_INITIALS.has(initial)) {
+        return "o";
+    }
+    if (final === "uei" && UEI_INITIALS.has(initial)) {
+        return "uei";
+    }
+    return FINAL_SPELLINGS[final];
+}
+/**
+ * The 儿化 suffix, which Wade-Giles hangs off the syllable rather than fusing
+ * into it.
+ *
+ * So this is the one place a syllable is written with a hyphen in it: 花儿 huār
+ * is `hua¹-'rh`. Two things about that shape are worth stating, because both
+ * are decisions:
+ *
+ * - **The suffix is the reduced `'rh` rather than a full `êrh`.** 兒 as a
+ *   syllable of its own is `êrh`, and as a suffix it is written short. This is
+ *   the form en.wiktionary's Chinese entries use throughout, and it is what the
+ *   fixture in [test/fixtures/wiktionary.ts](../../test/fixtures/wiktionary.ts)
+ *   is checked against.
+ * - **The tone digit goes on the syllable, in front of the suffix.** The tone
+ *   is the base syllable's — 花儿 is a first-tone 花 with a suffix on it — and
+ *   Wade-Giles writes the digit after the syllable it belongs to. Writing
+ *   `hua-êrh¹` instead, as this module used to, says the 兒 carries a first
+ *   tone, which is not what anybody means by it.
+ *
+ * Pinyin's `r` suffix is the later convention and the two are not
+ * interchangeable.
+ */
+export const ERHUA_SUFFIX = `-${APOSTROPHE}rh`;
+/**
+ * Spell a syllable in Wade-Giles without its tone.
+ */
+export function writeWadeGilesSpelling(syllable) {
+    const { initial, final } = syllable;
+    const suffix = syllable.erhua === true ? ERHUA_SUFFIX : "";
+    return `${initialSpelling(initial, final)}${finalSpelling(initial, final)}${suffix}`;
+}
+/**
+ * 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.
+ *
+ * The digit goes in front of the 儿化 suffix rather than after it — 玩儿 wánr
+ * is `wan²-'rh` — for the reason {@link ERHUA_SUFFIX} gives.
+ */
+export function writeWadeGiles(syllable, options = {}) {
+    const spelling = writeWadeGilesSpelling(syllable);
+    const { tone } = syllable;
+    const { tones = "superscript" } = options;
+    if (tone === undefined || tones === "none") {
+        return spelling;
+    }
+    const digit = tones === "numbers"
+        ? String(tone)
+        : /* c8 ignore next -- every tone has a raised digit */
+            (SUPERSCRIPT_TONES.get(tone) ?? "");
+    return spelling.endsWith(ERHUA_SUFFIX)
+        ? `${spelling.slice(0, -ERHUA_SUFFIX.length)}${digit}${ERHUA_SUFFIX}`
+        : `${spelling}${digit}`;
+}
+/**
+ * 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 function writeWadeGilesWord(syllables, options = {}) {
+    return syllables
+        .map((syllable) => writeWadeGiles(syllable, options))
+        .join("-");
+}
+//# sourceMappingURL=wade-giles-spelling.js.map

package/dist/transcription/wade-giles-spelling.js.map

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

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

@@ -0,0 +1,29 @@
+import type { Syllable } from "../syllable/syllable.js";
+/**
+ * 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.
+ *
+ * A written tone narrows that: 咯 is only ever neutral, so `lo` on its own is
+ * the two syllables and `lo²` is 羅 luó alone. See {@link narrowToAttested}.
+ */
+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.
+ *
+ * Narrowed over the whole list rather than over each half of it, because the
+ * two halves are rivals: `pan²` written exactly is a bán that Mandarin does not
+ * have, and the reading worth keeping is the 盤 pán of a text that dropped an
+ * apostrophe. Read exactly, `pan²` is still bán — there is nothing there to
+ * prefer it to.
+ */
+export declare function readWadeGilesLoosely(text: string): readonly Syllable[];
+//# sourceMappingURL=wade-giles-syllable.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wade-giles-syllable.d.ts","sourceRoot":"","sources":["../../src/transcription/wade-giles-syllable.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AA0CxD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CAM/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CAetE"}

package/dist/transcription/wade-giles-syllable.js

@@ -0,0 +1,90 @@
+/**
+ * Reading one written Wade-Giles syllable.
+ *
+ * Writing it is a table, in the same way bopomofo is — see
+ * `wade-giles-spelling.ts`. Reading it is not a table, and that asymmetry is
+ * the whole of this file. Three things stand in the way:
+ *
+ * - The spelling is not injective even when written correctly: `lo` is both
+ *   luō and lo, and `o` is both ē and ō.
+ * - The aspiration apostrophe is routinely dropped, and it carries a phonemic
+ *   distinction: `ch'i` is qī and `chi` is jī, so a dropped mark makes one
+ *   spelling stand for both. Written `chu`, with the diaeresis gone too, it
+ *   stands for four syllables.
+ * - The diacritics are routinely dropped as well — ê, ŭ and ü — which merges
+ *   `hsü` into `hsu` and `tzŭ` into `tzu`.
+ *
+ * So reading returns *every* syllable a spelling could be, and does it against
+ * the attested inventory rather than by rule: a rule would happily read `shung`
+ * or `ki`, which are not syllables of Mandarin at all.
+ * {@link readWadeGiles} takes the spelling as written, and
+ * {@link readWadeGilesLoosely} allows for the marks that fell off. How much
+ * that costs is measured — see `docs/romanization/`.
+ *
+ * The tone digit, where a text writes one, cuts that list back down: the
+ * inventory knows which tones each syllable is written in, so `lo²` is 羅 luó
+ * and not the 咯 that is only ever neutral. See {@link narrowToAttested}.
+ */
+import { narrowToAttested } from "../syllable/inventory.js";
+import { isMarksDropped, normalise, splitErhua, splitTone, } from "./wade-giles-parse.js";
+import { INDEX, isSameSyllable, withoutMarks, } from "./wade-giles-index.js";
+/**
+ * Read a normalised spelling out of one of the two indexes.
+ *
+ * `toKey` is how the spelling is turned into that index's key.
+ *
+ * The tone is written on here and not judged: the index is toneless, so what
+ * comes back is every syllable of that spelling in whatever tone the text
+ * carried, and narrowing that to the tones Mandarin actually writes belongs to
+ * the callers, which have the whole candidate list to weigh.
+ */
+function readFrom(index, toKey, spelling, tone, isErhua) {
+    return (index.get(toKey(spelling)) ?? [])
+        .filter((one) => isMarksDropped(one.spelling, spelling))
+        .map((one) => ({
+        ...one.syllable,
+        tone,
+        ...(isErhua && { erhua: true }),
+    }));
+}
+/**
+ * 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.
+ *
+ * A written tone narrows that: 咯 is only ever neutral, so `lo` on its own is
+ * the two syllables and `lo²` is 羅 luó alone. See {@link narrowToAttested}.
+ */
+export function readWadeGiles(text) {
+    const [written, isErhua] = splitErhua(normalise(text), false);
+    const [spelling, tone] = splitTone(written);
+    return narrowToAttested(readFrom(INDEX.exact, (key) => key, spelling, tone, isErhua));
+}
+/**
+ * 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.
+ *
+ * Narrowed over the whole list rather than over each half of it, because the
+ * two halves are rivals: `pan²` written exactly is a bán that Mandarin does not
+ * have, and the reading worth keeping is the 盤 pán of a text that dropped an
+ * apostrophe. Read exactly, `pan²` is still bán — there is nothing there to
+ * prefer it to.
+ */
+export function readWadeGilesLoosely(text) {
+    const exact = readWadeGiles(text);
+    const [written, isErhua] = splitErhua(normalise(text), true);
+    const [spelling, tone] = splitTone(written);
+    const loose = readFrom(INDEX.loose, withoutMarks, spelling, tone, isErhua);
+    return narrowToAttested([
+        ...exact,
+        ...loose.filter((syllable) => exact.every((other) => !isSameSyllable(other, syllable) || other.erhua !== syllable.erhua)),
+    ]);
+}
+//# sourceMappingURL=wade-giles-syllable.js.map

package/dist/transcription/wade-giles-syllable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wade-giles-syllable.js","sourceRoot":"","sources":["../../src/transcription/wade-giles-syllable.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAG5D,OAAO,EACL,cAAc,EACd,SAAS,EACT,UAAU,EACV,SAAS,GACV,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EACL,KAAK,EACL,cAAc,EAEd,YAAY,GACb,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;GASG;AACH,SAAS,QAAQ,CACf,KAA4C,EAC5C,KAAmC,EACnC,QAAgB,EAChB,IAAsB,EACtB,OAAgB;IAEhB,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;SACtC,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,cAAc,CAAC,GAAG,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;SACvD,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;QACb,GAAG,GAAG,CAAC,QAAQ;QACf,IAAI;QACJ,GAAG,CAAC,OAAO,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC;KAChC,CAAC,CAAC,CAAC;AACR,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,KAAK,CAAC,CAAC;IAC9D,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;IAC5C,OAAO,gBAAgB,CACrB,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAC7D,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,oBAAoB,CAAC,IAAY;IAC/C,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,CAAC,CAAC;IAClC,MAAM,CAAC,OAAO,EAAE,OAAO,CAAC,GAAG,UAAU,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,IAAI,CAAC,CAAC;IAC7D,MAAM,CAAC,QAAQ,EAAE,IAAI,CAAC,GAAG,SAAS,CAAC,OAAO,CAAC,CAAC;IAC5C,MAAM,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,CAAC,CAAC;IAE3E,OAAO,gBAAgB,CAAC;QACtB,GAAG,KAAK;QACR,GAAG,KAAK,CAAC,MAAM,CAAC,CAAC,QAAQ,EAAE,EAAE,CAC3B,KAAK,CAAC,KAAK,CACT,CAAC,KAAK,EAAE,EAAE,CACR,CAAC,cAAc,CAAC,KAAK,EAAE,QAAQ,CAAC,IAAI,KAAK,CAAC,KAAK,KAAK,QAAQ,CAAC,KAAK,CACrE,CACF;KACF,CAAC,CAAC;AACL,CAAC"}

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

@@ -0,0 +1,80 @@
+/**
+ * How Wade-Giles spells each part of a syllable, as tables.
+ *
+ * Separated from the rules that read them, so that this file is only ever a
+ * statement of what the system writes.
+ */
+import type { Final, Initial } from "../syllable/phonology.js";
+/**
+ * The mark Wade-Giles writes aspiration with.
+ *
+ * ASCII, because that is what a keyboard produces and what nearly all text
+ * carries; the turned comma ʻ of the original and of library cataloguing is
+ * read back but not written. Every shape a text might use is accepted on input,
+ * which matters more here than in most places — this mark is the one carrying
+ * the p/pʻ distinction.
+ */
+export declare const APOSTROPHE = "'";
+/**
+ * Every shape the aspiration mark is written with in the wild.
+ */
+export declare const APOSTROPHES: RegExp;
+/**
+ * How each initial is spelled.
+ *
+ * The unvoiced/aspirated pairing is what makes this look wrong to a reader who
+ * only knows pinyin: Wade-Giles writes the *unaspirated* stop with the plain
+ * letter, so pinyin b is `p` and pinyin p is `pʻ`. Nothing is missing from the
+ * table; the whole series is shifted.
+ */
+export declare const INITIAL_SPELLINGS: Map<Initial, string>;
+/**
+ * How z, c and s are spelled before the empty rhyme.
+ *
+ * 資 zī is `tzŭ` rather than `tsŭ`, and 私 sī is `ssŭ` rather than `sŭ`: the
+ * three sibilants take a different shape in front of the vowel that is not
+ * really one.
+ */
+export declare const SIBILANT_SPELLINGS: Map<Initial, string>;
+/**
+ * How each final is spelled after an initial.
+ *
+ * `ueng` never occurs after one — 翁 wēng is the only syllable that has it —
+ * and is written with the form the pattern would give it rather than being made
+ * a special case.
+ */
+export declare const FINAL_SPELLINGS: Record<Final, string>;
+/**
+ * How each final is spelled with no initial in front of it.
+ *
+ * The i, u and ü groups take a y or w onset as they do in pinyin, but not the
+ * same one in the same places: 一 yī is `i` and 有 yǒu is `yu`, which is also
+ * where 魚 yú's `yü` loses its diaeresis and collides. Finals that cannot stand
+ * alone keep their after-initial spelling.
+ */
+export declare const ZERO_INITIAL_SPELLINGS: Record<Final, string>;
+/**
+ * The initials after which the i final is the empty rhyme written `ih`.
+ */
+export declare const RETROFLEX_INITIALS: Set<Initial>;
+/**
+ * The initials after which it is the empty rhyme written `ŭ`.
+ */
+export declare const SIBILANT_INITIALS: Set<Initial>;
+/**
+ * The initials after which the e final is written `o` rather than `ê`.
+ */
+export declare const O_FOR_E_INITIALS: Set<Initial>;
+/**
+ * The initials after which `uo` loses its u: 作 zuò is `tso`, 若 ruò is `jo`.
+ *
+ * sh is the exception that has to be listed by its absence — 說 shuō stays
+ * `shuo` while 桌 zhuō is `cho` — and it is an exception in the source rather
+ * than an error here.
+ */
+export declare const O_FOR_UO_INITIALS: Set<Initial>;
+/**
+ * The initials after which `uei` keeps its middle vowel: 貴 guì is `kuei`.
+ */
+export declare const UEI_INITIALS: Set<Initial>;
+//# sourceMappingURL=wade-giles-tables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"wade-giles-tables.d.ts","sourceRoot":"","sources":["../../src/transcription/wade-giles-tables.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAE/D;;;;;;;;GAQG;AACH,eAAO,MAAM,UAAU,MAAM,CAAC;AAE9B;;GAEG;AACH,eAAO,MAAM,WAAW,QAAiB,CAAC;AAE1C;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,sBAsB5B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,sBAI7B,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CA0CjD,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,MAAM,CAAC,KAAK,EAAE,MAAM,CA0BxD,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,cAA4C,CAAC;AAE5E;;GAEG;AACH,eAAO,MAAM,iBAAiB,cAAoC,CAAC;AAEnE;;GAEG;AACH,eAAO,MAAM,gBAAgB,cAAoC,CAAC;AAElE;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,cAW5B,CAAC;AAEH;;GAEG;AACH,eAAO,MAAM,YAAY,cAA+B,CAAC"}

package/dist/transcription/wade-giles-tables.js

@@ -0,0 +1,178 @@
+/**
+ * The mark Wade-Giles writes aspiration with.
+ *
+ * ASCII, because that is what a keyboard produces and what nearly all text
+ * carries; the turned comma ʻ of the original and of library cataloguing is
+ * read back but not written. Every shape a text might use is accepted on input,
+ * which matters more here than in most places — this mark is the one carrying
+ * the p/pʻ distinction.
+ */
+export const APOSTROPHE = "'";
+/**
+ * Every shape the aspiration mark is written with in the wild.
+ */
+export const APOSTROPHES = /['ʻʼ‘’`´ʹ]/gu;
+/**
+ * How each initial is spelled.
+ *
+ * The unvoiced/aspirated pairing is what makes this look wrong to a reader who
+ * only knows pinyin: Wade-Giles writes the *unaspirated* stop with the plain
+ * letter, so pinyin b is `p` and pinyin p is `pʻ`. Nothing is missing from the
+ * table; the whole series is shifted.
+ */
+export const INITIAL_SPELLINGS = new Map([
+    ["b", "p"],
+    ["p", `p${APOSTROPHE}`],
+    ["m", "m"],
+    ["f", "f"],
+    ["d", "t"],
+    ["t", `t${APOSTROPHE}`],
+    ["n", "n"],
+    ["l", "l"],
+    ["g", "k"],
+    ["k", `k${APOSTROPHE}`],
+    ["h", "h"],
+    ["j", "ch"],
+    ["q", `ch${APOSTROPHE}`],
+    ["x", "hs"],
+    ["zh", "ch"],
+    ["ch", `ch${APOSTROPHE}`],
+    ["sh", "sh"],
+    ["r", "j"],
+    ["z", "ts"],
+    ["c", `ts${APOSTROPHE}`],
+    ["s", "s"],
+]);
+/**
+ * How z, c and s are spelled before the empty rhyme.
+ *
+ * 資 zī is `tzŭ` rather than `tsŭ`, and 私 sī is `ssŭ` rather than `sŭ`: the
+ * three sibilants take a different shape in front of the vowel that is not
+ * really one.
+ */
+export const SIBILANT_SPELLINGS = new Map([
+    ["z", "tz"],
+    ["c", `tz${APOSTROPHE}`],
+    ["s", "ss"],
+]);
+/**
+ * How each final is spelled after an initial.
+ *
+ * `ueng` never occurs after one — 翁 wēng is the only syllable that has it —
+ * and is written with the form the pattern would give it rather than being made
+ * a special case.
+ */
+export const FINAL_SPELLINGS = {
+    a: "a",
+    o: "o",
+    e: "ê",
+    ê: "eh",
+    er: "êrh",
+    ai: "ai",
+    ei: "ei",
+    ao: "ao",
+    ou: "ou",
+    an: "an",
+    en: "ên",
+    ang: "ang",
+    eng: "êng",
+    ong: "ung",
+    i: "i",
+    ia: "ia",
+    io: "io",
+    ie: "ieh",
+    iao: "iao",
+    iou: "iu",
+    ian: "ien",
+    in: "in",
+    iang: "iang",
+    ing: "ing",
+    iong: "iung",
+    u: "u",
+    ua: "ua",
+    uo: "uo",
+    uai: "uai",
+    uei: "ui",
+    uan: "uan",
+    uen: "un",
+    uang: "uang",
+    ueng: "uêng",
+    ü: "ü",
+    üe: "üeh",
+    üan: "üan",
+    ün: "ün",
+    m: "m",
+    n: "n",
+    ng: "ng",
+};
+/**
+ * How each final is spelled with no initial in front of it.
+ *
+ * The i, u and ü groups take a y or w onset as they do in pinyin, but not the
+ * same one in the same places: 一 yī is `i` and 有 yǒu is `yu`, which is also
+ * where 魚 yú's `yü` loses its diaeresis and collides. Finals that cannot stand
+ * alone keep their after-initial spelling.
+ */
+export const ZERO_INITIAL_SPELLINGS = {
+    ...FINAL_SPELLINGS,
+    i: "i",
+    ia: "ya",
+    io: "yo",
+    ie: "yeh",
+    iao: "yao",
+    iou: "yu",
+    ian: "yen",
+    in: "yin",
+    iang: "yang",
+    ing: "ying",
+    iong: "yung",
+    u: "wu",
+    ua: "wa",
+    uo: "wo",
+    uai: "wai",
+    uei: "wei",
+    uan: "wan",
+    uen: "wên",
+    uang: "wang",
+    ueng: "wêng",
+    ü: "yü",
+    üe: "yüeh",
+    üan: "yüan",
+    ün: "yün",
+};
+/**
+ * The initials after which the i final is the empty rhyme written `ih`.
+ */
+export const RETROFLEX_INITIALS = new Set(["zh", "ch", "sh", "r"]);
+/**
+ * The initials after which it is the empty rhyme written `ŭ`.
+ */
+export const SIBILANT_INITIALS = new Set(["z", "c", "s"]);
+/**
+ * The initials after which the e final is written `o` rather than `ê`.
+ */
+export const O_FOR_E_INITIALS = new Set(["g", "k", "h"]);
+/**
+ * The initials after which `uo` loses its u: 作 zuò is `tso`, 若 ruò is `jo`.
+ *
+ * sh is the exception that has to be listed by its absence — 說 shuō stays
+ * `shuo` while 桌 zhuō is `cho` — and it is an exception in the source rather
+ * than an error here.
+ */
+export const O_FOR_UO_INITIALS = new Set([
+    "d",
+    "t",
+    "n",
+    "l",
+    "z",
+    "c",
+    "s",
+    "zh",
+    "ch",
+    "r",
+]);
+/**
+ * The initials after which `uei` keeps its middle vowel: 貴 guì is `kuei`.
+ */
+export const UEI_INITIALS = new Set(["g", "k"]);
+//# sourceMappingURL=wade-giles-tables.js.map

package/dist/transcription/wade-giles-tables.js.map

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

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

@@ -1,66 +1,15 @@
-import { type Syllable } from "../syllable/syllable.js";
 /**
- * How a Wade-Giles syllable writes its tone.
+ * Wade-Giles, and cutting a run of it into syllables.
  *
- * 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.
+ * The entry point for the system, re-exporting the spelling tables and the
+ * single-syllable reader alongside its own subject: Wade-Giles writes a word
+ * with hyphens, and a text that dropped them has to be segmented back. That
+ * is a different problem from reading one syllable — the spellings overlap,
+ * so it takes a search rather than a lookup.
  */
-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.
- *
- * The digit goes in front of the 儿化 suffix rather than after it — 玩儿 wánr
- * is `wan²-'rh` — for the reason {@link ERHUA_SUFFIX} gives.
- */
-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.
- *
- * A written tone narrows that: 咯 is only ever neutral, so `lo` on its own is
- * the two syllables and `lo²` is 羅 luó alone. See {@link narrowToAttested}.
- */
-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.
- *
- * Narrowed over the whole list rather than over each half of it, because the
- * two halves are rivals: `pan²` written exactly is a bán that Mandarin does not
- * have, and the reading worth keeping is the 盤 pán of a text that dropped an
- * apostrophe. Read exactly, `pan²` is still bán — there is nothing there to
- * prefer it to.
- */
-export declare function readWadeGilesLoosely(text: string): readonly Syllable[];
+import type { Syllable } from "../syllable/syllable.js";
+export { type WadeGilesOptions, writeWadeGiles, writeWadeGilesSpelling, writeWadeGilesWord, } from "./wade-giles-spelling.js";
+export { readWadeGiles, readWadeGilesLoosely } from "./wade-giles-syllable.js";
 /**
  * Split written Wade-Giles into syllables: `maotsetung` becomes three.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"wade-giles.d.ts","sourceRoot":"","sources":["../../src/transcription/wade-giles.ts"],"names":[],"mappings":"AAoCA,OAAO,EAAgB,KAAK,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AA2PtE;;;;;;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;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAC5B,QAAQ,EAAE,QAAQ,EAClB,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAeR;AAED;;;;;;;;GAQG;AACH,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,QAAQ,EAAE,EAC9B,OAAO,GAAE,gBAAqB,GAC7B,MAAM,CAIR;AAoOD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CAM/D;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,CAetE;AAwFD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"wade-giles.d.ts","sourceRoot":"","sources":["../../src/transcription/wade-giles.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAMxD,OAAO,EACL,KAAK,gBAAgB,EACrB,cAAc,EACd,sBAAsB,EACtB,kBAAkB,GACnB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAwF/E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}