@kensio/pinyinjs 1.7.4 → 1.7.5

package/dist/decode/lattice-slice.js

@@ -0,0 +1,43 @@
+import { allEdges } from "./lattice.js";
+import { toCharacters } from "../script/characters.js";
+import { shiftHints } from "./hints.js";
+import { ruledLattice } from "./run-lattice.js";
+/**
+ * Whether any reading in the lattice would hold the two sides of a join
+ * together.
+ *
+ * A reading of one syllable per character can be cut anywhere; anything else —
+ * 儿化, a character with no reading — is a single claim about its whole span,
+ * so a claim spanning the join cannot be reported for the run alone. 1点儿事
+ * is that case: 一点儿 is one `yìdiǎnr` over the 一 the context supplied and
+ * the 点儿 the run did.
+ */
+export function isJoinedAt(lattice, at) {
+    return allEdges(lattice).some((edge) => edge.from < at &&
+        edge.to > at &&
+        edge.reading.length !== edge.to - edge.from);
+}
+/**
+ * The lattice a run decodes over, with whatever context stands in front of it.
+ *
+ * The context is dropped where a reading would hold it to the run, leaving the
+ * run decoded on its own, which is what it would have been before there was any
+ * context to give.
+ */
+export function runLattice(dictionary, run, rules, before, hints) {
+    const alone = () => ({
+        lattice: ruledLattice(dictionary, run, rules, hints),
+        at: 0,
+    });
+    if (before === "") {
+        return alone();
+    }
+    const held = toCharacters(before).length;
+    // The context is decoded with the run, so every hint position moves along
+    // with it. Shifting a copy keeps the caller's positions relative to the run
+    // they were given for.
+    const lattice = ruledLattice(dictionary, before + run, rules, hints === undefined ? undefined : shiftHints(hints, held));
+    const at = held;
+    return isJoinedAt(lattice, at) ? alone() : { lattice, at };
+}
+//# sourceMappingURL=lattice-slice.js.map

package/dist/decode/lattice-slice.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lattice-slice.js","sourceRoot":"","sources":["../../src/decode/lattice-slice.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,QAAQ,EAAgB,MAAM,cAAc,CAAC;AAEtD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAsB,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AAUhD;;;;;;;;;GASG;AACH,MAAM,UAAU,UAAU,CAAC,OAAgB,EAAE,EAAU;IACrD,OAAO,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,CAC3B,CAAC,IAAI,EAAE,EAAE,CACP,IAAI,CAAC,IAAI,GAAG,EAAE;QACd,IAAI,CAAC,EAAE,GAAG,EAAE;QACZ,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,EAAE,GAAG,IAAI,CAAC,IAAI,CAC9C,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CACxB,UAAsB,EACtB,GAAW,EACX,KAA0B,EAC1B,MAAc,EACd,KAAgC;IAEhC,MAAM,KAAK,GAAG,GAAe,EAAE,CAAC,CAAC;QAC/B,OAAO,EAAE,YAAY,CAAC,UAAU,EAAE,GAAG,EAAE,KAAK,EAAE,KAAK,CAAC;QACpD,EAAE,EAAE,CAAC;KACN,CAAC,CAAC;IACH,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;QAClB,OAAO,KAAK,EAAE,CAAC;IACjB,CAAC;IACD,MAAM,IAAI,GAAG,YAAY,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC;IACzC,0EAA0E;IAC1E,4EAA4E;IAC5E,uBAAuB;IACvB,MAAM,OAAO,GAAG,YAAY,CAC1B,UAAU,EACV,MAAM,GAAG,GAAG,EACZ,KAAK,EACL,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,KAAK,EAAE,IAAI,CAAC,CAC1D,CAAC;IACF,MAAM,EAAE,GAAG,IAAI,CAAC;IAChB,OAAO,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,EAAE,EAAE,CAAC;AAC7D,CAAC"}

package/dist/decode/lattice-types.d.ts

@@ -0,0 +1,82 @@
+/**
+ * What a lattice is made of, and what each edge costs it.
+ *
+ * The costs are the whole of the decode's judgement in four numbers, so they
+ * sit together and are stated once.
+ */
+import type { Syllable } from "../syllable/syllable.js";
+/**
+ * One candidate reading of one stretch of characters.
+ *
+ * An edge runs from character position `from` to position `to`, exclusive, and
+ * carries the syllables that stretch is read as. The reading is *not* required
+ * to have one syllable per character: 玩儿 covers two characters and reads as
+ * the single syllable `wánr`, which is the case that stops the lattice being a
+ * simple per-character grid.
+ */
+export interface LatticeEdge {
+    readonly from: number;
+    readonly to: number;
+    readonly text: string;
+    readonly reading: readonly Syllable[];
+    /** What this edge costs the spacing decode: a quantised `−log P(word)`. */
+    readonly cost: number;
+    /** What this edge costs the reading decode. See {@link READING_CHARGE}. */
+    readonly readingCost: number;
+    readonly isProperNoun: boolean;
+    readonly partOfSpeech: string;
+    /** Whether a dictionary entry backs this edge, rather than a fallback. */
+    readonly isKnown: boolean;
+}
+/**
+ * Every candidate reading of a Han run, as a DAG over character positions.
+ */
+export interface Lattice {
+    readonly characters: readonly string[];
+    /** Edges leaving each position, indexed by that position. */
+    readonly edges: readonly (readonly LatticeEdge[])[];
+}
+/**
+ * How far ahead a match is looked for.
+ *
+ * The prefix check stops a scan long before this in practice; it is a guard
+ * against pathological input, not a real limit.
+ */
+export declare const LONGEST_WORD = 16;
+/**
+ * What each step down a character's list of readings adds to the edge cost.
+ *
+ * A character's readings arrive most likely first, and nothing else in the data
+ * says how much more likely. One frequency bucket per step is the smallest
+ * separation that still ranks them, and it keeps a rare reading of a common
+ * character from outbidding a real dictionary word.
+ */
+export declare const ALTERNATE_PENALTY = 1;
+/**
+ * What every edge costs the reading decode on top of its word cost.
+ *
+ * The two decodes want different things, which is the asymmetry ALGORITHM.md
+ * builds on. Spacing asks which segmentation the corpus makes likeliest, and
+ * `−log P(word)` answers it. Readings ask something else: 地气 is rarer than 地
+ * followed by 气, so the unigram model is right to split it and the reading
+ * that falls out — `de qì` — is still wrong, because the dictionary states
+ * outright that those two characters together read `dì qì`. A stored reading is
+ * evidence about the characters; a character's default reading is only a prior.
+ *
+ * So the reading decode charges per *edge* heavily enough that dictionary
+ * evidence outranks frequency: at 16 an attested word always beats splitting it
+ * into characters, however common those characters are, since the worst word
+ * costs `15 + 16` and the best two-character split costs `0 + 16` twice. Word
+ * frequency survives as the tiebreak between paths covering the same span with
+ * the same number of words. That ordering — fewest words first, frequency
+ * second — is the one ALGORITHM.md already gives its data-free fallback tier.
+ */
+export declare const READING_CHARGE = 16;
+/**
+ * What an edge covering a character no dictionary entry knows costs.
+ *
+ * Above the worst cost a real entry can carry, so that any known reading is
+ * preferred to none.
+ */
+export declare const UNKNOWN_COST = 32;
+//# sourceMappingURL=lattice-types.d.ts.map

package/dist/decode/lattice-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lattice-types.d.ts","sourceRoot":"","sources":["../../src/decode/lattice-types.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,WAAW,EAAE,CAAC,EAAE,CAAC;CACrD;AAED;;;;;GAKG;AACH,eAAO,MAAM,YAAY,KAAK,CAAC;AAE/B;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,KAAK,CAAC"}

package/dist/decode/lattice-types.js

@@ -0,0 +1,44 @@
+/**
+ * How far ahead a match is looked for.
+ *
+ * The prefix check stops a scan long before this in practice; it is a guard
+ * against pathological input, not a real limit.
+ */
+export const LONGEST_WORD = 16;
+/**
+ * What each step down a character's list of readings adds to the edge cost.
+ *
+ * A character's readings arrive most likely first, and nothing else in the data
+ * says how much more likely. One frequency bucket per step is the smallest
+ * separation that still ranks them, and it keeps a rare reading of a common
+ * character from outbidding a real dictionary word.
+ */
+export const ALTERNATE_PENALTY = 1;
+/**
+ * What every edge costs the reading decode on top of its word cost.
+ *
+ * The two decodes want different things, which is the asymmetry ALGORITHM.md
+ * builds on. Spacing asks which segmentation the corpus makes likeliest, and
+ * `−log P(word)` answers it. Readings ask something else: 地气 is rarer than 地
+ * followed by 气, so the unigram model is right to split it and the reading
+ * that falls out — `de qì` — is still wrong, because the dictionary states
+ * outright that those two characters together read `dì qì`. A stored reading is
+ * evidence about the characters; a character's default reading is only a prior.
+ *
+ * So the reading decode charges per *edge* heavily enough that dictionary
+ * evidence outranks frequency: at 16 an attested word always beats splitting it
+ * into characters, however common those characters are, since the worst word
+ * costs `15 + 16` and the best two-character split costs `0 + 16` twice. Word
+ * frequency survives as the tiebreak between paths covering the same span with
+ * the same number of words. That ordering — fewest words first, frequency
+ * second — is the one ALGORITHM.md already gives its data-free fallback tier.
+ */
+export const READING_CHARGE = 16;
+/**
+ * What an edge covering a character no dictionary entry knows costs.
+ *
+ * Above the worst cost a real entry can carry, so that any known reading is
+ * preferred to none.
+ */
+export const UNKNOWN_COST = 32;
+//# sourceMappingURL=lattice-types.js.map

package/dist/decode/lattice-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lattice-types.js","sourceRoot":"","sources":["../../src/decode/lattice-types.ts"],"names":[],"mappings":"AAyCA;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,CAAC;AAE/B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAEnC;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,EAAE,CAAC;AAEjC;;;;;GAKG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,EAAE,CAAC"}

package/dist/decode/lattice.d.ts

@@ -1,64 +1,7 @@
 import type { Dictionary } from "../dictionary/dictionary.js";
-import type { Syllable } from "../syllable/syllable.js";
 import { type ResolvedHints } from "./hints.js";
-/**
- * One candidate reading of one stretch of characters.
- *
- * An edge runs from character position `from` to position `to`, exclusive, and
- * carries the syllables that stretch is read as. The reading is *not* required
- * to have one syllable per character: 玩儿 covers two characters and reads as
- * the single syllable `wánr`, which is the case that stops the lattice being a
- * simple per-character grid.
- */
-export interface LatticeEdge {
-    readonly from: number;
-    readonly to: number;
-    readonly text: string;
-    readonly reading: readonly Syllable[];
-    /** What this edge costs the spacing decode: a quantised `−log P(word)`. */
-    readonly cost: number;
-    /** What this edge costs the reading decode. See {@link READING_CHARGE}. */
-    readonly readingCost: number;
-    readonly isProperNoun: boolean;
-    readonly partOfSpeech: string;
-    /** Whether a dictionary entry backs this edge, rather than a fallback. */
-    readonly isKnown: boolean;
-}
-/**
- * Every candidate reading of a Han run, as a DAG over character positions.
- */
-export interface Lattice {
-    readonly characters: readonly string[];
-    /** Edges leaving each position, indexed by that position. */
-    readonly edges: readonly (readonly LatticeEdge[])[];
-}
-/**
- * What every edge costs the reading decode on top of its word cost.
- *
- * The two decodes want different things, which is the asymmetry ALGORITHM.md
- * builds on. Spacing asks which segmentation the corpus makes likeliest, and
- * `−log P(word)` answers it. Readings ask something else: 地气 is rarer than 地
- * followed by 气, so the unigram model is right to split it and the reading
- * that falls out — `de qì` — is still wrong, because the dictionary states
- * outright that those two characters together read `dì qì`. A stored reading is
- * evidence about the characters; a character's default reading is only a prior.
- *
- * So the reading decode charges per *edge* heavily enough that dictionary
- * evidence outranks frequency: at 16 an attested word always beats splitting it
- * into characters, however common those characters are, since the worst word
- * costs `15 + 16` and the best two-character split costs `0 + 16` twice. Word
- * frequency survives as the tiebreak between paths covering the same span with
- * the same number of words. That ordering — fewest words first, frequency
- * second — is the one ALGORITHM.md already gives its data-free fallback tier.
- */
-export declare const READING_CHARGE = 16;
-/**
- * What an edge covering a character no dictionary entry knows costs.
- *
- * Above the worst cost a real entry can carry, so that any known reading is
- * preferred to none.
- */
-export declare const UNKNOWN_COST = 32;
+import type { Lattice, LatticeEdge } from "./lattice-types.js";
+export { type Lattice, type LatticeEdge, READING_CHARGE, UNKNOWN_COST, } from "./lattice-types.js";
 /**
  * Build the lattice of every way a Han run could be read.
  *

package/dist/decode/lattice.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lattice.d.ts","sourceRoot":"","sources":["../../src/decode/lattice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AACxD,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAE5D;;;;;;;;GAQG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,OAAO,EAAE,SAAS,QAAQ,EAAE,CAAC;IACtC,2EAA2E;IAC3E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2EAA2E;IAC3E,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,YAAY,EAAE,OAAO,CAAC;IAC/B,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,QAAQ,CAAC,UAAU,EAAE,SAAS,MAAM,EAAE,CAAC;IACvC,6DAA6D;IAC7D,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAC,SAAS,WAAW,EAAE,CAAC,EAAE,CAAC;CACrD;AAoBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,cAAc,KAAK,CAAC;AAEjC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,KAAK,CAAC;AA+F/B;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,GACpB,OAAO,CAaT;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,WAAW,EAAE,CAEjE;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE,CAuB7D"}
+{"version":3,"file":"lattice.d.ts","sourceRoot":"","sources":["../../src/decode/lattice.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAC5D,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAE/D,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,cAAc,EACd,YAAY,GACb,MAAM,oBAAoB,CAAC;AAG5B;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,MAAM,EACX,KAAK,CAAC,EAAE,aAAa,GACpB,OAAO,CAaT;AAED;;GAEG;AACH,wBAAgB,QAAQ,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,WAAW,EAAE,CAEjE;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,SAAS,MAAM,EAAE,CAuB7D"}

package/dist/decode/lattice.js

@@ -1,123 +1,7 @@
 import { toCharacters } from "../script/characters.js";
 import { applyHints } from "./hints.js";
-/**
- * How far ahead a match is looked for.
- *
- * The prefix check stops a scan long before this in practice; it is a guard
- * against pathological input, not a real limit.
- */
-const LONGEST_WORD = 16;
-/**
- * What each step down a character's list of readings adds to the edge cost.
- *
- * A character's readings arrive most likely first, and nothing else in the data
- * says how much more likely. One frequency bucket per step is the smallest
- * separation that still ranks them, and it keeps a rare reading of a common
- * character from outbidding a real dictionary word.
- */
-const ALTERNATE_PENALTY = 1;
-/**
- * What every edge costs the reading decode on top of its word cost.
- *
- * The two decodes want different things, which is the asymmetry ALGORITHM.md
- * builds on. Spacing asks which segmentation the corpus makes likeliest, and
- * `−log P(word)` answers it. Readings ask something else: 地气 is rarer than 地
- * followed by 气, so the unigram model is right to split it and the reading
- * that falls out — `de qì` — is still wrong, because the dictionary states
- * outright that those two characters together read `dì qì`. A stored reading is
- * evidence about the characters; a character's default reading is only a prior.
- *
- * So the reading decode charges per *edge* heavily enough that dictionary
- * evidence outranks frequency: at 16 an attested word always beats splitting it
- * into characters, however common those characters are, since the worst word
- * costs `15 + 16` and the best two-character split costs `0 + 16` twice. Word
- * frequency survives as the tiebreak between paths covering the same span with
- * the same number of words. That ordering — fewest words first, frequency
- * second — is the one ALGORITHM.md already gives its data-free fallback tier.
- */
-export const READING_CHARGE = 16;
-/**
- * What an edge covering a character no dictionary entry knows costs.
- *
- * Above the worst cost a real entry can carry, so that any known reading is
- * preferred to none.
- */
-export const UNKNOWN_COST = 32;
-/**
- * The edges leaving a position that come from multi-character dictionary words.
- *
- * Walks one character at a time and stops as soon as the dictionary reports
- * that nothing begins with what has been collected, which is what keeps the
- * scan linear in practice rather than quadratic in the longest key.
- */
-function wordEdgesAt(dictionary, characters, at) {
-    const edges = [];
-    let candidate = "";
-    for (let length = 0; length < LONGEST_WORD && at + length < characters.length; length++) {
-        /* c8 ignore next -- the loop condition keeps the index in range */
-        candidate += characters[at + length] ?? "";
-        if (!dictionary.hasPrefix(candidate)) {
-            break;
-        }
-        const entry = length === 0 ? undefined : dictionary.lookup(candidate);
-        if (entry !== undefined) {
-            edges.push({
-                from: at,
-                to: at + length + 1,
-                text: candidate,
-                reading: entry.reading,
-                cost: entry.cost,
-                readingCost: entry.cost + READING_CHARGE,
-                isProperNoun: entry.isProperNoun,
-                partOfSpeech: entry.partOfSpeech,
-                isKnown: true,
-            });
-        }
-    }
-    return edges;
-}
-/**
- * The single-character edges leaving a position, one per known reading.
- *
- * Always present, whatever words also start here. Two things depend on that:
- * every position has an outgoing edge, so the lattice is always traversable;
- * and a polyphone offers all of its readings at every position, so scoring has
- * something to choose between rather than only what the word list happens to
- * cover.
- */
-function characterEdgesAt(dictionary, characters, at) {
-    /* c8 ignore next -- callers only ask about positions inside the run */
-    const character = characters[at] ?? "";
-    const entry = dictionary.lookup(character);
-    if (entry === undefined) {
-        // A character with no entry at all: keep it, unread, so that the text still
-        // round-trips and the failure is visible rather than silent.
-        return [
-            {
-                from: at,
-                to: at + 1,
-                text: character,
-                reading: [],
-                cost: UNKNOWN_COST,
-                readingCost: UNKNOWN_COST + READING_CHARGE,
-                isProperNoun: false,
-                partOfSpeech: "",
-                isKnown: false,
-            },
-        ];
-    }
-    return dictionary.readingsOf(character).map((reading, rank) => ({
-        from: at,
-        to: at + 1,
-        text: character,
-        reading,
-        cost: entry.cost + rank * ALTERNATE_PENALTY,
-        readingCost: entry.cost + rank * ALTERNATE_PENALTY + READING_CHARGE,
-        isProperNoun: entry.isProperNoun,
-        partOfSpeech: entry.partOfSpeech,
-        isKnown: true,
-    }));
-}
+export { READING_CHARGE, UNKNOWN_COST, } from "./lattice-types.js";
+import { characterEdgesAt, wordEdgesAt } from "./lattice-edges.js";
 /**
  * Build the lattice of every way a Han run could be read.
  *

package/dist/decode/lattice.js.map

@@ -1 +1 @@
-{"version":3,"file":"lattice.js","sourceRoot":"","sources":["../../src/decode/lattice.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"lattice.js","sourceRoot":"","sources":["../../src/decode/lattice.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,UAAU,EAAsB,MAAM,YAAY,CAAC;AAG5D,OAAO,EAGL,cAAc,EACd,YAAY,GACb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAEnE;;;;;;;GAOG;AACH,MAAM,UAAU,YAAY,CAC1B,UAAsB,EACtB,GAAW,EACX,KAAqB;IAErB,MAAM,UAAU,GAAG,YAAY,CAAC,GAAG,CAAC,CAAC;IACrC,MAAM,KAAK,GAA+B,EAAE,CAAC;IAE7C,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,UAAU,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;QAC9C,KAAK,CAAC,IAAI,CAAC;YACT,GAAG,WAAW,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC;YAC1C,GAAG,gBAAgB,CAAC,UAAU,EAAE,UAAU,EAAE,EAAE,CAAC;SAChD,CAAC,CAAC;IACL,CAAC;IAED,MAAM,OAAO,GAAG,EAAE,UAAU,EAAE,KAAK,EAAE,CAAC;IACtC,OAAO,KAAK,KAAK,SAAS,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,UAAU,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;AACpE,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,QAAQ,CAAC,OAAgB;IACvC,OAAO,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC;AAC9B,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,SAAS,CAAC,OAAgB;IACxC,MAAM,MAAM,GAAG,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC;IACzC,MAAM,SAAS,GAAG,IAAI,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IAE7C,2EAA2E;IAC3E,8DAA8D;IAC9D,KAAK,MAAM,IAAI,IAAI,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACrC,0EAA0E;QAC1E,SAAS,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QAC/D,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,GAAG,CAAC,SAAS,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;IACrD,CAAC;IAED,MAAM,IAAI,GAAa,EAAE,CAAC;IAC1B,IAAI,QAAQ,GAAG,CAAC,CAAC;IACjB,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,IAAI,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;QACpC,mEAAmE;QACnE,QAAQ,IAAI,SAAS,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QAC/B,IAAI,QAAQ,KAAK,CAAC,EAAE,CAAC;YACnB,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;QAChB,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/decode/number-pieces.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Turning one read number into pieces, spaced against what surrounds it.
+ *
+ * A digit run is said as words and the words are grouped, so the pieces carry
+ * both the reading and where the words break — and whether a space belongs
+ * between the number and the text beside it.
+ */
+import type { NumeralSegment } from "../numerals/read-numeral.js";
+/**
+ * The numbers in a text, said out loud.
+ *
+ * A digit is not Han and does not reach the decoder, so reading 1998年 as
+ * `yī jiǔ jiǔ bā nián` means working out what the run around it says and
+ * whether a space belongs between them. That is all this does.
+ */
+import { type Syllable } from "../syllable/syllable.js";
+import { type ApostropheStyle } from "../orthography/apostrophe.js";
+import { type ConvertedPiece, type Written } from "./pieces.js";
+/**
+ * Whether a character wants a space between it and a number read out.
+ *
+ * A letter or a digit does; punctuation does not, so 20%。 keeps its full stop
+ * against the number.
+ */
+export declare const WORDLIKE: RegExp;
+/**
+ * Whether two stretches take a space between them once one has been read.
+ */
+export declare function isSpaced(before: string, after: string): boolean;
+/**
+ * Write a run whose words are already known, a word at a time.
+ *
+ * Each group is one orthographic word and takes the 隔音符号 within itself, so
+ * a time's minutes are `sānshí` rather than `sān shí` — the same grouping the
+ * number would get if the text had written 6点30分 out in 汉字.
+ */
+export declare function groupedPieces(spelled: readonly string[], said: readonly Syllable[], words: readonly number[], apostrophe: ApostropheStyle): readonly ConvertedPiece[];
+/**
+ * Write a number's syllables as the pieces they are written with.
+ *
+ * A counted number is *one word*, which is what 正词法 6.1.5 asks for: 123 is
+ * `yībǎi'èrshísān` and not three words, so the syllables run together and take
+ * the 隔音符号 where one is needed. A number read out digit by digit is not a
+ * word at all — it is digits — so those are written apart: 1998年 is
+ * `yī jiǔ jiǔ bā nián`.
+ */
+export declare function numberPieces(said: readonly Syllable[], segment: NumeralSegment, written: Written): readonly ConvertedPiece[];
+/**
+ * Name what a read number is a reading of, once for the whole of it.
+ *
+ * A number is not read character by character the way a word is: 95% is
+ * `bǎifēnzhījiǔshíwǔ` over eight syllables and three written characters, and
+ * the order reverses on the way, so no syllable belongs to any one of them.
+ * The written form is therefore named once, by the first piece that says
+ * anything, and the rest read on into it.
+ */
+export declare function read(pieces: readonly ConvertedPiece[], source: string): readonly ConvertedPiece[];
+/**
+ * A stand-in for the pinyin either side of a run, which ends in a letter.
+ */
+export declare function runEdge(isHan: boolean): string;
+//# sourceMappingURL=number-pieces.d.ts.map

package/dist/decode/number-pieces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"number-pieces.d.ts","sourceRoot":"","sources":["../../src/decode/number-pieces.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,6BAA6B,CAAC;AAClE;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,QAAQ,EAAiB,MAAM,yBAAyB,CAAC;AACvE,OAAO,EAAE,KAAK,eAAe,EAAY,MAAM,8BAA8B,CAAC;AAC9E,OAAO,EAAE,KAAK,cAAc,EAAc,KAAK,OAAO,EAAE,MAAM,aAAa,CAAC;AAE5E;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,QAAkB,CAAC;AAExC;;GAEG;AACH,wBAAgB,QAAQ,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAE/D;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,SAAS,MAAM,EAAE,EAC1B,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,KAAK,EAAE,SAAS,MAAM,EAAE,EACxB,UAAU,EAAE,eAAe,GAC1B,SAAS,cAAc,EAAE,CAmB3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,SAAS,QAAQ,EAAE,EACzB,OAAO,EAAE,cAAc,EACvB,OAAO,EAAE,OAAO,GACf,SAAS,cAAc,EAAE,CAkC3B;AAED;;;;;;;;GAQG;AACH,wBAAgB,IAAI,CAClB,MAAM,EAAE,SAAS,cAAc,EAAE,EACjC,MAAM,EAAE,MAAM,GACb,SAAS,cAAc,EAAE,CAS3B;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAE9C"}

package/dist/decode/number-pieces.js

@@ -0,0 +1,106 @@
+/**
+ * The numbers in a text, said out loud.
+ *
+ * A digit is not Han and does not reach the decoder, so reading 1998年 as
+ * `yī jiǔ jiǔ bā nián` means working out what the run around it says and
+ * whether a space belongs between them. That is all this does.
+ */
+import { writeSyllable } from "../syllable/syllable.js";
+import { markWord } from "../orthography/apostrophe.js";
+import { plainPiece } from "./pieces.js";
+/**
+ * Whether a character wants a space between it and a number read out.
+ *
+ * A letter or a digit does; punctuation does not, so 20%。 keeps its full stop
+ * against the number.
+ */
+export const WORDLIKE = /[\p{L}\p{N}]/u;
+/**
+ * Whether two stretches take a space between them once one has been read.
+ */
+export function isSpaced(before, after) {
+    return WORDLIKE.test(before.at(-1) ?? "") && WORDLIKE.test(after[0] ?? "");
+}
+/**
+ * Write a run whose words are already known, a word at a time.
+ *
+ * Each group is one orthographic word and takes the 隔音符号 within itself, so
+ * a time's minutes are `sānshí` rather than `sān shí` — the same grouping the
+ * number would get if the text had written 6点30分 out in 汉字.
+ */
+export function groupedPieces(spelled, said, words, apostrophe) {
+    const pieces = [];
+    let at = 0;
+    for (const length of words) {
+        if (at > 0) {
+            pieces.push(plainPiece(" "));
+        }
+        const group = spelled.slice(at, at + length);
+        for (const [index, text] of markWord(group, apostrophe).entries()) {
+            pieces.push({
+                text,
+                syllable: said[at + index],
+                confidence: undefined,
+                source: undefined,
+            });
+        }
+        at += length;
+    }
+    return pieces;
+}
+/**
+ * Write a number's syllables as the pieces they are written with.
+ *
+ * A counted number is *one word*, which is what 正词法 6.1.5 asks for: 123 is
+ * `yībǎi'èrshísān` and not three words, so the syllables run together and take
+ * the 隔音符号 where one is needed. A number read out digit by digit is not a
+ * word at all — it is digits — so those are written apart: 1998年 is
+ * `yī jiǔ jiǔ bā nián`.
+ */
+export function numberPieces(said, segment, written) {
+    const spelled = said.map((syllable) => writeSyllable(syllable, written.notation));
+    if (segment.style === "digits") {
+        return read(spelled.flatMap((text, at) => [
+            ...(at === 0 ? [] : [plainPiece(" ")]),
+            { text, syllable: said[at], confidence: undefined, source: undefined },
+        ]), segment.text);
+    }
+    const isNumbered = written.notation === "numbers" || written.notation === "superscript";
+    const apostrophe = isNumbered ? "never" : written.apostrophe;
+    // A run that says where its words break gets them: a time is `liù diǎn
+    // sānshí fēn` and a decimal is `qīshíwǔ diǎn wǔ`, each counted part a word
+    // of its own and everything after the 点 a digit at a time.
+    if (segment.words !== undefined) {
+        return read(groupedPieces(spelled, said, segment.words, apostrophe), segment.text);
+    }
+    return read(markWord(spelled, apostrophe).map((text, at) => ({
+        text,
+        syllable: said[at],
+        confidence: undefined,
+        source: undefined,
+    })), segment.text);
+}
+/**
+ * Name what a read number is a reading of, once for the whole of it.
+ *
+ * A number is not read character by character the way a word is: 95% is
+ * `bǎifēnzhījiǔshíwǔ` over eight syllables and three written characters, and
+ * the order reverses on the way, so no syllable belongs to any one of them.
+ * The written form is therefore named once, by the first piece that says
+ * anything, and the rest read on into it.
+ */
+export function read(pieces, source) {
+    const first = pieces.findIndex((piece) => piece.syllable !== undefined);
+    /* c8 ignore next 3 -- a read number has at least one syllable in it */
+    if (first === -1) {
+        return pieces;
+    }
+    return pieces.map((piece, at) => at === first ? { ...piece, source } : piece);
+}
+/**
+ * A stand-in for the pinyin either side of a run, which ends in a letter.
+ */
+export function runEdge(isHan) {
+    return isHan ? "a" : "";
+}
+//# sourceMappingURL=number-pieces.js.map

package/dist/decode/number-pieces.js.map

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

package/dist/decode/numbers.d.ts

@@ -0,0 +1,53 @@
+import type { Syllable } from "../syllable/syllable.js";
+/**
+ * The numbers in a text, said out loud.
+ *
+ * A digit is not Han and does not reach the decoder, so reading 1998年 as
+ * `yī jiǔ jiǔ bā nián` means working out what the run around it says and
+ * whether a space belongs between them. That is all this does.
+ */
+import { type NumeralSegment } from "../numerals/text.js";
+import { type TextRun } from "./runs.js";
+import type { ScoredWord } from "./word.js";
+import type { SandhiOptions } from "./sandhi.js";
+import { type ConvertedPiece, type Written } from "./pieces.js";
+/**
+ * What surrounds a non-Han run, as far as a number in it cares.
+ */
+export interface RunContext {
+    readonly after: {
+        readonly character: string;
+        readonly syllable: Syllable | undefined;
+    };
+    /** Whether pinyin was written immediately before this run. */
+    readonly isAfterHan: boolean;
+}
+/**
+ * What surrounds a run once it has been decoded: the character after it, and
+ * the syllable that character is read as.
+ *
+ * The syllable is the one part of a number's context that a decode has to
+ * supply, and it is what a 一 ending the number assimilates to.
+ */
+export declare function surrounding(runs: readonly TextRun[], decoded: readonly (readonly ScoredWord[])[], at: number): RunContext;
+/**
+ * The 汉字 a number in front of a Han run stands for, for that run's decode.
+ *
+ * Only the last segment of the run before, because only that one touches the
+ * Han: the D of 3D银行 comes between them, and a decode of 银行 that saw 三
+ * beside it would be reading a text nobody wrote.
+ */
+export declare function numeralBefore(segments: readonly NumeralSegment[]): string;
+/**
+ * Write a stretch that was never Han, reading the numbers in it.
+ *
+ * Everything that is not a number goes through exactly as written, which is
+ * what this always did: digits are the only part of a non-Han run this package
+ * has anything to say about. Once a number *has* been read, though, the whole
+ * stretch is being said rather than shown, so its parts take the spacing of
+ * words — 3D打印 is `sān D dǎyìn` — and punctuation still takes none.
+ */
+export declare function writeNumbers(text: string, segments: readonly NumeralSegment[], context: RunContext, written: Written, options: {
+    readonly sandhi: SandhiOptions | undefined;
+}): readonly ConvertedPiece[];
+//# sourceMappingURL=numbers.d.ts.map

package/dist/decode/numbers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.d.ts","sourceRoot":"","sources":["../../src/decode/numbers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAExD;;;;;;GAMG;AACH,OAAO,EAAE,KAAK,cAAc,EAAe,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAyB,KAAK,OAAO,EAAE,MAAM,WAAW,CAAC;AAChE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAC5C,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AACjD,OAAO,EACL,KAAK,cAAc,EAGnB,KAAK,OAAO,EACb,MAAM,aAAa,CAAC;AAErB;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,KAAK,EAAE;QACd,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;QAC3B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,GAAG,SAAS,CAAC;KACzC,CAAC;IACF,8DAA8D;IAC9D,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,SAAS,OAAO,EAAE,EACxB,OAAO,EAAE,SAAS,CAAC,SAAS,UAAU,EAAE,CAAC,EAAE,EAC3C,EAAE,EAAE,MAAM,GACT,UAAU,CAQZ;AAED;;;;;;GAMG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,SAAS,cAAc,EAAE,GAAG,MAAM,CAEzE;AAED;;;;;;;;GAQG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,cAAc,EAAE,EACnC,OAAO,EAAE,UAAU,EACnB,OAAO,EAAE,OAAO,EAChB,OAAO,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,aAAa,GAAG,SAAS,CAAA;CAAE,GACtD,SAAS,cAAc,EAAE,CA6B3B"}