@kensio/pinyinjs 1.7.3 → 1.7.5

package/dist/dictionary/frequency-tones.js

@@ -0,0 +1,128 @@
+import { FREQUENCY_FIELD } from "../sources/unihan.js";
+import { NEUTRAL_TONE } from "../tone/tone.js";
+import { readDictionaryReading } from "./reading.js";
+/**
+ * Strip the tone marks from a reading, for comparing two spellings.
+ */
+function tonelessReading(reading) {
+    return reading
+        .normalize("NFD")
+        .replaceAll(/[̀́̄̌]/gu, "")
+        .normalize("NFC");
+}
+/**
+ * Whether a reading carries a tone mark.
+ */
+function isToneMarked(reading) {
+    return tonelessReading(reading) !== reading;
+}
+/**
+ * Put back a tone that `kHanyuPinlu` left off.
+ *
+ * The frequency field writes some readings without their tone mark: 李 is
+ * `li(36)` there where every dictionary field writes `lǐ`. Read as 轻声 — which
+ * is what an unmarked reading means in source data — that makes 李华 come out
+ * `Li Huá`, and it is the only Unihan field this happens in.
+ *
+ * The other fields settle which it is. If they also write the spelling bare,
+ * the neutral tone is real and 么, 们, 吧, 裳 keep it. If every one of them
+ * writes it with a tone, the frequency field simply omitted the mark, and the
+ * tone is taken back. Measured over the real file, 3,799 characters have a
+ * `kHanyuPinlu` entry, 60 of those have only unmarked readings, and the split
+ * is 45 that should carry a tone against 15 genuine 轻声.
+ */
+export function resolveFrequencyTones(unihan) {
+    const frequencyReadings = unihan.fields.get(FREQUENCY_FIELD) ?? [];
+    // A character whose frequency field marks any tone is already trustworthy:
+    // there the unmarked readings sit alongside marked ones and mean 轻声.
+    if (frequencyReadings.length === 0 ||
+        frequencyReadings.some((reading) => isToneMarked(reading))) {
+        return unihan.readings;
+    }
+    const elsewhere = [...unihan.fields]
+        .filter(([field]) => field !== FREQUENCY_FIELD)
+        .flatMap(([, readings]) => readings);
+    return unihan.readings.map((reading) => {
+        if (isToneMarked(reading)) {
+            return reading;
+        }
+        const sameSpelling = elsewhere.filter((other) => tonelessReading(other) === reading);
+        if (sameSpelling.length === 0 || sameSpelling.includes(reading)) {
+            return reading;
+        }
+        return sameSpelling.find((other) => isToneMarked(other)) ?? reading;
+    });
+}
+/**
+ * A CC-CEDICT sense that describes a suffix rather than a word.
+ *
+ * Matches its own wording: 子 is `/noun suffix, as in 椅子[yi3 zi5] "chair"/`,
+ * and the other suffix senses are written the same way.
+ */
+const SUFFIX_SENSE = /\bsuffix\b/iu;
+/**
+ * Whether CC-CEDICT reads the bare character 轻声 in its own right.
+ *
+ * The exception to {@link demoteReducedNeutrals}, and the thing that separates
+ * a 语气词 from a syllable that is only ever unstressed inside a word. A
+ * single-character CC-CEDICT headword with a neutral reading is a claim about
+ * the character standing alone, which is exactly what the frequency field's
+ * counting cannot distinguish: 吗 is `(question particle for "yes-no"
+ * questions)`, 啊 is `modal particle ending sentence`, 得 is `structural
+ * particle: used after a verb`. Nine characters carry one — 得, 啊, 吗, 呀, 啦,
+ * 哇, 嘛, 罢 and 子 — and their 繁體 spellings with them.
+ *
+ * **A suffix sense is not such a claim.** 子's neutral headword is `noun
+ * suffix, as in 椅子`, which says the character is unstressed *in words*, and
+ * words are what the corpus can already see. 子 is `zǐ` on its own — 子曰, 母子
+ * — and CPP's human labelling has it `zi3` in 30 of its 38 cases.
+ *
+ * 罢 is the known loss. CC-CEDICT calls its `ba5` a final particle, so it is
+ * held here, and CPP labels the character `ba4` in all 40 of its cases: the
+ * particle is the literary 也罢 and 罢了, while a modern bare 罢 is 罢工. Left
+ * protected because the rule is about what a source claims of the character,
+ * and singling one out because a dataset disagrees is fitting to the dataset.
+ */
+export function isNeutralAlone(character, entries) {
+    return entries.some((entry) => {
+        const reading = readDictionaryReading(character, entry.readings);
+        return (reading?.length === 1 &&
+            reading[0]?.tone === NEUTRAL_TONE &&
+            !entry.definitions.some((definition) => SUFFIX_SENSE.test(definition)));
+    });
+}
+/**
+ * Demote a 轻声 the frequency field counted only inside words.
+ *
+ * `kHanyuPinlu` counts occurrences in running text, and a character's neutral
+ * count there mixes two unrelated things: a character that stands alone
+ * unstressed, and one reduced *inside a word*. Where the field writes the same
+ * spelling both bare and toned it is reporting that split with no way to say
+ * which is which — 西 is `xi(902) xī(738)`, and the 902 are 东西 — and since the
+ * field leads {@link import("../sources/unihan.js").READING_FIELDS}, the
+ * reduction became the character's reading. 西 read `xi`, so 往西 was `wǎng xi`;
+ * 夫 read `fu`, 识 `shi`, 拾 `shi`, 候 `hou`, 姐 `jie`, 友 `you`.
+ *
+ * So a bare spelling the field also writes with a tone ranks below that twin —
+ * demoted rather than dropped, keeping it as a candidate without letting it set
+ * the default, exactly as a lone `kHanyuPinlu` reading is. It reaches 50
+ * characters, and {@link isNeutralAlone} holds back the ones a source says are
+ * neutral on their own.
+ *
+ * The other half of the same blind spot is already handled: where the field
+ * marks *no* tone at all it omitted the mark rather than meaning 轻声, which is
+ * {@link resolveFrequencyTones}.
+ */
+export function demoteReducedNeutrals(unihan, readings) {
+    const frequency = unihan.fields.get(FREQUENCY_FIELD) ?? [];
+    const reduced = new Set(frequency.filter((reading) => !isToneMarked(reading) &&
+        frequency.some((other) => isToneMarked(other) && tonelessReading(other) === reading)));
+    if (reduced.size === 0) {
+        return readings;
+    }
+    return [
+        ...readings.filter((reading) => !reduced.has(reading)),
+        ...readings.filter((reading) => reduced.has(reading)),
+    ];
+}
+//# sourceMappingURL=frequency-tones.js.map

package/dist/dictionary/frequency-tones.js.map

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

package/dist/dictionary/inventory-invariants.d.ts

@@ -0,0 +1,3 @@
+import type { BuildAssertion } from "./built-dictionary.js";
+export declare const INVENTORY_INVARIANTS: readonly BuildAssertion[];
+//# sourceMappingURL=inventory-invariants.d.ts.map

package/dist/dictionary/inventory-invariants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"inventory-invariants.d.ts","sourceRoot":"","sources":["../../src/dictionary/inventory-invariants.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,cAAc,EAAmB,MAAM,uBAAuB,CAAC;AAE7E,eAAO,MAAM,oBAAoB,EAAE,SAAS,cAAc,EAgDzD,CAAC"}

package/dist/dictionary/inventory-invariants.js

@@ -0,0 +1,54 @@
+/**
+ * What must hold of every reading at once.
+ *
+ * Three sweeps: every syllable used is one the inventory knows, in a tone the
+ * inventory knows, and a reading is as long as the characters it reads.
+ */
+import { characterCount } from "../script/characters.js";
+import { DICTIONARY_SYLLABLES } from "../syllable/inventory.js";
+export const INVENTORY_INVARIANTS = [
+    {
+        // Membership rather than a count. MERGE.md asked for "exactly 408 after the
+        // merge", which is the phrase corpus's own inventory — but the merged
+        // dictionary also carries Unihan's and CC-CEDICT's rare characters, whose
+        // readings are legitimately outside it (鞥 ēng, 覅 fiào, 挼 ruá). Fixing the
+        // count would either exclude those or bless whatever a refresh adds; naming
+        // the permitted set does neither.
+        description: "every syllable used is one the inventory knows",
+        check: (dictionary) => {
+            const unknown = [...dictionary.syllableInventory()].filter((syllable) => !DICTIONARY_SYLLABLES.has(syllable));
+            return unknown.length === 0
+                ? undefined
+                : `readings use ${String(unknown.length)} syllable(s) outside the inventory: ${unknown.join(", ")}`;
+        },
+    },
+    {
+        // The romanisation readers narrow an ambiguous spelling on the tone that
+        // was written — `lo²` is 羅 luó and not a 咯 that is only ever neutral —
+        // so a tone the table has never heard of is a syllable those readers will
+        // refuse to hand back. Regenerate `SYLLABLE_TONES` when this fails.
+        description: "every syllable is used in a tone the inventory knows",
+        check: (dictionary) => {
+            const unattested = [...dictionary.unattestedTones()];
+            return unattested.length === 0
+                ? undefined
+                : `readings use ${String(unattested.length)} syllable(s) in a tone the inventory does not list: ${unattested.join(", ")}`;
+        },
+    },
+    {
+        description: "every entry's syllable count matches its character count",
+        check: (dictionary) => {
+            for (const entry of dictionary.entries) {
+                const characters = characterCount(entry.hans);
+                const erhua = entry.readings.cn.filter((syllable) => syllable.erhua === true).length;
+                // Punctuation is written but unread, so it is allowed to have no
+                // syllable; a reading may therefore be shorter but never longer.
+                if (entry.readings.cn.length + erhua > characters) {
+                    return `${entry.hans} has ${String(entry.readings.cn.length)} syllables for ${String(characters)} characters`;
+                }
+            }
+            return;
+        },
+    },
+];
+//# sourceMappingURL=inventory-invariants.js.map

package/dist/dictionary/inventory-invariants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"inventory-invariants.js","sourceRoot":"","sources":["../../src/dictionary/inventory-invariants.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAC;AAGhE,MAAM,CAAC,MAAM,oBAAoB,GAA8B;IAC7D;QACE,4EAA4E;QAC5E,sEAAsE;QACtE,0EAA0E;QAC1E,0EAA0E;QAC1E,4EAA4E;QAC5E,kCAAkC;QAClC,WAAW,EAAE,gDAAgD;QAC7D,KAAK,EAAE,CAAC,UAA2B,EAAsB,EAAE;YACzD,MAAM,OAAO,GAAG,CAAC,GAAG,UAAU,CAAC,iBAAiB,EAAE,CAAC,CAAC,MAAM,CACxD,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,oBAAoB,CAAC,GAAG,CAAC,QAAQ,CAAC,CAClD,CAAC;YACF,OAAO,OAAO,CAAC,MAAM,KAAK,CAAC;gBACzB,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,gBAAgB,MAAM,CAAC,OAAO,CAAC,MAAM,CAAC,uCAAuC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACxG,CAAC;KACF;IACD;QACE,yEAAyE;QACzE,uEAAuE;QACvE,0EAA0E;QAC1E,oEAAoE;QACpE,WAAW,EAAE,sDAAsD;QACnE,KAAK,EAAE,CAAC,UAA2B,EAAsB,EAAE;YACzD,MAAM,UAAU,GAAG,CAAC,GAAG,UAAU,CAAC,eAAe,EAAE,CAAC,CAAC;YACrD,OAAO,UAAU,CAAC,MAAM,KAAK,CAAC;gBAC5B,CAAC,CAAC,SAAS;gBACX,CAAC,CAAC,gBAAgB,MAAM,CAAC,UAAU,CAAC,MAAM,CAAC,uDAAuD,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QAC9H,CAAC;KACF;IACD;QACE,WAAW,EAAE,0DAA0D;QACvE,KAAK,EAAE,CAAC,UAA2B,EAAsB,EAAE;YACzD,KAAK,MAAM,KAAK,IAAI,UAAU,CAAC,OAAO,EAAE,CAAC;gBACvC,MAAM,UAAU,GAAG,cAAc,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;gBAC9C,MAAM,KAAK,GAAG,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CACpC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,KAAK,KAAK,IAAI,CACtC,CAAC,MAAM,CAAC;gBACT,iEAAiE;gBACjE,iEAAiE;gBACjE,IAAI,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,GAAG,KAAK,GAAG,UAAU,EAAE,CAAC;oBAClD,OAAO,GAAG,KAAK,CAAC,IAAI,QAAQ,MAAM,CAAC,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,CAAC,kBAAkB,MAAM,CAAC,UAAU,CAAC,aAAa,CAAC;gBAChH,CAAC;YACH,CAAC;YACD,OAAO;QACT,CAAC;KACF;CACF,CAAC"}

package/dist/dictionary/locale-candidates.d.ts

@@ -0,0 +1,40 @@
+import type { DictionaryEntry } from "./entry.js";
+/**
+ * Compounds whose constituent's 國語 reading must not be carried over.
+ *
+ * The composition below only fires where the compound reads its constituent
+ * exactly as that constituent's own entry does, which rules out most of the ways
+ * it could be wrong. What it cannot rule out is a homograph: two words spelled
+ * and read identically in 普通话, of which only one shifts in 國語. 相亲 is
+ * `xiāngqīn` either way when it means "mutually close" and `xiàngqīn` in Taiwan
+ * when it means a matchmaking meeting, and nothing in the data distinguishes the
+ * two senses.
+ *
+ * **Keep this small**, for the same reason
+ * {@link import("./overrides.js").READING_OVERRIDES} is kept small. Three
+ * exclusions against the 100 compounds the composition settles is the measured
+ * ratio; a list growing much past that would mean the alignment check has
+ * stopped carrying its weight and the rule itself needs revisiting.
+ */
+export declare const LOCALE_COMPOSITION_EXCLUSIONS: readonly {
+    readonly word: string;
+    readonly reason: string;
+}[];
+/**
+ * Whether a compound can be asked what it is made of at all.
+ *
+ * A reading of one syllable per character is what lets a character span be cut
+ * out of the compound's reading and replaced. 儿化 folds two characters into one
+ * syllable and punctuation reads as none, so neither lines up and both are left
+ * alone.
+ */
+export declare function isComposable(entry: DictionaryEntry): boolean;
+/**
+ * Whether any delta-carrying word appears inside this one.
+ *
+ * A cheap filter ahead of the segmentation: only a few hundred words carry a
+ * delta, against 461,555 entries, and enumerating one word's substrings costs
+ * far less than segmenting it.
+ */
+export declare function hasMarkedConstituent(word: string, marked: ReadonlySet<string>): boolean;
+//# sourceMappingURL=locale-candidates.d.ts.map

package/dist/dictionary/locale-candidates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-candidates.d.ts","sourceRoot":"","sources":["../../src/dictionary/locale-candidates.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,EAeA,CAAC;AASF;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,eAAe,GAAG,OAAO,CAQ5D;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAC1B,OAAO,CAST"}

package/dist/dictionary/locale-candidates.js

@@ -0,0 +1,77 @@
+/**
+ * Which compounds the locale composition may be asked about at all.
+ *
+ * Three filters that between them cut 461,555 entries to a few hundred: the
+ * compound has to line up one syllable per character, it has to contain a word
+ * that carries a delta, and it must not be one of the homographs the data
+ * cannot tell apart.
+ */
+import { toCharacters } from "../script/characters.js";
+/**
+ * Compounds whose constituent's 國語 reading must not be carried over.
+ *
+ * The composition below only fires where the compound reads its constituent
+ * exactly as that constituent's own entry does, which rules out most of the ways
+ * it could be wrong. What it cannot rule out is a homograph: two words spelled
+ * and read identically in 普通话, of which only one shifts in 國語. 相亲 is
+ * `xiāngqīn` either way when it means "mutually close" and `xiàngqīn` in Taiwan
+ * when it means a matchmaking meeting, and nothing in the data distinguishes the
+ * two senses.
+ *
+ * **Keep this small**, for the same reason
+ * {@link import("./overrides.js").READING_OVERRIDES} is kept small. Three
+ * exclusions against the 100 compounds the composition settles is the measured
+ * ratio; a list growing much past that would mean the alignment check has
+ * stopped carrying its weight and the rule itself needs revisiting.
+ */
+export const LOCALE_COMPOSITION_EXCLUSIONS = [
+    {
+        word: "相亲相爱",
+        reason: "相亲 here is 相 + 亲 in the reciprocal sense, `xiāngqīn`, not the matchmaking word that reads `xiàngqīn` in 國語.",
+    },
+    {
+        word: "腹背相亲",
+        reason: "The same reciprocal 相亲, so the same reading in both locales.",
+    },
+    {
+        word: "洋为中用",
+        reason: "中 is 中国 and 用 is its own verb: 洋为中用 is not built on the word 中用, which is what reads `zhòngyòng` in 國語.",
+    },
+];
+/**
+ * The exclusions as a set, for the composition to consult.
+ */
+const EXCLUDED = new Set(LOCALE_COMPOSITION_EXCLUSIONS.map((exclusion) => exclusion.word));
+/**
+ * Whether a compound can be asked what it is made of at all.
+ *
+ * A reading of one syllable per character is what lets a character span be cut
+ * out of the compound's reading and replaced. 儿化 folds two characters into one
+ * syllable and punctuation reads as none, so neither lines up and both are left
+ * alone.
+ */
+export function isComposable(entry) {
+    const characters = toCharacters(entry.hans);
+    return (characters.length > 2 &&
+        entry.readings.cn.length === characters.length &&
+        !EXCLUDED.has(entry.hans) &&
+        !EXCLUDED.has(entry.hant));
+}
+/**
+ * Whether any delta-carrying word appears inside this one.
+ *
+ * A cheap filter ahead of the segmentation: only a few hundred words carry a
+ * delta, against 461,555 entries, and enumerating one word's substrings costs
+ * far less than segmenting it.
+ */
+export function hasMarkedConstituent(word, marked) {
+    const characters = toCharacters(word);
+    return characters.some((_, from) => {
+        let candidate = "";
+        return characters.slice(from).some((character) => {
+            candidate += character;
+            return candidate !== word && marked.has(candidate);
+        });
+    });
+}
+//# sourceMappingURL=locale-candidates.js.map

package/dist/dictionary/locale-candidates.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-candidates.js","sourceRoot":"","sources":["../../src/dictionary/locale-candidates.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAGvD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAGpC;IACJ;QACE,IAAI,EAAE,MAAM;QACZ,MAAM,EACJ,6GAA6G;KAChH;IACD;QACE,IAAI,EAAE,MAAM;QACZ,MAAM,EAAE,8DAA8D;KACvE;IACD;QACE,IAAI,EAAE,MAAM;QACZ,MAAM,EACJ,yGAAyG;KAC5G;CACF,CAAC;AAEF;;GAEG;AACH,MAAM,QAAQ,GAAwB,IAAI,GAAG,CAC3C,6BAA6B,CAAC,GAAG,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,CAAC,CACjE,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAAC,KAAsB;IACjD,MAAM,UAAU,GAAG,YAAY,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAC5C,OAAO,CACL,UAAU,CAAC,MAAM,GAAG,CAAC;QACrB,KAAK,CAAC,QAAQ,CAAC,EAAE,CAAC,MAAM,KAAK,UAAU,CAAC,MAAM;QAC9C,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC;QACzB,CAAC,QAAQ,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAC1B,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,oBAAoB,CAClC,IAAY,EACZ,MAA2B;IAE3B,MAAM,UAAU,GAAG,YAAY,CAAC,IAAI,CAAC,CAAC;IACtC,OAAO,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE;QACjC,IAAI,SAAS,GAAG,EAAE,CAAC;QACnB,OAAO,UAAU,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE;YAC/C,SAAS,IAAI,SAAS,CAAC;YACvB,OAAO,SAAS,KAAK,IAAI,IAAI,MAAM,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;QACrD,CAAC,CAAC,CAAC;IACL,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/dictionary/locale-segments.d.ts

@@ -0,0 +1,47 @@
+import type { DictionaryEntry } from "./entry.js";
+/**
+ * One word of a segmentation, and where in the compound it falls.
+ */
+export interface Segment {
+    readonly entry: DictionaryEntry;
+    readonly text: string;
+    /** First character covered. */
+    readonly from: number;
+    /** One past the last character covered. */
+    readonly to: number;
+}
+/**
+ * Every key an entry answers to, under either script.
+ */
+export declare function keysOf(entry: DictionaryEntry): readonly string[];
+/**
+ * A compound's constituent words, and the readings they carry.
+ *
+ * Indexed by every key an entry claims, so that a 繁體 headword segments into
+ * 繁體 constituents. Headwords are set first and never displaced, which is the
+ * same precedence the artifact and the build assertions use: 发 and 髮 both claim
+ * 发, and the entry the key names has to win.
+ */
+export declare class ConstituentIndex {
+    #private;
+    /**
+     * Index entries by key, quantising their frequencies the way the decoder will.
+     */
+    constructor(entries: readonly DictionaryEntry[]);
+    /**
+     * What a key costs a segmentation that uses it.
+     */
+    costOf(key: string): number;
+    /**
+     * The likeliest way to cut a word into *other* dictionary words.
+     *
+     * The whole word is excluded from its own segmentation, which is the point:
+     * 垃圾分类 is a dictionary word, so a decoder handed the text would stop there
+     * and never ask what it is made of. This asks anyway.
+     *
+     * Returns undefined when no path of known words covers the word, which is
+     * common — most compounds contain a character no shorter word claims.
+     */
+    segment(word: string): readonly Segment[] | undefined;
+}
+//# sourceMappingURL=locale-segments.d.ts.map

package/dist/dictionary/locale-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"locale-segments.d.ts","sourceRoot":"","sources":["../../src/dictionary/locale-segments.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAmBlD;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,KAAK,EAAE,eAAe,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,+BAA+B;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,wBAAgB,MAAM,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,MAAM,EAAE,CAEhE;AAED;;;;;;;GAOG;AACH,qBAAa,gBAAgB;;IAI3B;;OAEG;IACH,YAAY,OAAO,EAAE,SAAS,eAAe,EAAE,EA4B9C;IA+BD;;OAEG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAG1B;IAED;;;;;;;;;OASG;IACH,OAAO,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,OAAO,EAAE,GAAG,SAAS,CA+BpD;CACF"}

package/dist/dictionary/locale-segments.js

@@ -0,0 +1,141 @@
+/**
+ * Cutting a compound into the constituents a 國語 delta can be composed from.
+ *
+ * The segmentation the composition runs on: which pieces a word divides into,
+ * and what each of them costs, so that the division a reader would make is
+ * the one that wins.
+ */
+import { toCharacters } from "../script/characters.js";
+import { FrequencyTable } from "./frequency-table.js";
+/**
+ * What each word in a segmentation costs on top of its frequency.
+ *
+ * The same charge, and for the same reason, as `READING_CHARGE` in
+ * `src/decode/lattice.ts`: it orders candidate segmentations by fewest words
+ * first and frequency second. That ordering is what decides 皮夹克 is 皮 + 夹克
+ * rather than 皮夹 + 克, which is the difference between leaving `pí jiákè`
+ * alone and mistaking it for the wallet 皮夹 that reads `pí jiá` in 國語.
+ *
+ * Duplicated rather than imported because the decoder sits above the dictionary
+ * and must not be depended on from inside it. The two are kept in step by
+ * `src/dictionary/locale.test.ts`, which asserts the segmentations this value
+ * produces rather than the value itself.
+ */
+const WORD_CHARGE = 16;
+/**
+ * Every key an entry answers to, under either script.
+ */
+export function keysOf(entry) {
+    return [entry.hans, entry.hant, ...(entry.hantVariants ?? [])];
+}
+/**
+ * A compound's constituent words, and the readings they carry.
+ *
+ * Indexed by every key an entry claims, so that a 繁體 headword segments into
+ * 繁體 constituents. Headwords are set first and never displaced, which is the
+ * same precedence the artifact and the build assertions use: 发 and 髮 both claim
+ * 发, and the entry the key names has to win.
+ */
+export class ConstituentIndex {
+    #byKey;
+    #cost;
+    /**
+     * Index entries by key, quantising their frequencies the way the decoder will.
+     */
+    constructor(entries) {
+        const byKey = new Map();
+        for (const entry of entries) {
+            byKey.set(entry.hans, entry);
+        }
+        for (const entry of entries) {
+            for (const form of keysOf(entry)) {
+                if (!byKey.has(form)) {
+                    byKey.set(form, entry);
+                }
+            }
+        }
+        // Costs come from the same quantised table the artifact ships, so that a
+        // segmentation decided here is the one the decoder would have reached.
+        const table = FrequencyTable.build(entries.map((entry) => entry.frequency));
+        const byEntry = new Map();
+        for (const [at, entry] of entries.entries()) {
+            byEntry.set(entry, table.costOf(at));
+        }
+        const cost = new Map();
+        for (const [key, entry] of byKey) {
+            /* c8 ignore next -- every key was indexed from one of these entries */
+            cost.set(key, (byEntry.get(entry) ?? 0) + WORD_CHARGE);
+        }
+        this.#byKey = byKey;
+        this.#cost = cost;
+    }
+    /**
+     * Relax every word starting at one position, improving the costs it reaches.
+     *
+     * One step of the shortest-path scan, lifted out of its enclosing loop.
+     */
+    #relaxFrom(word, characters, from, best, previous) {
+        /* c8 ignore next -- the caller only relaxes from a position in range */
+        const reached = best[from] ?? Infinity;
+        let candidate = "";
+        for (let to = from; to < characters.length; to++) {
+            /* c8 ignore next -- the loop condition keeps the index in range */
+            candidate += characters[to] ?? "";
+            // The whole word is not a segmentation of itself.
+            const entry = candidate === word ? undefined : this.#byKey.get(candidate);
+            const total = reached + this.costOf(candidate);
+            /* c8 ignore next -- `to + 1` is at most `length`, which `best` holds */
+            if (entry !== undefined && total < (best[to + 1] ?? Infinity)) {
+                best[to + 1] = total;
+                previous[to + 1] = { entry, text: candidate, from, to: to + 1 };
+            }
+        }
+    }
+    /**
+     * What a key costs a segmentation that uses it.
+     */
+    costOf(key) {
+        /* c8 ignore next -- only asked about keys the index just returned */
+        return this.#cost.get(key) ?? WORD_CHARGE;
+    }
+    /**
+     * The likeliest way to cut a word into *other* dictionary words.
+     *
+     * The whole word is excluded from its own segmentation, which is the point:
+     * 垃圾分类 is a dictionary word, so a decoder handed the text would stop there
+     * and never ask what it is made of. This asks anyway.
+     *
+     * Returns undefined when no path of known words covers the word, which is
+     * common — most compounds contain a character no shorter word claims.
+     */
+    segment(word) {
+        const characters = toCharacters(word);
+        const length = characters.length;
+        const best = Array.from({ length: length + 1 }, () => Infinity);
+        const previous = Array.from({ length: length + 1 });
+        best[0] = 0;
+        for (let from = 0; from < length; from++) {
+            /* c8 ignore next -- the loop condition keeps the index in range */
+            if ((best[from] ?? Infinity) !== Infinity) {
+                this.#relaxFrom(word, characters, from, best, previous);
+            }
+        }
+        /* c8 ignore next -- `best` is built one longer than the word */
+        if ((best[length] ?? Infinity) === Infinity) {
+            return undefined;
+        }
+        const path = [];
+        let at = length;
+        while (at > 0) {
+            const step = previous[at];
+            /* c8 ignore next 3 -- a finite cost at `at` means a step reached it */
+            if (step === undefined) {
+                return undefined;
+            }
+            path.unshift(step);
+            at = step.from;
+        }
+        return path;
+    }
+}
+//# sourceMappingURL=locale-segments.js.map

package/dist/dictionary/locale-segments.js.map

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

package/dist/dictionary/locale.d.ts

@@ -1,25 +1,5 @@
 import { type DictionaryEntry } from "./entry.js";
-/**
- * Compounds whose constituent's 國語 reading must not be carried over.
- *
- * The composition below only fires where the compound reads its constituent
- * exactly as that constituent's own entry does, which rules out most of the ways
- * it could be wrong. What it cannot rule out is a homograph: two words spelled
- * and read identically in 普通话, of which only one shifts in 國語. 相亲 is
- * `xiāngqīn` either way when it means "mutually close" and `xiàngqīn` in Taiwan
- * when it means a matchmaking meeting, and nothing in the data distinguishes the
- * two senses.
- *
- * **Keep this small**, for the same reason
- * {@link import("./overrides.js").READING_OVERRIDES} is kept small. Three
- * exclusions against the 100 compounds the composition settles is the measured
- * ratio; a list growing much past that would mean the alignment check has
- * stopped carrying its weight and the rule itself needs revisiting.
- */
-export declare const LOCALE_COMPOSITION_EXCLUSIONS: readonly {
-    readonly word: string;
-    readonly reason: string;
-}[];
+export { LOCALE_COMPOSITION_EXCLUSIONS } from "./locale-candidates.js";
 /**
  * What the composition pass changed.
  */

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

@@ -1 +1 @@
-{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../src/dictionary/locale.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,eAAe,EAAiB,MAAM,YAAY,CAAC;AAGjE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,6BAA6B,EAAE,SAAS;IACnD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB,EAeA,CAAC;AA6PF;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAYD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,iBAAiB,CA8DnB"}
+{"version":3,"file":"locale.d.ts","sourceRoot":"","sources":["../../src/dictionary/locale.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,KAAK,eAAe,EAAiB,MAAM,YAAY,CAAC;AAIjE,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AA6CvE;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,CAAC;IAC7C,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;CAC3B;AAYD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CACjC,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,iBAAiB,CA8DnB"}