@kensio/pinyinjs 1.7.4 → 1.7.6

package/dist/dictionary/cedict-senses.js

@@ -0,0 +1,126 @@
+/**
+ * Reading CC-CEDICT: indexing its entries, and telling its senses apart.
+ *
+ * CC-CEDICT gives a word one entry per pronunciation and keys each under both
+ * scripts, so getting anything out of it means first deciding which entries
+ * describe the word in hand and which describe a different one written alike.
+ */
+import { isSingleCharacter } from "../script/characters.js";
+import { isSameReading } from "./entry.js";
+import { readDictionaryReading } from "./reading.js";
+/**
+ * Whether a phrase-corpus headword is really the 繁體 spelling of another word.
+ *
+ * `large_pinyin.txt` is a 简体 corpus, and where it carries a 繁體 headword
+ * anyway it has read it as though the characters were 简体: 特徵 is `tè zhǐ`
+ * there because 徵 alone is `zhǐ`, 沈溺 is `shěn nì` because 沈 alone is the
+ * surname, 蝨子 is `shī zǐ`, 纔然 is `shān rán`. Every one of those is a word
+ * whose 简体 form the corpus also carries, correctly.
+ *
+ * Left in, each becomes an entry of its own that outranks the 繁體 key the
+ * derivation would have hung on the 简体 entry, so the word reads one way in a
+ * tier holding the phrase tail and another way in a tier without it.
+ *
+ * So the corpus is held to its own contract: a headword CC-CEDICT knows only as
+ * the 繁體 spelling of a different 简体 word contributes no entry, and the word
+ * keeps the reading CC-CEDICT pairs it with. It is 72 headwords, 13 of which
+ * the corpus reads wrongly; the other 59 arrive at the same reading either way.
+ *
+ * Narrow on purpose. 2,854 corpus headwords contain a 繁體-only character and
+ * only these 72 are ones CC-CEDICT pairs — the rest are rare or mixed-script
+ * words whose characters do read them, and dropping those would lose coverage
+ * to fix nothing.
+ */
+export function isSpeltTraditionally(word, byWord, byHant) {
+    if (byWord.has(word)) {
+        return false;
+    }
+    return (byHant.get(word) ?? []).some((entry) => entry.simplified !== entry.traditional);
+}
+/**
+ * CC-CEDICT's entries for a word, keyed by one of its two written forms.
+ */
+export function indexCedict(cedict, formOf) {
+    const byWord = new Map();
+    for (const entry of cedict) {
+        const form = formOf(entry);
+        const existing = byWord.get(form);
+        if (existing === undefined) {
+            byWord.set(form, [entry]);
+        }
+        else {
+            existing.push(entry);
+        }
+    }
+    return byWord;
+}
+/**
+ * A word's readings as CC-CEDICT gives them, one per sense.
+ */
+export function cedictReadingsOf(word, entries) {
+    return entries
+        .map((entry) => readDictionaryReading(word, entry.readings))
+        .filter((reading) => reading !== undefined);
+}
+/**
+ * Ask either index for every reading CC-CEDICT gives a spelling.
+ *
+ * Both scripts, because a word can be listed under one and not the other, and
+ * an empty answer means CC-CEDICT does not hold the spelling at all.
+ */
+export function senseLookup(byWord, byHant) {
+    return (word) => [
+        ...cedictReadingsOf(word, byWord.get(word) ?? []),
+        ...cedictReadingsOf(word, byHant.get(word) ?? []),
+    ];
+}
+/**
+ * Whether a proposed 國語 reading is really another 普通话 sense of the word.
+ *
+ * The test that separates a locale shift from a sense selection, which the
+ * sources write the same way and mean differently. 地 is offered `dì` against a
+ * 普通话 `de` — but CC-CEDICT lists 地[de5] and 地[di4] as two entries, so `dì`
+ * is what 地 reads in 普通话 when it means the ground, not what 國語 does to the
+ * particle. The adverbial 地 is `de` in Taipei too, and 4,240 entries end in it.
+ * 都 is the same shape, and so are 着, 应, 差, 称, 斗, 舍, 薄 and 万.
+ *
+ * A genuine delta leaves no such trace: nothing in 普通话 reads 和 as `hàn`, 期
+ * as `qí` or 垃 as `lè`, which is why those survive this and 71 characters and
+ * 3 words do not.
+ *
+ * Only CC-CEDICT is consulted. Unihan's reading fields carry rare and historical
+ * pronunciations alongside current ones — 驯 is listed `xún` somewhere in them —
+ * and a reading no one uses today is not evidence that a source meant a sense
+ * rather than a locale.
+ */
+export function isOwnSense(taiwan, senseReadings) {
+    return senseReadings.some((sense) => isSameReading(sense, taiwan));
+}
+/**
+ * Whether a character's `Taiwan pr.` note describes one sense rather than the
+ * character.
+ *
+ * The other half of the sense test, and the one {@link isOwnSense} cannot do.
+ * That test asks whether the offered reading is a 普通话 sense of the word; this
+ * asks whether the note was ever about the whole word to begin with. 從's
+ * `Taiwan pr. [zong4]` sits on three of its eight senses — 侍從, 從兄弟, 從犯 —
+ * and 教育部's dictionary agrees with CC-CEDICT about which: 跟隨, 依順, 參與 and
+ * the preposition are `cóng` in Taipei exactly as they are in Beijing. Applying
+ * it to the headword made 我从北京来 read `wǒ zòng Běijīng lái`. 會 (`huǐ`, only
+ * 一會兒), 勞 (`lào`, only 慰勞) and 燥 (`sào`, only 肉燥) are the same shape.
+ *
+ * A note the entry leads with is kept, because the leading sense is what the
+ * character means with nothing to narrow it: 和's `hàn` is on the conjunction,
+ * which is what a bare 和 almost always is.
+ *
+ * **Only a character is tested this way.** Its entry is what every occurrence
+ * no longer word covers falls back to, so it has to carry the reading that
+ * survives out of context; a multi-character headword is reached only where
+ * that exact word is written. Four of them carry an inline note — 相親, 載具,
+ * 高挑 and 樂色 — and only 相親 has senses that differ, its dominant one being
+ * the matchmaking sense that really is `xiàngqīn`.
+ */
+export function isSenseScopedNote(word, sense) {
+    return sense?.taiwanScope === "sense" && isSingleCharacter(word);
+}
+//# sourceMappingURL=cedict-senses.js.map

package/dist/dictionary/cedict-senses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cedict-senses.js","sourceRoot":"","sources":["../../src/dictionary/cedict-senses.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAG5D,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAC;AAErD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAY,EACZ,MAAmD,EACnD,MAAmD;IAEnD,IAAI,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;QACrB,OAAO,KAAK,CAAC;IACf,CAAC;IACD,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,IAAI,CAClC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,UAAU,KAAK,KAAK,CAAC,WAAW,CAClD,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,WAAW,CACzB,MAA8B,EAC9B,MAAsC;IAEtC,MAAM,MAAM,GAAG,IAAI,GAAG,EAAyB,CAAC;IAChD,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;QAC3B,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAClC,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;YAC3B,MAAM,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC;QAC5B,CAAC;aAAM,CAAC;YACN,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACvB,CAAC;IACH,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAC9B,IAAY,EACZ,OAA+B;IAE/B,OAAO,OAAO;SACX,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,qBAAqB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAC;SAC3D,MAAM,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,KAAK,SAAS,CAAC,CAAC;AAChD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,MAAmD,EACnD,MAAmD;IAEnD,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;QACf,GAAG,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;QACjD,GAAG,gBAAgB,CAAC,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,EAAE,CAAC;KAClD,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,UAAU,UAAU,CACxB,MAA2B,EAC3B,aAA+C;IAE/C,OAAO,aAAa,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,aAAa,CAAC,KAAK,EAAE,MAAM,CAAC,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAY,EACZ,KAA8B;IAE9B,OAAO,KAAK,EAAE,WAAW,KAAK,OAAO,IAAI,iBAAiB,CAAC,IAAI,CAAC,CAAC;AACnE,CAAC"}

package/dist/dictionary/character-defaults.d.ts

@@ -0,0 +1,26 @@
+import type { CedictEntry } from "../sources/cedict.js";
+import type { Syllable } from "../syllable/syllable.js";
+import { TraditionalTable } from "./traditional.js";
+import type { MergeSources } from "./merge-types.js";
+/**
+ * Parse a Unihan reading string for one character.
+ *
+ * Goes through the dictionary reader so that a Unihan reading gets the same
+ * treatment as any other source's: an unmarked tone means neutral, and 一 and
+ * 不 are restored to their underlying tones.
+ */
+export declare function characterSyllable(character: string, reading: string): Syllable | undefined;
+/**
+ * The 繁體 table and the character defaults, with the count of defaults a
+ * reduced 轻声 would otherwise have set.
+ */
+export interface CharacterDefaults {
+    readonly traditional: TraditionalTable;
+    readonly defaults: ReadonlyMap<string, readonly Syllable[]>;
+    readonly reducedNeutrals: number;
+}
+/**
+ * Build both, from the sources and CC-CEDICT's two indexes.
+ */
+export declare function buildCharacterDefaults(sources: MergeSources, cedictByWord: ReadonlyMap<string, readonly CedictEntry[]>, cedictByHant: ReadonlyMap<string, readonly CedictEntry[]>): CharacterDefaults;
+//# sourceMappingURL=character-defaults.d.ts.map

package/dist/dictionary/character-defaults.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-defaults.d.ts","sourceRoot":"","sources":["../../src/dictionary/character-defaults.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACxD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,EAGL,gBAAgB,EACjB,MAAM,kBAAkB,CAAC;AAC1B,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAErD;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC/B,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,GACd,QAAQ,GAAG,SAAS,CAEtB;AAED;;;GAGG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,WAAW,EAAE,gBAAgB,CAAC;IACvC,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,QAAQ,EAAE,CAAC,CAAC;IAC5D,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;CAClC;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CACpC,OAAO,EAAE,YAAY,EACrB,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC,EACzD,YAAY,EAAE,WAAW,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC,GACxD,iBAAiB,CAiDnB"}

package/dist/dictionary/character-defaults.js

@@ -0,0 +1,67 @@
+/**
+ * What every later step of the merge leans on: the 繁體 pairing table and each
+ * character's default reading.
+ *
+ * Both come out of the sources alone, before a single word has been looked at,
+ * and the order matters — the corpus mass the defaults are ranked by reaches
+ * 繁體 characters only through the pairing table.
+ */
+import { countCorpusMass, rankByCorpusMass } from "./corpus-mass.js";
+import { demoteReducedNeutrals, isNeutralAlone, resolveFrequencyTones, } from "./frequency-tones.js";
+import { readAlignedReading, readDictionaryReading } from "./reading.js";
+import { pairScripts, TraditionalTable, } from "./traditional.js";
+/**
+ * Parse a Unihan reading string for one character.
+ *
+ * Goes through the dictionary reader so that a Unihan reading gets the same
+ * treatment as any other source's: an unmarked tone means neutral, and 一 and
+ * 不 are restored to their underlying tones.
+ */
+export function characterSyllable(character, reading) {
+    return readDictionaryReading(character, [reading])?.[0];
+}
+/**
+ * Build both, from the sources and CC-CEDICT's two indexes.
+ */
+export function buildCharacterDefaults(sources, cedictByWord, cedictByHant) {
+    const { unihanReadings, unihanVariants, phrase, cedict, jieba } = sources;
+    // ── 繁體 evidence, mined from CC-CEDICT's own pairings ──────
+    // Before the character defaults, because the corpus mass those are ranked by
+    // has to reach 繁體 characters through this table: jieba's corpus and the
+    // phrase corpus are both 简体, so nothing else would count a vote for 髮.
+    const pairings = [];
+    for (const entry of cedict) {
+        const aligned = readAlignedReading(entry.simplified, entry.readings);
+        pairings.push(...pairScripts(entry.simplified, entry.traditional, aligned));
+    }
+    const traditional = TraditionalTable.build(pairings, unihanVariants, unihanReadings);
+    // ── Character defaults, which every later step leans on ────
+    // Unihan ranks the readings and the corpus re-ranks the ones it has seen: a
+    // character's default is whichever of its readings the dictionary's own words
+    // spend the most of jieba's corpus on, and Unihan's order decides the rest.
+    const mass = countCorpusMass({ phrase, cedict, jieba }, traditional);
+    const defaults = new Map();
+    let reducedNeutrals = 0;
+    for (const [character, readings] of unihanReadings) {
+        const resolved = resolveFrequencyTones(readings);
+        // A 轻声 the frequency field only ever counted inside words is not the
+        // character's reading — unless a source says the bare character is neutral.
+        const ranked = isNeutralAlone(character, [
+            ...(cedictByWord.get(character) ?? []),
+            ...(cedictByHant.get(character) ?? []),
+        ])
+            ? resolved
+            : demoteReducedNeutrals(readings, resolved);
+        if (ranked !== resolved && ranked[0] !== resolved[0]) {
+            reducedNeutrals++;
+        }
+        const parsed = ranked
+            .map((reading) => characterSyllable(character, reading))
+            .filter((syllable) => syllable !== undefined);
+        if (parsed.length > 0) {
+            defaults.set(character, rankByCorpusMass(character, parsed, readings.fields, mass));
+        }
+    }
+    return { traditional, defaults, reducedNeutrals };
+}
+//# sourceMappingURL=character-defaults.js.map

package/dist/dictionary/character-defaults.js.map

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

package/dist/dictionary/character-readings.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Single characters whose default reading a source would otherwise get wrong.
+ *
+ * Two source quirks between them: the 简体 phrase corpus carrying a 繁體
+ * headword and reading it as though the characters were 简体, and Unihan's
+ * frequency field counting a 轻声 that only occurs inside words.
+ */
+import type { BuildAssertion } from "./built-dictionary.js";
+export declare const CHARACTER_READINGS: readonly BuildAssertion[];
+//# sourceMappingURL=character-readings.d.ts.map

package/dist/dictionary/character-readings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-readings.d.ts","sourceRoot":"","sources":["../../src/dictionary/character-readings.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,eAAO,MAAM,kBAAkB,EAAE,SAAS,cAAc,EAsBvD,CAAC"}

package/dist/dictionary/character-readings.js

@@ -0,0 +1,25 @@
+import { reads } from "./word-readings.js";
+export const CHARACTER_READINGS = [
+    // The 简体 phrase corpus carries a few 繁體 headwords and reads them as
+    // though the characters were 简体 — 徵 as `zhǐ` rather than as 征, 沈 as the
+    // surname rather than as 沉. Left as entries of their own they outrank the
+    // 繁體 key derived from the 简体 entry, and the word reads one way in a tier
+    // holding the phrase tail and another way in a tier without it.
+    reads("特徵", "tè zhēng", "not tè zhǐ, which is 徵 read as itself"),
+    reads("沈溺", "chén nì", "not shěn nì, which is 沈 read as the surname"),
+    reads("蝨子", "shī zi", "not shī zǐ, which is 子 read with its full tone"),
+    // kHanyuPinlu writes 李 as `li(36)`, with no tone mark. Read as 轻声 — which
+    // is what an unmarked reading means everywhere else in source data — 李华
+    // comes out `Li Huá`. The other Unihan fields all write `lǐ`, and that is
+    // what settles it. 们 is the control: genuinely neutral, and written bare by
+    // the other fields too, so it must not be "corrected".
+    reads("李", "lǐ", "a tone kHanyuPinlu left off is restored"),
+    reads("们", "men", "a genuine 轻声 is not given a tone it never had"),
+    reads("吧", "ba", "the 语气词, not the 酒吧 the corpus mass counts"),
+    reads("酒吧", "jiǔ bā", "and the word the character keeps its full tone in"),
+    reads("西", "xī", "a 轻声 counted only inside words does not lead"),
+    reads("子", "zǐ", "and a suffix sense is not a claim about the character"),
+    reads("夫", "fū", "nor is 大夫's and 丈夫's reduction"),
+    reads("吗", "ma", "but a 语气词 CC-CEDICT reads 轻声 alone keeps it"),
+];
+//# sourceMappingURL=character-readings.js.map

package/dist/dictionary/character-readings.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-readings.js","sourceRoot":"","sources":["../../src/dictionary/character-readings.ts"],"names":[],"mappings":"AAQA,OAAO,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAE3C,MAAM,CAAC,MAAM,kBAAkB,GAA8B;IAC3D,oEAAoE;IACpE,wEAAwE;IACxE,0EAA0E;IAC1E,yEAAyE;IACzE,gEAAgE;IAChE,KAAK,CAAC,IAAI,EAAE,UAAU,EAAE,uCAAuC,CAAC;IAChE,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,6CAA6C,CAAC;IACrE,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,gDAAgD,CAAC;IACvE,0EAA0E;IAC1E,wEAAwE;IACxE,0EAA0E;IAC1E,4EAA4E;IAC5E,uDAAuD;IACvD,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,yCAAyC,CAAC;IAC3D,KAAK,CAAC,GAAG,EAAE,KAAK,EAAE,+CAA+C,CAAC;IAClE,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,4CAA4C,CAAC;IAC9D,KAAK,CAAC,IAAI,EAAE,QAAQ,EAAE,mDAAmD,CAAC;IAC1E,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,8CAA8C,CAAC;IAChE,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,uDAAuD,CAAC;IACzE,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,gCAAgC,CAAC;IAClD,KAAK,CAAC,GAAG,EAAE,IAAI,EAAE,6CAA6C,CAAC;CAChE,CAAC"}

package/dist/dictionary/constituent-repair.d.ts

@@ -0,0 +1,36 @@
+import type { Syllable } from "../syllable/syllable.js";
+import { type DictionaryEntry } from "./entry.js";
+/**
+ * What the repair pass changed.
+ */
+export interface ConstituentRepair {
+    readonly entries: readonly DictionaryEntry[];
+    /** Entries given a reading from a word inside them. */
+    readonly repaired: number;
+}
+/**
+ * Read a phrase entry as the corroborated words inside it read it.
+ *
+ * 做什么 is stored `zuò shí mǒ` upstream, and 什么 is `shén me` in the same file
+ * and in CC-CEDICT besides. The decode has no way back from that: the four
+ * characters are one dictionary key, so the key answers and the word inside it
+ * is never asked. 什么意思, 不记得 and 这么说 are the same defect, and between
+ * them they account for 160 of the 290 sentences a downstream corpus of 13,182
+ * reported as misread.
+ *
+ * The pass runs over entries **nothing but the phrase corpus attests** — no
+ * CC-CEDICT headword under either script, no jieba frequency — and takes each
+ * one's constituents from `ConstituentIndex`, the same segmentation the locale
+ * composition uses. Only a constituent CC-CEDICT holds may correct anything, so
+ * this never trades one uncorroborated reading for another. What survives
+ * {@link corrects} replaces the span it covers.
+ *
+ * Measured on the full dictionary it repairs 1,727 entries of the 250,417 it
+ * looks at. Sampled by hand at every 61st, the repairs are neutral tones the
+ * corpus wrote out in full (骨头, 大夫, 秀才, 和尚), spellings it got wrong
+ * (相扑 `xiàng pū`, 武侯 `wǔ hòu`, 用尽 `yòng jǐn`) and one entry with no tones
+ * at all (激昂青云). The doubtful ones are homographs either reading is
+ * defensible for: 倒数比 and 面糊盆.
+ */
+export declare function repairConstituentReadings(entries: readonly DictionaryEntry[], sensesOf: (word: string) => readonly (readonly Syllable[])[]): ConstituentRepair;
+//# sourceMappingURL=constituent-repair.d.ts.map

package/dist/dictionary/constituent-repair.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constituent-repair.d.ts","sourceRoot":"","sources":["../../src/dictionary/constituent-repair.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAE,KAAK,eAAe,EAAiB,MAAM,YAAY,CAAC;AAGjE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,uDAAuD;IACvD,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AA0CD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,yBAAyB,CACvC,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,GAC3D,iBAAiB,CAmDnB"}

package/dist/dictionary/constituent-repair.js

@@ -0,0 +1,117 @@
+/**
+ * Holding a phrase entry to what the words inside it already read.
+ *
+ * The phrase corpus is a reading source and not a word list, and 251,528 of its
+ * 411,956 keys are in neither CC-CEDICT nor jieba. Much of that tail is running
+ * text rather than vocabulary — 做什么, 什么意思, 不记得, 一个幽灵在欧洲游荡 —
+ * and where a key like that carries a defective reading there is nothing to
+ * correct it against, because `settleReading` compares a phrase entry with the
+ * CC-CEDICT sense of the *same* headword and CC-CEDICT has no such headword.
+ *
+ * This is that missing correction, taken from the words inside instead.
+ */
+import { toCharacters } from "../script/characters.js";
+import { NEUTRAL_TONE } from "../tone/tone.js";
+import { isSameReading } from "./entry.js";
+import { ConstituentIndex } from "./locale-segments.js";
+/**
+ * Whether a constituent may correct the span it covers.
+ *
+ * Four tests, and each one rules out a class of damage:
+ *
+ * 1. **Multi-character only.** A character's own reading is the prior the
+ *    phrase entry was built from, so correcting against it says nothing new.
+ *    It is the same reasoning `composeLocaleDeltas` gives for the same
+ *    restriction.
+ * 2. **One syllable per character on both sides**, or the two readings are not
+ *    describing the same span character for character.
+ * 3. **The span must match no sense CC-CEDICT gives the constituent.** A word
+ *    with two readings has two senses, and a phrase using the other one is
+ *    right: 分子 is `fēn zǐ` as a molecule and `fèn zǐ` as a member, so
+ *    分子结构 keeps the reading it was given. The build's tier check found this
+ *    one, which is what that check is for.
+ * 4. **No 轻声 may gain a tone.** The phrase corpus writes full tones where
+ *    CC-CEDICT has neutral and never the reverse, so a correction pushing the
+ *    other way is not a correction at all — it is a constituent that fell
+ *    across a boundary. Every 地 in the 268 entries this rules out is the
+ *    adverbial particle, and the words claiming it are 心地, 性地 and 野地.
+ */
+function corrects(part, span, own, senses) {
+    if (toCharacters(part.text).length < 2 || own.length !== span.length) {
+        return false;
+    }
+    if (senses.some((sense) => isSameReading(sense, span))) {
+        return false;
+    }
+    return !span.some((syllable, at) => syllable.tone === NEUTRAL_TONE && own[at]?.tone !== NEUTRAL_TONE);
+}
+/**
+ * Read a phrase entry as the corroborated words inside it read it.
+ *
+ * 做什么 is stored `zuò shí mǒ` upstream, and 什么 is `shén me` in the same file
+ * and in CC-CEDICT besides. The decode has no way back from that: the four
+ * characters are one dictionary key, so the key answers and the word inside it
+ * is never asked. 什么意思, 不记得 and 这么说 are the same defect, and between
+ * them they account for 160 of the 290 sentences a downstream corpus of 13,182
+ * reported as misread.
+ *
+ * The pass runs over entries **nothing but the phrase corpus attests** — no
+ * CC-CEDICT headword under either script, no jieba frequency — and takes each
+ * one's constituents from `ConstituentIndex`, the same segmentation the locale
+ * composition uses. Only a constituent CC-CEDICT holds may correct anything, so
+ * this never trades one uncorroborated reading for another. What survives
+ * {@link corrects} replaces the span it covers.
+ *
+ * Measured on the full dictionary it repairs 1,727 entries of the 250,417 it
+ * looks at. Sampled by hand at every 61st, the repairs are neutral tones the
+ * corpus wrote out in full (骨头, 大夫, 秀才, 和尚), spellings it got wrong
+ * (相扑 `xiàng pū`, 武侯 `wǔ hòu`, 用尽 `yòng jǐn`) and one entry with no tones
+ * at all (激昂青云). The doubtful ones are homographs either reading is
+ * defensible for: 倒数比 and 面糊盆.
+ */
+export function repairConstituentReadings(entries, sensesOf) {
+    const index = new ConstituentIndex(entries);
+    let repaired = 0;
+    const repair = (entry) => {
+        const reading = entry.readings.cn;
+        if (entry.frequency > 0 ||
+            sensesOf(entry.hans).length > 0 ||
+            sensesOf(entry.hant).length > 0 ||
+            reading.length !== toCharacters(entry.hans).length ||
+            reading.length < 2) {
+            return entry;
+        }
+        const path = index.segment(entry.hans);
+        if (path === undefined) {
+            return entry;
+        }
+        let corrected = [...reading];
+        let isMoved = false;
+        for (const part of path) {
+            const own = part.entry.readings.cn;
+            const senses = [
+                ...sensesOf(part.entry.hans),
+                ...sensesOf(part.entry.hant),
+            ];
+            if (senses.length === 0) {
+                continue;
+            }
+            if (!corrects(part, reading.slice(part.from, part.to), own, senses)) {
+                continue;
+            }
+            corrected = [
+                ...corrected.slice(0, part.from),
+                ...own,
+                ...corrected.slice(part.to),
+            ];
+            isMoved = true;
+        }
+        if (!isMoved) {
+            return entry;
+        }
+        repaired++;
+        return { ...entry, readings: { ...entry.readings, cn: corrected } };
+    };
+    return { entries: entries.map((entry) => repair(entry)), repaired };
+}
+//# sourceMappingURL=constituent-repair.js.map

package/dist/dictionary/constituent-repair.js.map

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

package/dist/dictionary/dictionary-entry.d.ts

@@ -0,0 +1,37 @@
+import type { Syllable } from "../syllable/syllable.js";
+/**
+ * What the dictionary knows about one word.
+ */
+export interface WordEntry {
+    readonly word: string;
+    /** 普通话 reading. */
+    readonly reading: readonly Syllable[];
+    /** 國語 reading, absent when it does not differ. */
+    readonly taiwanReading?: readonly Syllable[];
+    readonly partOfSpeech: string;
+    readonly isProperNoun: boolean;
+    /**
+     * Where a proper name divides into its parts, in characters.
+     *
+     * Present only where CC-CEDICT's own capitalisation divides it: 齐白石 is
+     * `[Qi2 Bai2 shi2]`, 司马迁 `[Si1 ma3 Qian1]`, 上海交通大学
+     * `[Shang4 hai3 Jiao1 tong1 Da4 xue2]`. Absent for 马克思 `[Ma3 ke4 si1]`,
+     * which is why a transliteration stays one word.
+     */
+    readonly nameBoundaries?: readonly number[];
+    /**
+     * Decoding cost, where lower means more likely.
+     *
+     * Quantised from the corpus frequency; see
+     * {@link import("./frequency-table.js").FrequencyTable.costOf}.
+     */
+    readonly cost: number;
+}
+/**
+ * Decode one line's columns into an entry.
+ *
+ * `readingOf` is asked for a single character's stored reading, and is only
+ * reached where the line's own reading column is empty.
+ */
+export declare function decodeEntry(word: string, columns: readonly string[], readingOf: (character: string) => string | undefined, cost: number): WordEntry;
+//# sourceMappingURL=dictionary-entry.d.ts.map

package/dist/dictionary/dictionary-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionary-entry.d.ts","sourceRoot":"","sources":["../../src/dictionary/dictionary-entry.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIxD;;GAEG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,mBAAmB;IACnB,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,kDAAkD;IAClD,QAAQ,CAAC,aAAa,CAAC,EAAE,SAAS,QAAQ,EAAE,CAAC;IAC7C,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B;;;;;;;OAOG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5C;;;;;OAKG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,SAAS,EAAE,CAAC,SAAS,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,EACpD,IAAI,EAAE,MAAM,GACX,SAAS,CAwBX"}

package/dist/dictionary/dictionary-entry.js

@@ -0,0 +1,41 @@
+/**
+ * What one line of the entry blob means, once it is read as a word.
+ *
+ * The blob is columns of text and `Dictionary` is a store of words; this is
+ * where the one becomes the other. It is worth its own module because the
+ * decode is the only part of a lookup that knows the artifact's encoding — the
+ * flag letters, the boundary notation, the empty reading that means "derive it"
+ * — and none of that should be visible to the index and caching around it.
+ */
+import { toCharacters } from "../script/characters.js";
+import { decodeReading } from "./artifact.js";
+import { nameBoundariesIn, PROPER_NOUN_FLAG } from "./artifact-format.js";
+/**
+ * Decode one line's columns into an entry.
+ *
+ * `readingOf` is asked for a single character's stored reading, and is only
+ * reached where the line's own reading column is empty.
+ */
+export function decodeEntry(word, columns, readingOf, cost) {
+    const [reading = "", taiwan = "", partOfSpeech = "", flags = ""] = columns;
+    // An empty reading means the word is read as its characters' defaults,
+    // which is how 87.8% of multi-character entries are stored.
+    const encoded = reading === ""
+        ? toCharacters(word)
+            .map((character) => readingOf(character) ?? "")
+            .join(" ")
+        : reading;
+    const decoded = decodeReading(encoded) ?? [];
+    const taiwanReading = decodeReading(taiwan);
+    const nameBoundaries = nameBoundariesIn(flags);
+    return {
+        word,
+        reading: decoded,
+        ...(taiwanReading !== undefined && { taiwanReading }),
+        partOfSpeech,
+        isProperNoun: flags.includes(PROPER_NOUN_FLAG),
+        ...(nameBoundaries.length > 0 && { nameBoundaries }),
+        cost,
+    };
+}
+//# sourceMappingURL=dictionary-entry.js.map

package/dist/dictionary/dictionary-entry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionary-entry.js","sourceRoot":"","sources":["../../src/dictionary/dictionary-entry.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAEvD,OAAO,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAC9C,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AA+B1E;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CACzB,IAAY,EACZ,OAA0B,EAC1B,SAAoD,EACpD,IAAY;IAEZ,MAAM,CAAC,OAAO,GAAG,EAAE,EAAE,MAAM,GAAG,EAAE,EAAE,YAAY,GAAG,EAAE,EAAE,KAAK,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC;IAE3E,uEAAuE;IACvE,4DAA4D;IAC5D,MAAM,OAAO,GACX,OAAO,KAAK,EAAE;QACZ,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC;aACf,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,SAAS,CAAC,IAAI,EAAE,CAAC;aAC9C,IAAI,CAAC,GAAG,CAAC;QACd,CAAC,CAAC,OAAO,CAAC;IACd,MAAM,OAAO,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,CAAC;IAC7C,MAAM,aAAa,GAAG,aAAa,CAAC,MAAM,CAAC,CAAC;IAC5C,MAAM,cAAc,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;IAE/C,OAAO;QACL,IAAI;QACJ,OAAO,EAAE,OAAO;QAChB,GAAG,CAAC,aAAa,KAAK,SAAS,IAAI,EAAE,aAAa,EAAE,CAAC;QACrD,YAAY;QACZ,YAAY,EAAE,KAAK,CAAC,QAAQ,CAAC,gBAAgB,CAAC;QAC9C,GAAG,CAAC,cAAc,CAAC,MAAM,GAAG,CAAC,IAAI,EAAE,cAAc,EAAE,CAAC;QACpD,IAAI;KACL,CAAC;AACJ,CAAC"}

package/dist/dictionary/dictionary-readings.d.ts

@@ -0,0 +1,56 @@
+/**
+ * The readings the entry blob holds, short of decoding a whole entry.
+ *
+ * Three questions that all stop at the reading columns: what one key is read
+ * as, what every key is read as, and what else a character can be read as. None
+ * of them wants the other four columns, and the first two never leave the
+ * string level at all — which is what makes a pass over all 723,147 keys
+ * affordable at load time, and what keeps the entry decoder out of this path.
+ */
+import type { Syllable } from "../syllable/syllable.js";
+import type { EntryLines } from "./entry-lines.js";
+import type { KeyIndex } from "./key-index.js";
+/**
+ * The stored reading of a key, or undefined when it is not a key.
+ *
+ * Read from the blob without decoding the rest of the line, since deriving a
+ * word's reading needs its characters' readings and nothing else about them.
+ */
+export declare function storedReadingOf(index: KeyIndex, lines: EntryLines, word: string): string | undefined;
+/**
+ * The other readings recorded on a line, after the one the entry names.
+ *
+ * The lattice needs these for its single-character fallback edges: 行 has to
+ * offer `xíng`, `háng` and `héng` at a position no word covers.
+ */
+export declare function alternateReadings(lines: EntryLines, at: number): readonly (readonly Syllable[])[];
+/**
+ * Every key's reading, in key order, at the string level.
+ *
+ * The seam a second index over the same artifact is built through.
+ *
+ * Handed out as a cursor rather than as an array because the array is 39 MB on
+ * the full tier. What the cursor holds instead is the character defaults a
+ * derived reading is assembled from, and dropping it releases them.
+ */
+export interface DictionaryReadings {
+    /** How many positions there are, which is the dictionary's own size. */
+    readonly size: number;
+    /**
+     * The reading at a position, in the artifact's tone-numbered spelling.
+     *
+     * Empty where the position is out of range, or where a character the word is
+     * written with is not itself a key.
+     */
+    readonly readingAt: (at: number) => string;
+}
+/**
+ * A cursor over every key's reading, in key order.
+ *
+ * Two passes, mirroring `readArtifact`: the character defaults are gathered
+ * first, because 83.25% of the full tier's keys store no reading and mean "the
+ * characters' defaults, in order". Holding the cursor holds those defaults, so
+ * build what needs it, use it, and let it go.
+ */
+export declare function readingsCursor(index: KeyIndex, lines: EntryLines): DictionaryReadings;
+//# sourceMappingURL=dictionary-readings.d.ts.map

package/dist/dictionary/dictionary-readings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dictionary-readings.d.ts","sourceRoot":"","sources":["../../src/dictionary/dictionary-readings.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAI/C;;;;;GAKG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,QAAQ,EACf,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM,GACX,MAAM,GAAG,SAAS,CAGpB;AAED;;;;;GAKG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,UAAU,EACjB,EAAE,EAAE,MAAM,GACT,SAAS,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,CAKlC;AAmDD;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,CAAC;CAC5C;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,QAAQ,EACf,KAAK,EAAE,UAAU,GAChB,kBAAkB,CAiBpB"}