@kensio/pinyinjs 1.7.4 → 1.7.6

package/dist/decode/tan-rule.js

@@ -0,0 +1,131 @@
+/**
+ * Whether a 弹 is plucked or is a bullet.
+ *
+ * The two readings are a verb and a noun, so what settles it is what the word
+ * beside it is doing rather than what the character is.
+ */
+import { toCharacters } from "../script/characters.js";
+import { ASPECT, PARTICLE_TAG, tagOf, wordEndingAt, wordStartingAt, } from "./edge-context.js";
+/**
+ * Whether a syllable is `tán`, the verbal reading of 弹.
+ */
+export function isTan(syllable) {
+    return (syllable?.initial === "t" && syllable.final === "an" && syllable.tone === 2);
+}
+/**
+ * The character in both scripts, since 彈 is not the shape 弹 is.
+ *
+ * 得, 教 and 儿 are the same character in either script and need say it once.
+ * This one is not, and neither is the 长 above, which is silent on 長 as a
+ * result. {@link ASPECT} carries 過 and 著 for the same reason this carries 彈.
+ */
+export const PLUCKED = new Set(["弹", "彈"]);
+/**
+ * Whether the character at a position is 弹, in either script.
+ */
+export function isPluckedAt(context, at) {
+    return PLUCKED.has(context.characters[at] ?? "");
+}
+/**
+ * What a 弹 that is playing governs: the instrument, the piece or its composer.
+ *
+ * 弹吉他, 弹竖琴, 弹肖邦, 弹一曲, 给我们弹一手. The name tags are in because
+ * jieba calls 吉他 `ns` and 管风琴, 班卓琴 and 古琴 `nr` — instruments read as
+ * places and people — and `m` because a piece is as often counted as named.
+ */
+export const PLAYED_TAGS = new Set(["n", "nz", "nr", "ns", "nt", "ng", "m"]);
+/**
+ * Whether a word is an object rather than the far half of a compound.
+ *
+ * The one place this rule departs from {@link isTeachingAt}, and it is what
+ * makes it usable on technical prose. 弹 joins bound morphemes into nouns far
+ * more readily than 教 does — 着弹点, 掷弹兵, 供弹爪, 底排弹时, 弹洞 — and every
+ * one of those puts a single tagged character after the 弹 where an object
+ * would go. What the verb actually governs is a word: 吉他, 竖琴, 管风琴, 电子琴,
+ * 一曲, 肖邦. Requiring two characters keeps the compounds out at the cost of
+ * 反手持法去弹班卓琴, where the decode reaches 班 rather than 班卓琴 anyway.
+ *
+ * 教 could not take the same guard, since 教我 and 教你 are the commonest shape
+ * it has. Nobody plays a pronoun, so `r` is out of {@link PLAYED_TAGS} too.
+ */
+function isPlayedObject(word) {
+    return word !== undefined && toCharacters(word).length > 1;
+}
+/**
+ * Whether the 弹 at a position is playing something.
+ *
+ * Much the same shape as {@link isTeachingAt}, and for the same reason: the
+ * object is what says so. A 弹 with an instrument, a tune or a name after it is
+ * governing it, and a 弹 with 了, 过, 着 or 得 after it is a verb whatever
+ * follows that. A particle in front of it rules it out, since a verb does not
+ * follow one.
+ */
+function isPlayingAt(context, at) {
+    if (tagOf(context, wordEndingAt(context, at)).startsWith(PARTICLE_TAG)) {
+        return false;
+    }
+    if (ASPECT.has(context.characters[at + 1] ?? "")) {
+        return true;
+    }
+    const played = wordStartingAt(context, at + 1);
+    return isPlayedObject(played) && PLAYED_TAGS.has(tagOf(context, played));
+}
+/**
+ * 弹 read as `tán` where it is playing rather than a projectile.
+ *
+ * The character is stored `dàn` with `tán` as an alternate, and the sources are
+ * agreed about it: Unihan's `kHanyuPinlu` counts `dàn(313)` against `tán(50)`
+ * and `kMandarin` names `dàn`. That is a fact about a corpus in which nearly
+ * every 弹 is ammunition — 子弹, 炮弹, 导弹, 原子弹, 手榴弹 — and every one of
+ * those is a word that carries its own reading. What the default is left
+ * deciding is the 弹 that stands as a word of its own, and in running text that
+ * one is the verb: 他会弹一点儿古筝 came out `dàn`, and 弹吉他, 弹竖琴, 我在弹肖邦
+ * and 他钢琴弹得很好 with it.
+ *
+ * See {@link isPlayingAt} for what decides it. Forcing the single-character
+ * edge is not enough on its own, for the reason {@link TEACHING_JIAO} gives: a
+ * reading spanning two characters carries its own 弹 into the position, and
+ * 我的爱好是开车和弹吉他 read `dàn` off 和弹, a pair the dictionary holds with
+ * no part of speech and at the cost of a reading nobody counted. A *tagged*
+ * word ending in 弹 is left alone, which is every one that matters — 子弹, 炸弹,
+ * 导弹, 反弹, 手榴弹. Nothing has to be done about the other side, since the
+ * nominal compounds starting with 弹 are all listed: 弹匣, 弹坑, 弹壳, 弹片,
+ * 弹药, 弹道 and 弹头 reach their reading through the word, so a bare 弹 with a
+ * noun after it is not the front of one that got away.
+ *
+ * The 88,866 lines of Tatoeba and zh.wikipedia the other rules were sized
+ * against are the wrong corpus for this one on their own: 38 弹 decode as a
+ * word of their own in them, and 31 are somebody playing something. So CPP's
+ * 20,147 sentences are measured with them as plain text — the benchmark is
+ * drawn from zh.wikipedia's military articles, which is precisely where the
+ * shapes this rule can break live. Over the 109,013 lines together, 60 弹
+ * decode as a word of their own, every one read `dàn`, and 34 of the 60 are
+ * wrong.
+ *
+ * This moves 30 of them, of which 29 are right: the whole of 弹吉他, 弹一曲肖邦
+ * and 钢琴弹得很好, and none of 南部弹, 毛瑟弹, 掷弹兵, 供弹爪, 着弹点, 弹洞 or
+ * 底排弹时. The one it breaks is 拆弹专家, where a compound has an object's
+ * shape on both sides. Five it leaves alone: 开始弹, 四手联弹 and 弹起三次, which
+ * have no object to see, 用那种指法弹不会觉得费力, and 反手持法去弹班卓琴, where
+ * the decode reaches 班 rather than 班卓琴. On CPP's 40 labelled 弹 nothing
+ * moves at all, every one of them having been right through a word.
+ */
+export const PLAYING_TAN = {
+    name: "playing-tan",
+    verdictFor: (context) => {
+        const { edge } = context;
+        if (PLUCKED.has(edge.text)) {
+            return isTan(edge.reading[0]) && isPlayingAt(context, edge.from)
+                ? "force"
+                : "keep";
+        }
+        return edge.partOfSpeech === "" &&
+            isPluckedAt(context, edge.to - 1) &&
+            edge.reading.length === edge.to - edge.from &&
+            !isTan(edge.reading.at(-1)) &&
+            isPlayingAt(context, edge.to - 1)
+            ? "forbid"
+            : "keep";
+    },
+};
+//# sourceMappingURL=tan-rule.js.map

package/dist/decode/tan-rule.js.map

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

package/dist/decode/write-run.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Writing one decoded Han run out as pieces.
+ *
+ * Sandhi runs across the whole run rather than within a word, and 分词连写
+ * rewrites the word boundaries without touching the readings, so both happen
+ * here rather than per word.
+ */
+import type { Dictionary } from "../dictionary/dictionary.js";
+import type { Locale } from "../script/script.js";
+import { type SandhiOptions } from "./sandhi.js";
+import type { ScoredWord } from "./word.js";
+import { type ConvertedPiece, type Written } from "./pieces.js";
+/**
+ * Write one Han run's worth of decoded words.
+ */
+export declare function writeRun(dictionary: Dictionary, words: readonly ScoredWord[], locale: Locale, written: Written, sandhi: SandhiOptions | undefined): readonly ConvertedPiece[];
+/**
+ * Rewrite every piece's text with a pass that reads across all of them.
+ */
+export declare function rewrite(pieces: readonly ConvertedPiece[], pass: (parts: readonly string[]) => readonly string[]): readonly ConvertedPiece[];
+//# sourceMappingURL=write-run.d.ts.map

package/dist/decode/write-run.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-run.d.ts","sourceRoot":"","sources":["../../src/decode/write-run.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElD,OAAO,EAAe,KAAK,aAAa,EAAE,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,EACL,KAAK,cAAc,EAInB,KAAK,OAAO,EACb,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,wBAAgB,QAAQ,CACtB,UAAU,EAAE,UAAU,EACtB,KAAK,EAAE,SAAS,UAAU,EAAE,EAC5B,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,aAAa,GAAG,SAAS,GAChC,SAAS,cAAc,EAAE,CAqC3B;AAED;;GAEG;AACH,wBAAgB,OAAO,CACrB,MAAM,EAAE,SAAS,cAAc,EAAE,EACjC,IAAI,EAAE,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,KAAK,SAAS,MAAM,EAAE,GACpD,SAAS,cAAc,EAAE,CAO3B"}

package/dist/decode/write-run.js

@@ -0,0 +1,42 @@
+import { charactersPerSyllable, groupingOf } from "./sandhi-input.js";
+import { applySandhi } from "./sandhi.js";
+import { plainPiece, readingFor, writeWord, } from "./pieces.js";
+/**
+ * Write one Han run's worth of decoded words.
+ */
+export function writeRun(dictionary, words, locale, written, sandhi) {
+    // Sandhi runs across the whole run rather than within a word, since 不 in one
+    // word assimilates to the tone starting the next, and what it needs beyond
+    // the syllables is in `sandhi-input.ts`.
+    const readings = words.map((scored) => readingFor(dictionary, scored.word, locale));
+    const flattened = applySandhi(readings.flat(), sandhi, groupingOf(dictionary, words, readings, sandhi?.thirdTone === true), charactersPerSyllable(words, readings));
+    let at = 0;
+    const pieces = [];
+    for (const [index, scored] of words.entries()) {
+        /* c8 ignore next -- readings is built by mapping over these same words */
+        const length = readings[index]?.length ?? 0;
+        if (index > 0) {
+            // A space, unless 分词连写 wrote a hyphen: 干干净净 is one orthographic
+            // word, `gāngān-jìngjìng`, cut into two decoded ones.
+            pieces.push(plainPiece(scored.word.separator ?? " "));
+        }
+        pieces.push(...writeWord(flattened.slice(at, at + length), 
+        // A locale reading of a different length cannot be lined up with the
+        // confidence reported for the reading it replaced.
+        scored.confidence.length === length ? scored.confidence : [], scored.word, written));
+        at += length;
+    }
+    return pieces;
+}
+/**
+ * Rewrite every piece's text with a pass that reads across all of them.
+ */
+export function rewrite(pieces, pass) {
+    const rewritten = pass(pieces.map((piece) => piece.text));
+    return pieces.map((piece, at) => {
+        /* c8 ignore next -- one part comes back for each part handed over */
+        const text = rewritten[at] ?? piece.text;
+        return text === piece.text ? piece : { ...piece, text };
+    });
+}
+//# sourceMappingURL=write-run.js.map

package/dist/decode/write-run.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-run.js","sourceRoot":"","sources":["../../src/decode/write-run.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,qBAAqB,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AACtE,OAAO,EAAE,WAAW,EAAsB,MAAM,aAAa,CAAC;AAE9D,OAAO,EAEL,UAAU,EACV,UAAU,EACV,SAAS,GAEV,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,UAAU,QAAQ,CACtB,UAAsB,EACtB,KAA4B,EAC5B,MAAc,EACd,OAAgB,EAChB,MAAiC;IAEjC,6EAA6E;IAC7E,2EAA2E;IAC3E,yCAAyC;IACzC,MAAM,QAAQ,GAAG,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,EAAE,EAAE,CACpC,UAAU,CAAC,UAAU,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,CAAC,CAC5C,CAAC;IACF,MAAM,SAAS,GAAG,WAAW,CAC3B,QAAQ,CAAC,IAAI,EAAE,EACf,MAAM,EACN,UAAU,CAAC,UAAU,EAAE,KAAK,EAAE,QAAQ,EAAE,MAAM,EAAE,SAAS,KAAK,IAAI,CAAC,EACnE,qBAAqB,CAAC,KAAK,EAAE,QAAQ,CAAC,CACvC,CAAC;IAEF,IAAI,EAAE,GAAG,CAAC,CAAC;IACX,MAAM,MAAM,GAAqB,EAAE,CAAC;IACpC,KAAK,MAAM,CAAC,KAAK,EAAE,MAAM,CAAC,IAAI,KAAK,CAAC,OAAO,EAAE,EAAE,CAAC;QAC9C,0EAA0E;QAC1E,MAAM,MAAM,GAAG,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC;QAC5C,IAAI,KAAK,GAAG,CAAC,EAAE,CAAC;YACd,gEAAgE;YAChE,sDAAsD;YACtD,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,IAAI,CAAC,SAAS,IAAI,GAAG,CAAC,CAAC,CAAC;QACxD,CAAC;QACD,MAAM,CAAC,IAAI,CACT,GAAG,SAAS,CACV,SAAS,CAAC,KAAK,CAAC,EAAE,EAAE,EAAE,GAAG,MAAM,CAAC;QAChC,qEAAqE;QACrE,mDAAmD;QACnD,MAAM,CAAC,UAAU,CAAC,MAAM,KAAK,MAAM,CAAC,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,CAAC,EAAE,EAC5D,MAAM,CAAC,IAAI,EACX,OAAO,CACR,CACF,CAAC;QACF,EAAE,IAAI,MAAM,CAAC;IACf,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,OAAO,CACrB,MAAiC,EACjC,IAAqD;IAErD,MAAM,SAAS,GAAG,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAC1D,OAAO,MAAM,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,EAAE,EAAE;QAC9B,qEAAqE;QACrE,MAAM,IAAI,GAAG,SAAS,CAAC,EAAE,CAAC,IAAI,KAAK,CAAC,IAAI,CAAC;QACzC,OAAO,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,KAAK,EAAE,IAAI,EAAE,CAAC;IAC1D,CAAC,CAAC,CAAC;AACL,CAAC"}

package/dist/dictionary/artifact-claims.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Which entry owns each key, since an entry claims both its scripts.
+ *
+ * Settled before a single line is written, and separately from writing them,
+ * because it is the one place the artifact resolves a disagreement rather than
+ * recording one: 发 and 髮 both claim 发 and read it differently, and something
+ * has to say which of them the key means.
+ */
+import type { DictionaryEntry } from "./entry.js";
+/**
+ * Decide which entry owns each key, since an entry claims both its scripts.
+ *
+ * Entries overlap: 头 claims 頭 as its 繁體 key, and 頭 is also a character
+ * entry of its own. They agree, so the conflict is harmless there — but 发 and
+ * 髮 both claim 发, and they emphatically do not agree, one reading `fā` and the
+ * other `fà`. The entry whose own headword *is* the key wins, which is what
+ * keeps 发 on its own reading rather than the one that reached it sideways.
+ *
+ * An entry claims every 繁體 spelling a source attests for it, not only the one
+ * it stores as {@link DictionaryEntry.hant}: 重复 claims 重複 and 重覆 alike,
+ * since a reader typing either expects `chóngfù` rather than the character by
+ * character reading a missing key falls back to.
+ */
+export declare function claimKeys(entries: readonly DictionaryEntry[]): ReadonlyMap<string, DictionaryEntry>;
+//# sourceMappingURL=artifact-claims.d.ts.map

package/dist/dictionary/artifact-claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-claims.d.ts","sourceRoot":"","sources":["../../src/dictionary/artifact-claims.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAuBlD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,eAAe,EAAE,GAClC,WAAW,CAAC,MAAM,EAAE,eAAe,CAAC,CAiBtC"}

package/dist/dictionary/artifact-claims.js

@@ -0,0 +1,47 @@
+import { traditionalForms } from "./artifact-format.js";
+/**
+ * Let one entry claim each of its 繁體 spellings, where nothing outranks it.
+ *
+ * A spelling equal to the 简体 headword is already claimed, and a spelling that
+ * is some entry's own headword belongs to that entry — 发 and 髮 disagree about
+ * the reading, and the one the key names has to win.
+ */
+function claimTraditional(claimed, entry) {
+    for (const form of traditionalForms(entry)) {
+        const held = claimed.get(form);
+        const isTaken = form === entry.hans || held?.hans === form;
+        if (!isTaken && (held === undefined || entry.frequency > held.frequency)) {
+            claimed.set(form, entry);
+        }
+    }
+}
+/**
+ * Decide which entry owns each key, since an entry claims both its scripts.
+ *
+ * Entries overlap: 头 claims 頭 as its 繁體 key, and 頭 is also a character
+ * entry of its own. They agree, so the conflict is harmless there — but 发 and
+ * 髮 both claim 发, and they emphatically do not agree, one reading `fā` and the
+ * other `fà`. The entry whose own headword *is* the key wins, which is what
+ * keeps 发 on its own reading rather than the one that reached it sideways.
+ *
+ * An entry claims every 繁體 spelling a source attests for it, not only the one
+ * it stores as {@link DictionaryEntry.hant}: 重复 claims 重複 and 重覆 alike,
+ * since a reader typing either expects `chóngfù` rather than the character by
+ * character reading a missing key falls back to.
+ */
+export function claimKeys(entries) {
+    const claimed = new Map();
+    // Headwords first, so that the second pass can never displace one: a 繁體
+    // alias reaching a key sideways must not outrank the entry that key names.
+    for (const entry of entries) {
+        const held = claimed.get(entry.hans);
+        if (held === undefined || entry.frequency > held.frequency) {
+            claimed.set(entry.hans, entry);
+        }
+    }
+    for (const entry of entries) {
+        claimTraditional(claimed, entry);
+    }
+    return claimed;
+}
+//# sourceMappingURL=artifact-claims.js.map

package/dist/dictionary/artifact-claims.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-claims.js","sourceRoot":"","sources":["../../src/dictionary/artifact-claims.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAExD;;;;;;GAMG;AACH,SAAS,gBAAgB,CACvB,OAAqC,EACrC,KAAsB;IAEtB,KAAK,MAAM,IAAI,IAAI,gBAAgB,CAAC,KAAK,CAAC,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC/B,MAAM,OAAO,GAAG,IAAI,KAAK,KAAK,CAAC,IAAI,IAAI,IAAI,EAAE,IAAI,KAAK,IAAI,CAAC;QAC3D,IAAI,CAAC,OAAO,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YACzE,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;AACH,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,SAAS,CACvB,OAAmC;IAEnC,MAAM,OAAO,GAAG,IAAI,GAAG,EAA2B,CAAC;IAEnD,wEAAwE;IACxE,2EAA2E;IAC3E,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,MAAM,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;QACrC,IAAI,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,SAAS,GAAG,IAAI,CAAC,SAAS,EAAE,CAAC;YAC3D,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACjC,CAAC;IACH,CAAC;IAED,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE,CAAC;QAC5B,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IACnC,CAAC;IAED,OAAO,OAAO,CAAC;AACjB,CAAC"}

package/dist/dictionary/artifact-format.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The artifact's on-disk format: its separators, its flags, and how a reading
+ * is written as one field.
+ *
+ * Both halves of `artifact.ts` — writing the file and reading it back — are
+ * held to the same answers here, which is what stops the two drifting apart.
+ */
+import { type Syllable } from "../syllable/syllable.js";
+import type { DictionaryEntry } from "./entry.js";
+/**
+ * Separator between a line's columns.
+ */
+export declare const COLUMN = "\t";
+/**
+ * Separator between lines, matching the key index's own separator.
+ */
+export declare const LINE = "\n";
+/**
+ * Separator between the alternate readings of a character.
+ */
+export declare const ALTERNATE = ",";
+/**
+ * The flag marking a proper noun.
+ */
+export declare const PROPER_NOUN_FLAG = "p";
+/**
+ * Where a proper name divides, written after the proper-noun flag.
+ *
+ * `p` alone is a proper noun whose parts CC-CEDICT does not divide; `p1` is one
+ * that divides after the first character, `p2.4` after the second and fourth.
+ * The positions are decimal and dot-separated rather than one digit each,
+ * because the longest word carrying any is 19 characters.
+ *
+ * It rides in the flags column rather than taking a column of its own because
+ * it is only ever present on a proper noun, and only 8,205 of 723,139 keys
+ * carry one — a sixth column would cost a separator on every line to say
+ * nothing on almost all of them. *
+ * `security/detect-unsafe-regex` flags the nested quantifier, and there is no
+ * ambiguity behind it: a literal `.` separates `\d+` from `(?:\.\d+)*`, so no
+ * input can be split between them two ways. Timed on a string of digits and
+ * dots that cannot match, it is linear — 8k to 128k characters doubles the time
+ * for each doubling of the input, 39µs to 607µs.
+ */
+export declare const NAME_BOUNDARIES: RegExp;
+export declare const BOUNDARY_SEPARATOR = ".";
+/**
+ * The boundaries a flags column states, empty where it states none.
+ */
+export declare function nameBoundariesIn(flags: string): readonly number[];
+/**
+ * A compiled dictionary, in the form it is written to disk and read back.
+ *
+ * Three parallel pieces, all indexed by the same position: search `keys` for a
+ * word, and the line at that position in `entries` describes it. Nothing is
+ * parsed on load beyond scanning for separators — see BROWSER.md, where the
+ * measurement behind that choice is recorded.
+ */
+export interface DictionaryArtifact {
+    /** Sorted keys, newline-joined: the {@link KeyIndex} blob. */
+    readonly keys: string;
+    /** One line per key, in key order. */
+    readonly entries: string;
+    /** Quantised frequencies, packed two per byte. */
+    readonly frequencies: Uint8Array;
+}
+/**
+ * Write a reading in tone-numbered notation.
+ *
+ * Numbered rather than tone-marked because it is ASCII, so it survives any
+ * encoding, and because the tone is then a character rather than a combining
+ * mark that normalisation could move.
+ */
+export declare function encodeReading(syllables: readonly Syllable[]): string;
+/**
+ * Read a reading back, or return undefined if any syllable is malformed.
+ */
+export declare function decodeReading(text: string): readonly Syllable[] | undefined;
+/**
+ * Order two keys the way {@link KeyIndex} requires them: by UTF-16 code unit.
+ */
+export declare function byCodeUnit(left: string, right: string): number;
+/**
+ * Every 繁體 spelling an entry claims a key for.
+ */
+export declare function traditionalForms(entry: DictionaryEntry): readonly string[];
+//# sourceMappingURL=artifact-format.d.ts.map

package/dist/dictionary/artifact-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-format.d.ts","sourceRoot":"","sources":["../../src/dictionary/artifact-format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;GAEG;AACH,eAAO,MAAM,MAAM,OAAO,CAAC;AAE3B;;GAEG;AACH,eAAO,MAAM,IAAI,OAAO,CAAC;AAEzB;;GAEG;AACH,eAAO,MAAM,SAAS,MAAM,CAAC;AAE7B;;GAEG;AACH,eAAO,MAAM,gBAAgB,MAAM,CAAC;AAEpC;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,eAAe,QAA6B,CAAC;AAE1D,eAAO,MAAM,kBAAkB,MAAM,CAAC;AAEtC;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,CAGjE;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,kBAAkB;IACjC,8DAA8D;IAC9D,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,kDAAkD;IAClD,QAAQ,CAAC,WAAW,EAAE,UAAU,CAAC;CAClC;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAIpE;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,QAAQ,EAAE,GAAG,SAAS,CAQ3E;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,CAK9D;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,eAAe,GAAG,SAAS,MAAM,EAAE,CAE1E"}

package/dist/dictionary/artifact-format.js

@@ -0,0 +1,91 @@
+/**
+ * The artifact's on-disk format: its separators, its flags, and how a reading
+ * is written as one field.
+ *
+ * Both halves of `artifact.ts` — writing the file and reading it back — are
+ * held to the same answers here, which is what stops the two drifting apart.
+ */
+import { readSyllable, writeSyllable, } from "../syllable/syllable.js";
+/**
+ * Separator between a line's columns.
+ */
+export const COLUMN = "\t";
+/**
+ * Separator between lines, matching the key index's own separator.
+ */
+export const LINE = "\n";
+/**
+ * Separator between the alternate readings of a character.
+ */
+export const ALTERNATE = ",";
+/**
+ * The flag marking a proper noun.
+ */
+export const PROPER_NOUN_FLAG = "p";
+/**
+ * Where a proper name divides, written after the proper-noun flag.
+ *
+ * `p` alone is a proper noun whose parts CC-CEDICT does not divide; `p1` is one
+ * that divides after the first character, `p2.4` after the second and fourth.
+ * The positions are decimal and dot-separated rather than one digit each,
+ * because the longest word carrying any is 19 characters.
+ *
+ * It rides in the flags column rather than taking a column of its own because
+ * it is only ever present on a proper noun, and only 8,205 of 723,139 keys
+ * carry one — a sixth column would cost a separator on every line to say
+ * nothing on almost all of them. *
+ * `security/detect-unsafe-regex` flags the nested quantifier, and there is no
+ * ambiguity behind it: a literal `.` separates `\d+` from `(?:\.\d+)*`, so no
+ * input can be split between them two ways. Timed on a string of digits and
+ * dots that cannot match, it is linear — 8k to 128k characters doubles the time
+ * for each doubling of the input, 39µs to 607µs.
+ */
+export const NAME_BOUNDARIES = /^p(?<at>\d+(?:\.\d+)*)$/u;
+export const BOUNDARY_SEPARATOR = ".";
+/**
+ * The boundaries a flags column states, empty where it states none.
+ */
+export function nameBoundariesIn(flags) {
+    const at = NAME_BOUNDARIES.exec(flags)?.groups?.["at"];
+    return at === undefined ? [] : at.split(BOUNDARY_SEPARATOR).map(Number);
+}
+/**
+ * Write a reading in tone-numbered notation.
+ *
+ * Numbered rather than tone-marked because it is ASCII, so it survives any
+ * encoding, and because the tone is then a character rather than a combining
+ * mark that normalisation could move.
+ */
+export function encodeReading(syllables) {
+    return syllables
+        .map((syllable) => writeSyllable(syllable, "numbers"))
+        .join(" ");
+}
+/**
+ * Read a reading back, or return undefined if any syllable is malformed.
+ */
+export function decodeReading(text) {
+    if (text === "") {
+        return undefined;
+    }
+    const syllables = text.split(" ").map((token) => readSyllable(token));
+    return syllables.includes(undefined)
+        ? undefined
+        : syllables;
+}
+/**
+ * Order two keys the way {@link KeyIndex} requires them: by UTF-16 code unit.
+ */
+export function byCodeUnit(left, right) {
+    if (left < right) {
+        return -1;
+    }
+    return left > right ? 1 : 0;
+}
+/**
+ * Every 繁體 spelling an entry claims a key for.
+ */
+export function traditionalForms(entry) {
+    return [entry.hant, ...(entry.hantVariants ?? [])];
+}
+//# sourceMappingURL=artifact-format.js.map

package/dist/dictionary/artifact-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-format.js","sourceRoot":"","sources":["../../src/dictionary/artifact-format.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,EACL,YAAY,EAEZ,aAAa,GACd,MAAM,yBAAyB,CAAC;AAGjC;;GAEG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG,IAAI,CAAC;AAE3B;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,IAAI,CAAC;AAEzB;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,GAAG,CAAC;AAE7B;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAEpC;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,0BAA0B,CAAC;AAE1D,MAAM,CAAC,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAEtC;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAa;IAC5C,MAAM,EAAE,GAAG,eAAe,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC,IAAI,CAAC,CAAC;IACvD,OAAO,EAAE,KAAK,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;AAC1E,CAAC;AAmBD;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,SAA8B;IAC1D,OAAO,SAAS;SACb,GAAG,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,aAAa,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;SACrD,IAAI,CAAC,GAAG,CAAC,CAAC;AACf,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,aAAa,CAAC,IAAY;IACxC,IAAI,IAAI,KAAK,EAAE,EAAE,CAAC;QAChB,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,MAAM,SAAS,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC;IACtE,OAAO,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC;QAClC,CAAC,CAAC,SAAS;QACX,CAAC,CAAE,SAAiC,CAAC;AACzC,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,UAAU,CAAC,IAAY,EAAE,KAAa;IACpD,IAAI,IAAI,GAAG,KAAK,EAAE,CAAC;QACjB,OAAO,CAAC,CAAC,CAAC;IACZ,CAAC;IACD,OAAO,IAAI,GAAG,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;AAC9B,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAsB;IACrD,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,GAAG,CAAC,KAAK,CAAC,YAAY,IAAI,EAAE,CAAC,CAAC,CAAC;AACrD,CAAC"}

package/dist/dictionary/artifact-read.d.ts

@@ -0,0 +1,34 @@
+import type { DictionaryEntry } from "./entry.js";
+import { type DictionaryArtifact } from "./artifact-format.js";
+export { decodeReading, type DictionaryArtifact, encodeReading, traditionalForms, } from "./artifact-format.js";
+/**
+ * Read an artifact back into entries, for tests and for the loader.
+ *
+ * The reverse of {@link buildArtifact} but for the two things it does not
+ * store: frequency comes back as a bucket rather than a count, since it is
+ * quantised on the way out, and 简体/繁體 pairing is absent, so every entry
+ * reports its key as both. Entries are returned in key order.
+ */
+export declare function readArtifact(artifact: DictionaryArtifact): readonly DictionaryEntry[];
+/**
+ * The reading every key in an artifact resolves to, in tone-numbered notation.
+ *
+ * Resolved rather than read off the line, since 87.8% of multi-character lines
+ * store no reading at all and mean "the characters' defaults, in order" — and
+ * those defaults are whatever *this* artifact holds. That is exactly what makes
+ * the comparison between tiers worth doing: a tier missing a character does not
+ * only lose that character, it changes every derived reading that stands on it.
+ */
+export declare function readingsByKey(artifact: DictionaryArtifact): ReadonlyMap<string, string>;
+/**
+ * The first key an artifact does not read back the same, or undefined.
+ *
+ * Only the fields the artifact stores are compared: frequency is quantised on
+ * the way out, and the 简体/繁體 labelling of a pair is not recoverable from a
+ * key alone, so neither is checked here.
+ *
+ * Returns the offending key rather than a bare false so that a build failure
+ * names the word to go and look at.
+ */
+export declare function findRoundTripFailure(entries: readonly DictionaryEntry[], artifact: DictionaryArtifact): string | undefined;
+//# sourceMappingURL=artifact-read.d.ts.map

package/dist/dictionary/artifact-read.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artifact-read.d.ts","sourceRoot":"","sources":["../../src/dictionary/artifact-read.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAIlD,OAAO,EAIL,KAAK,kBAAkB,EAKxB,MAAM,sBAAsB,CAAC;AAE9B,OAAO,EACL,aAAa,EACb,KAAK,kBAAkB,EACvB,aAAa,EACb,gBAAgB,GACjB,MAAM,sBAAsB,CAAC;AAE9B;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,kBAAkB,GAC3B,SAAS,eAAe,EAAE,CA2D5B;AAED;;;;;;;;GAQG;AACH,wBAAgB,aAAa,CAC3B,QAAQ,EAAE,kBAAkB,GAC3B,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAO7B;AAED;;;;;;;;;GASG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,SAAS,eAAe,EAAE,EACnC,QAAQ,EAAE,kBAAkB,GAC3B,MAAM,GAAG,SAAS,CAkBpB"}

package/dist/dictionary/artifact-read.js

@@ -0,0 +1,114 @@
+/**
+ * Reading the dictionary artifact back.
+ *
+ * The mirror of buildArtifact, and held to it by the round-trip check at the
+ * end of the build.
+ */
+import { claimKeys } from "./artifact.js";
+import { toCharacters } from "../script/characters.js";
+import { isSameReading } from "./entry.js";
+import { FrequencyTable } from "./frequency-table.js";
+import { KeyIndex } from "./key-index.js";
+import { ALTERNATE, COLUMN, decodeReading, encodeReading, LINE, nameBoundariesIn, PROPER_NOUN_FLAG, } from "./artifact-format.js";
+export { decodeReading, encodeReading, traditionalForms, } from "./artifact-format.js";
+/**
+ * Read an artifact back into entries, for tests and for the loader.
+ *
+ * The reverse of {@link buildArtifact} but for the two things it does not
+ * store: frequency comes back as a bucket rather than a count, since it is
+ * quantised on the way out, and 简体/繁體 pairing is absent, so every entry
+ * reports its key as both. Entries are returned in key order.
+ */
+export function readArtifact(artifact) {
+    const index = KeyIndex.from(artifact.keys);
+    const lines = artifact.entries === "" ? [] : artifact.entries.split(LINE);
+    const frequencies = FrequencyTable.from(artifact.frequencies, index.size);
+    // Two passes: a derivable reading needs its characters' readings, which are
+    // themselves entries in the same artifact.
+    const defaults = new Map();
+    for (let at = 0; at < index.size; at++) {
+        const key = index.keyAt(at);
+        const reading = (lines[at] ?? "").split(COLUMN)[0] ?? "";
+        if (toCharacters(key).length === 1 && reading !== "") {
+            defaults.set(key, reading);
+        }
+    }
+    const entries = [];
+    for (let at = 0; at < index.size; at++) {
+        const key = index.keyAt(at);
+        const [reading = "", taiwan = "", partOfSpeech = "", flags = "", alternates = "",] = (lines[at] ?? "").split(COLUMN);
+        const nameBoundaries = nameBoundariesIn(flags);
+        const stored = reading === ""
+            ? toCharacters(key)
+                .map((character) => defaults.get(character) ?? "")
+                .join(" ")
+            : reading;
+        const cn = decodeReading(stored);
+        if (cn === undefined) {
+            throw new Error(`artifact entry for ${key} has no readable reading`);
+        }
+        const tw = decodeReading(taiwan);
+        // The artifact stores keys, not pairs, so a key read back is both scripts
+        // as far as it knows. See buildArtifact for what that leaves out and why.
+        entries.push({
+            hans: key,
+            hant: key,
+            readings: { cn, ...(tw !== undefined && { tw }) },
+            frequency: frequencies.bucketOf(at),
+            partOfSpeech,
+            isProperNoun: flags.includes(PROPER_NOUN_FLAG),
+            ...(nameBoundaries.length > 0 && { nameBoundaries }),
+            ...(alternates !== "" && {
+                alternates: alternates
+                    .split(ALTERNATE)
+                    .map((text) => decodeReading(text))
+                    .filter((decoded) => decoded !== undefined),
+            }),
+        });
+    }
+    return entries;
+}
+/**
+ * The reading every key in an artifact resolves to, in tone-numbered notation.
+ *
+ * Resolved rather than read off the line, since 87.8% of multi-character lines
+ * store no reading at all and mean "the characters' defaults, in order" — and
+ * those defaults are whatever *this* artifact holds. That is exactly what makes
+ * the comparison between tiers worth doing: a tier missing a character does not
+ * only lose that character, it changes every derived reading that stands on it.
+ */
+export function readingsByKey(artifact) {
+    const index = KeyIndex.from(artifact.keys);
+    const readings = new Map();
+    for (const [at, entry] of readArtifact(artifact).entries()) {
+        readings.set(index.keyAt(at), encodeReading(entry.readings.cn));
+    }
+    return readings;
+}
+/**
+ * The first key an artifact does not read back the same, or undefined.
+ *
+ * Only the fields the artifact stores are compared: frequency is quantised on
+ * the way out, and the 简体/繁體 labelling of a pair is not recoverable from a
+ * key alone, so neither is checked here.
+ *
+ * Returns the offending key rather than a bare false so that a build failure
+ * names the word to go and look at.
+ */
+export function findRoundTripFailure(entries, artifact) {
+    const index = KeyIndex.from(artifact.keys);
+    const read = readArtifact(artifact);
+    const byKey = new Map();
+    for (const [at, entry] of read.entries()) {
+        byKey.set(index.keyAt(at), entry);
+    }
+    for (const [key, entry] of claimKeys(entries)) {
+        const other = byKey.get(key);
+        if (other === undefined ||
+            !isSameReading(entry.readings.cn, other.readings.cn)) {
+            return key;
+        }
+    }
+    return undefined;
+}
+//# sourceMappingURL=artifact-read.js.map

package/dist/dictionary/artifact-read.js.map

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