@kensio/pinyinjs 1.7.4 → 1.7.5

package/dist/dictionary/cedict-senses.js

@@ -0,0 +1,114 @@
+/**
+ * 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);
+}
+/**
+ * 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;;;;;;;;;;;;;;;;;;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/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"}

package/dist/dictionary/dictionary-readings.js

@@ -0,0 +1,93 @@
+import { decodeReading } from "./artifact.js";
+const ALTERNATE = ",";
+/**
+ * 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 function storedReadingOf(index, lines, word) {
+    const found = index.lookup(word);
+    return found.isKey ? (lines.columnsAt(found.index)[0] ?? "") : 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 function alternateReadings(lines, at) {
+    return (lines.columnsAt(at)[4] ?? "")
+        .split(ALTERNATE)
+        .map((text) => decodeReading(text))
+        .filter((reading) => reading !== undefined);
+}
+/**
+ * The lowest code unit that begins a surrogate pair.
+ */
+const HIGH_SURROGATE = 0x1_00_00;
+/**
+ * Whether a key is written with exactly one character, without allocating.
+ *
+ * Asked of every key in the dictionary when {@link readingsCursor} gathers the
+ * character defaults, which is where splitting each key into characters would
+ * cost an array per key for an answer that is a length check.
+ */
+function isOneCharacter(key) {
+    if (key.length === 1) {
+        return true;
+    }
+    return key.length === 2 && (key.codePointAt(0) ?? 0) >= HIGH_SURROGATE;
+}
+/**
+ * A word's reading, joined from its characters' default readings.
+ *
+ * Walked by code point rather than split into characters first, for the same
+ * reason as {@link isOneCharacter}: this runs over every key in the dictionary
+ * three times during a reverse index build, and the array `toCharacters`
+ * allocates per key is 20% of it.
+ *
+ * Returns the empty string where any character has no default, which is what a
+ * tier missing a character would look like. No tier does: `selectTier` never
+ * drops a character some word is written with.
+ */
+function derivedReading(key, defaults) {
+    let joined = "";
+    let at = 0;
+    while (at < key.length) {
+        const width = (key.codePointAt(at) ?? 0) >= HIGH_SURROGATE ? 2 : 1;
+        const value = defaults.get(key.slice(at, at + width));
+        if (value === undefined) {
+            return "";
+        }
+        joined = joined === "" ? value : `${joined} ${value}`;
+        at += width;
+    }
+    return joined;
+}
+/**
+ * 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 function readingsCursor(index, lines) {
+    const defaults = new Map();
+    for (let at = 0; at < index.size; at++) {
+        const key = index.keyAt(at);
+        const reading = isOneCharacter(key) ? lines.readingColumnAt(at) : "";
+        if (reading !== "") {
+            defaults.set(key, reading);
+        }
+    }
+    return {
+        size: index.size,
+        readingAt: (at) => {
+            const stored = lines.readingColumnAt(at);
+            return stored === "" ? derivedReading(index.keyAt(at), defaults) : stored;
+        },
+    };
+}
+//# sourceMappingURL=dictionary-readings.js.map

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

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

package/dist/dictionary/dictionary.d.ts

@@ -1,55 +1,9 @@
 import type { Syllable } from "../syllable/syllable.js";
-import { type DictionaryArtifact } from "./artifact.js";
-/**
- * Every key's reading, in key order, at the string level.
- *
- * The seam a second index over the same artifact is built through. A reading is
- * `yin2 hang2` on the way in and on the way out, and no {@link Syllable} is
- * constructed anywhere along it — which is what makes a pass over all 723,147
- * keys affordable at load time rather than a decode of the whole dictionary.
- *
- * 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;
-}
-/**
- * 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 FrequencyTable.costOf}.
-     */
-    readonly cost: number;
-}
+import type { DictionaryArtifact } from "./artifact.js";
+import { type WordEntry } from "./dictionary-entry.js";
+import { type DictionaryReadings } from "./dictionary-readings.js";
+export type { WordEntry } from "./dictionary-entry.js";
+export type { DictionaryReadings } from "./dictionary-readings.js";
 /**
  * A compiled dictionary, queried without being parsed.
  *
@@ -76,7 +30,7 @@ export declare class Dictionary {
      */
     static from(artifact: DictionaryArtifact): Dictionary;
     /**
-     * Scan the entry blob for its line starts. Use {@link Dictionary.from}.
+     * Wrap an artifact's blobs. Use {@link Dictionary.from}.
      */
     private constructor();
     /**
@@ -103,11 +57,6 @@ export declare class Dictionary {
     frequencyAt(at: number): number;
     /**
      * 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.
      */
     readingsInOrder(): DictionaryReadings;
     /**
@@ -129,9 +78,6 @@ export declare class Dictionary {
     /**
      * Every reading a single character is known to take, most likely first.
      *
-     * 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.
-     *
      * The alternates are read off the canonical form's line, the same form
      * {@link Dictionary.lookup} found the entry under. Searching the index for
      * the raw character instead would land on the insertion point for a Hong Kong

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

@@ -1 +1 @@
-{"version":3,"file":"dictionary.d.ts","sourceRoot":"","sources":["../../src/dictionary/dictionary.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAiB,KAAK,kBAAkB,EAAE,MAAM,eAAe,CAAC;AA0EvE;;;;;;;;;;;GAWG;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;;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;;;;OAIG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;;IACrB;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,kBAAkB,GAAG,UAAU,CAEpD;IAQD;;OAEG;IACH,OAAO,eAiBN;IA+ED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzB;IAED;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE9B;IAED;;;;;;;OAOG;IACH,eAAe,IAAI,kBAAkB,CAmBpC;IAED;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/B;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAa1C;IAED;;;;;;;;;;;OAWG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,CAW9D;CACF"}
+{"version":3,"file":"dictionary.d.ts","sourceRoot":"","sources":["../../src/dictionary/dictionary.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACxD,OAAO,EAAe,KAAK,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACpE,OAAO,EAEL,KAAK,kBAAkB,EAGxB,MAAM,0BAA0B,CAAC;AAKlC,YAAY,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AACvD,YAAY,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAEnE;;;;;;;;;;;;;;;;;;GAkBG;AACH,qBAAa,UAAU;;IACrB;;OAEG;IACH,MAAM,CAAC,IAAI,CAAC,QAAQ,EAAE,kBAAkB,GAAG,UAAU,CAEpD;IAOD;;OAEG;IACH,OAAO,eAON;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAEzB;IAED;;;;;;;OAOG;IACH,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAE9B;IAED;;OAEG;IACH,eAAe,IAAI,kBAAkB,CAEpC;IAED;;;;;OAKG;IACH,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE/B;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,CAkB1C;IAED;;;;;;;;OAQG;IACH,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC,SAAS,QAAQ,EAAE,CAAC,EAAE,CAO9D;CACF"}