@kensio/pinyinjs 1.3.0 → 1.4.0

package/dist/script/glyphs.js

@@ -0,0 +1,236 @@
+import { toCharacters } from "./characters.js";
+/**
+ * The regional 繁體 orthographies this package writes.
+ *
+ * A third axis, independent of the script and locale axes in `script.ts`:
+ * Taiwan and Hong Kong write the same characters with the same readings, and
+ * disagree about the standard form of 58 of them. See SCRIPTS-AND-LOCALES.md.
+ */
+export const REGIONS = ["TW", "HK"];
+/**
+ * The 繁體 orthography written when the caller does not name one.
+ *
+ * There is no region-free 繁體 to fall back on: converting character by
+ * character from OpenCC's baseline yields 爲, 衆, 峯, 羣, 裏, 麪, which are the
+ * Hong Kong forms. Declining to choose would mean choosing Hong Kong silently,
+ * so a region is always applied and always named.
+ *
+ * Taiwan wins it on population, and more to the point because it is the one
+ * polity where 繁體 orthography and Mandarin as the spoken standard coincide —
+ * which is the intersection a pinyin package serves.
+ */
+export const DEFAULT_REGION = "TW";
+/**
+ * Read a table written as a flat run of `from`/`to` character pairs.
+ *
+ * Pairs rather than a `Record` so that the tables stay legible as data and cost
+ * one string each: these are code rather than an artifact to fetch, for the
+ * same reason the transcription tables are — 133 mappings do not justify a
+ * download, and they must be available before any dictionary has loaded.
+ */
+function readPairs(pairs) {
+    const characters = toCharacters(pairs);
+    const table = new Map();
+    for (let at = 0; at + 1 < characters.length; at += 2) {
+        /* c8 ignore next 2 -- both indices are in range while at + 1 < length */
+        table.set(characters[at] ?? "", characters[at + 1] ?? "");
+    }
+    return table;
+}
+/**
+ * Variant 繁體 forms, mapped to the canonical form this package stores.
+ *
+ * The canonical form is Taiwan's, because that is what the dictionary's 繁體
+ * keys already are: measured on CC-CEDICT's traditional column, 裡 outnumbers
+ * 裏 116 to 8, 群 outnumbers 羣 175 to 1 and 麵 outnumbers 麪 138 to 1. So
+ * normalisation means mapping toward `TW`, and only Hong Kong output needs a
+ * pass away from what is stored.
+ *
+ * This is what lets Hong Kong text find dictionary keys. 羣眾 and 麪包 are not
+ * keys and never will be, so they would otherwise fall back to converting
+ * character by character — the same loss 臺灣 had before `hantVariants`.
+ * Measured: of the 9,833 dictionary keys with a distinct Hong Kong spelling,
+ * 2,358 are already keys and normalisation reaches a further 5,439. The 2,036
+ * still out of reach are mostly 臺 written as 台, which the exclusions below
+ * deliberately decline to reverse.
+ *
+ * Nineteen mappings OpenCC makes are deliberately **excluded**, because the
+ * variant is itself current in the corpus the dictionary is built from and
+ * rewriting it would corrupt legitimate text. Two different reasons, and the
+ * second is the one that is easy to miss:
+ *
+ * 1. The variant is a live 繁體 spelling. 台 is the clearest — OpenCC maps it to
+ *    臺, but CC-CEDICT writes 台 164 times against 臺's 208, so it is a spelling
+ *    someone chose rather than a Hong Kong-ism. Also 污, 濕, 睾, 祕, 泄.
+ * 2. **The variant is a current 简体 character.** Many Hong Kong standard forms
+ *    are exactly the mainland simplified form, because the PRC simplification
+ *    adopted the same 新字形 conventions Hong Kong did: 着, 温, 脱, 户, 税, 卧,
+ *    悦, 兑, 葱, 幺, 棱, 檐, 痹. Normalising those would rewrite 简体 text, and
+ *    走着 `zǒuzhe` is the case that caught it.
+ *
+ * Excluding them costs almost nothing, because a variant current in either
+ * script is a key in its own right and resolves without any help from here.
+ * Reversing a merge is ambiguous in exactly the way 简→繁 is, and where the
+ * evidence says the variant is current, the safe answer is to leave it alone.
+ */
+const CANONICAL_PAIRS = "僞偽衹只啓啟喫吃粧妝嫺嫻嬀媯峯峰捝挩敍敘枴柺棁梲" +
+    "樑梁枱檯涚涗潙溈潨潀爲為牀床癡痴皁皂竈灶糉粽糭粽" +
+    "綫線緼縕繮韁纔才羣群脣唇蒀蒕蔘參蔿蒍藴蘊衆眾衞衛" +
+    "裏裡覈核説說輼轀醖醞鉢缽鈎鉤鋭銳鍼針閲閱鮎鯰鰛鰮" +
+    "麪麵齶顎";
+/**
+ * Canonical 繁體 forms, mapped to the form Hong Kong writes.
+ *
+ * The 58 characters the two standards genuinely disagree about, measured over
+ * the 86 that appear in either of OpenCC's variant tables. The other 28 are
+ * agreements rather than differences — 爲 → 為 and 衆 → 眾 are both moves *both*
+ * standards make, which is easy to get backwards by reading either table alone.
+ *
+ * Taiwan needs no table of its own: the canonical form is already Taiwan's, so
+ * `zh-Hant-TW` output is what the dictionary stores, unaltered.
+ */
+const HONG_KONG_PAIRS = "兌兑叄叁啟啓囪囱媼媪嫻嫺峰峯么幺悅悦慍愠戶户挩捝" +
+    "搵揾敓敚敘敍柺枴梲棁榲榅梁樑簷檐檯枱氳氲汙污洩泄" +
+    "涗涚溫温溼濕熅煴床牀痺痹著着睪睾稅税縕緼韁繮群羣" +
+    "脫脱膃腽臥卧臺台菸煙蒕蒀參蔘蔥葱蘊藴蛻蜕衛衞裡裏" +
+    "說説轀輼醞醖鉤鈎銳鋭閱閲鯰鮎鰮鰛麵麪顎齶";
+/**
+ * Variant 繁體 forms mapped to the canonical form, as a table.
+ *
+ * Exported so the data pipeline can recompute it from OpenCC and fail the build
+ * if the two have drifted — these tables are code rather than an artifact, so
+ * nothing else would notice an upstream release that moved a character.
+ */
+export const CANONICAL_FORMS = readPairs(CANONICAL_PAIRS);
+/**
+ * Canonical 繁體 forms mapped to Hong Kong's, as a table. Verified like
+ * {@link CANONICAL_FORMS}.
+ */
+export const HONG_KONG_FORMS = readPairs(HONG_KONG_PAIRS);
+/**
+ * The one glyph mapping whose answer depends on how the character is read.
+ *
+ * Taiwan writes 著 for every sense; Hong Kong splits it, writing 着 for the
+ * aspect particle and its relatives and keeping 著 for `zhù`. CC-CEDICT records
+ * the same split in its 简体 column — `著 着 [zhe5]` against `著 著 [zhu4]` —
+ * which is independent confirmation that the divide is real and where it falls.
+ *
+ * OpenCC resolves this with a phrase table. We resolve it with the reading,
+ * which is the point of difference this feature exists for, and which
+ * generalises to words no phrase table lists.
+ *
+ * `zhuó` is deliberately absent, and that is not an oversight: CC-CEDICT writes
+ * it both ways — `著 着 [zhuo2]` for wearing or applying, `著 著 [zhuo2]` for
+ * 執著 — so the reading genuinely does not settle it. It falls through to the
+ * default below and is reported as uncertain rather than guessed at silently.
+ */
+const READING_SPLITS = new Map([["著", new Map([["zhu", "著"]])]]);
+/**
+ * A reading key ignoring tone and 儿化, which never bear on a glyph choice.
+ *
+ * Tone is dropped because the split that needs it — 著 — divides `zhù` from
+ * `zhe` and `zháo`, and those differ in their vowels as well, so the initial
+ * and final are enough and are what sources agree on most.
+ */
+function readingKey(syllable) {
+    if (syllable === undefined) {
+        return undefined;
+    }
+    return `${syllable.initial}${syllable.final}`;
+}
+/**
+ * Whether a character's regional form depends on how it is read.
+ *
+ * Exposed so that a conversion can report the choice as uncertain when it had
+ * no reading to go on, rather than presenting a default as though it were
+ * settled.
+ */
+export function isReadingSensitive(character) {
+    return READING_SPLITS.has(character);
+}
+/**
+ * Normalise one 繁體 character to the canonical form the dictionary stores.
+ *
+ * Characters no table knows are returned unchanged, which is the right answer
+ * for nearly all of them: the two standards agree about everything except the
+ * 58 characters {@link HONG_KONG_FORMS} lists.
+ */
+export function toCanonicalGlyph(character) {
+    return CANONICAL_FORMS.get(character) ?? character;
+}
+/**
+ * Whether any character of a text has a canonical form other than itself.
+ */
+function hasVariantGlyph(text) {
+    for (const character of text) {
+        if (CANONICAL_FORMS.has(character)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Normalise a whole 繁體 text to the canonical forms the dictionary stores.
+ *
+ * Safe to run over 简体 or mixed text, but only because the table is built to
+ * make it so: every variant that is also a current 简体 character is excluded,
+ * since many Hong Kong forms and mainland simplified forms are the same
+ * character. See {@link CANONICAL_FORMS}.
+ *
+ * Returns the original string when nothing needs normalising, which is nearly
+ * always. This sits on the dictionary lookup path, where it is called once per
+ * candidate word at every position of a run, so the common case has to cost a
+ * scan rather than an allocation.
+ *
+ * The mapping is one character to one character, which is what makes it safe
+ * here: normalising a prefix gives the same answer as taking the prefix of the
+ * normalised text, so a lattice scan that prunes on prefixes cannot disagree
+ * with the lookup that follows it.
+ */
+export function toCanonicalGlyphs(text) {
+    if (!hasVariantGlyph(text)) {
+        return text;
+    }
+    let normalised = "";
+    for (const character of toCharacters(text)) {
+        normalised += toCanonicalGlyph(character);
+    }
+    return normalised;
+}
+/**
+ * Write one canonical character in a region's orthography.
+ *
+ * The syllable is used only where the character is one the two standards split
+ * on a reading; everywhere else it is ignored, because a glyph choice never
+ * changes how a character is read.
+ */
+export function toRegionalGlyph(character, region, syllable) {
+    if (region === DEFAULT_REGION) {
+        return character;
+    }
+    const split = READING_SPLITS.get(character);
+    const kept = split?.get(readingKey(syllable) ?? "");
+    if (kept !== undefined) {
+        return kept;
+    }
+    return HONG_KONG_FORMS.get(character) ?? character;
+}
+/**
+ * Write a whole canonical text in a region's orthography.
+ *
+ * Readings are matched to characters by position, so a caller with a decoded
+ * reading can pass it and a caller without one can leave it out. A position
+ * with no syllable behind it falls back to the region's default form, which is
+ * what {@link isReadingSensitive} lets the caller flag.
+ */
+export function toRegionalGlyphs(text, region, readings = []) {
+    if (region === DEFAULT_REGION) {
+        return text;
+    }
+    let written = "";
+    for (const [at, character] of toCharacters(text).entries()) {
+        written += toRegionalGlyph(character, region, readings[at]);
+    }
+    return written;
+}
+//# sourceMappingURL=glyphs.js.map

package/dist/script/glyphs.js.map

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

package/dist/sources/opencc.d.ts

@@ -0,0 +1,32 @@
+/**
+ * One OpenCC mapping table: each key with the forms it may be written as.
+ *
+ * The first value is OpenCC's default, and the rest are alternatives it keeps
+ * for the reverse tables it generates. Both matter here: the default is what a
+ * conversion takes when it has no other evidence, and the alternatives are what
+ * a normalisation has to recognise on input.
+ */
+export type OpenCcTable = ReadonlyMap<string, readonly string[]>;
+/**
+ * Read one of OpenCC's dictionary tables.
+ *
+ * The format is one mapping per line as `key<TAB>value(s)`, values separated by
+ * spaces with the first as the default, and `#` starting a comment line.
+ *
+ * OpenCC also writes directives into those comments — `# @reverse-prefer: 才`
+ * tells its own build which value to favour when it generates the reversed
+ * table. They are deliberately ignored: we do not use OpenCC's generated
+ * reverse tables, and reversing a table here is a decision for the code that
+ * knows what it is reversing for. See SCRIPTS-AND-LOCALES.md.
+ *
+ * Faithful to the file, per the convention in DATA-SOURCES.md: a key mapping to
+ * itself is kept rather than dropped as a no-op, because "this character is
+ * already standard" and "this character is unknown to the table" are different
+ * facts, and only the table can tell them apart.
+ */
+export declare function parseOpenCcTable(text: string): OpenCcTable;
+/**
+ * The form a table converts a character to, or undefined if it has no opinion.
+ */
+export declare function openCcDefault(table: OpenCcTable, character: string): string | undefined;
+//# sourceMappingURL=opencc.d.ts.map

package/dist/sources/opencc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencc.d.ts","sourceRoot":"","sources":["../../src/sources/opencc.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAAC;AAYjE;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,WAAW,CAsB1D;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,KAAK,EAAE,WAAW,EAClB,SAAS,EAAE,MAAM,GAChB,MAAM,GAAG,SAAS,CAEpB"}

package/dist/sources/opencc.js

@@ -0,0 +1,50 @@
+/**
+ * Separator between an OpenCC key and its values.
+ */
+const COLUMN = "\t";
+/**
+ * Separator between the values of one key.
+ */
+const VALUE = " ";
+/**
+ * Read one of OpenCC's dictionary tables.
+ *
+ * The format is one mapping per line as `key<TAB>value(s)`, values separated by
+ * spaces with the first as the default, and `#` starting a comment line.
+ *
+ * OpenCC also writes directives into those comments — `# @reverse-prefer: 才`
+ * tells its own build which value to favour when it generates the reversed
+ * table. They are deliberately ignored: we do not use OpenCC's generated
+ * reverse tables, and reversing a table here is a decision for the code that
+ * knows what it is reversing for. See SCRIPTS-AND-LOCALES.md.
+ *
+ * Faithful to the file, per the convention in DATA-SOURCES.md: a key mapping to
+ * itself is kept rather than dropped as a no-op, because "this character is
+ * already standard" and "this character is unknown to the table" are different
+ * facts, and only the table can tell them apart.
+ */
+export function parseOpenCcTable(text) {
+    const table = new Map();
+    for (const line of text.split("\n")) {
+        if (line.startsWith("#")) {
+            continue;
+        }
+        const [key, values] = line.trim().split(COLUMN);
+        if (key === undefined || key === "" || values === undefined) {
+            continue;
+        }
+        const forms = values.split(VALUE).filter((form) => form !== "");
+        if (forms.length === 0) {
+            continue;
+        }
+        table.set(key.normalize("NFC"), forms.map((form) => form.normalize("NFC")));
+    }
+    return table;
+}
+/**
+ * The form a table converts a character to, or undefined if it has no opinion.
+ */
+export function openCcDefault(table, character) {
+    return table.get(character)?.[0];
+}
+//# sourceMappingURL=opencc.js.map

package/dist/sources/opencc.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"opencc.js","sourceRoot":"","sources":["../../src/sources/opencc.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,MAAM,MAAM,GAAG,IAAI,CAAC;AAEpB;;GAEG;AACH,MAAM,KAAK,GAAG,GAAG,CAAC;AAElB;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAY;IAC3C,MAAM,KAAK,GAAG,IAAI,GAAG,EAA6B,CAAC;IAEnD,KAAK,MAAM,IAAI,IAAI,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC;QACpC,IAAI,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YACzB,SAAS;QACX,CAAC;QACD,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAChD,IAAI,GAAG,KAAK,SAAS,IAAI,GAAG,KAAK,EAAE,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;YAC5D,SAAS;QACX,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,EAAE,CAAC,CAAC;QAChE,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACvB,SAAS;QACX,CAAC;QACD,KAAK,CAAC,GAAG,CACP,GAAG,CAAC,SAAS,CAAC,KAAK,CAAC,EACpB,KAAK,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAC3C,CAAC;IACJ,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAC3B,KAAkB,EAClB,SAAiB;IAEjB,OAAO,KAAK,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;AACnC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kensio/pinyinjs",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Chinese hanzi to pinyin conversion",
   "repository": {
     "type": "git",