@kensio/pinyinjs 1.7.4 → 1.7.6

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

@@ -0,0 +1 @@
+{"version":3,"file":"lattice-costs.d.ts","sourceRoot":"","sources":["../../src/decode/lattice-costs.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEzD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAC;IAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,wBAAgB,OAAO,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,WAAW,EAAE,CAG5E;AAED;;GAEG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,GACT,SAAS,WAAW,EAAE,CAMxB;AAED;;GAEG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,GACb,SAAS,MAAM,EAAE,CAiBnB;AAED;;GAEG;AACH,wBAAgB,aAAa,CAC3B,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,GACb,SAAS,MAAM,EAAE,CAiBnB;AAED;;;;;;;;;GASG;AACH,wBAAgB,WAAW,CACzB,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,GACb,aAAa,CAsBf;AAED;;GAEG"}

package/dist/decode/lattice-costs.js

@@ -0,0 +1,90 @@
+import { unitKey, unitsOf } from "./locking.js";
+/**
+ * The edges leaving one position.
+ */
+export function edgesAt(lattice, at) {
+    /* c8 ignore next -- at is always a position of the run */
+    return lattice.edges[at] ?? [];
+}
+/**
+ * Every edge lying wholly inside a stretch.
+ */
+export function edgesInside(lattice, from, to) {
+    const inside = [];
+    for (let at = from; at < to; at++) {
+        inside.push(...edgesAt(lattice, at).filter((edge) => edge.to <= to));
+    }
+    return inside;
+}
+/**
+ * Cheapest cost of reaching each position in a stretch from its start.
+ */
+export function forwardCosts(lattice, from, to, costOf) {
+    const best = Array.from({ length: to - from + 1 }, () => Infinity);
+    best[0] = 0;
+    for (let at = from; at < to; at++) {
+        /* c8 ignore next 2 -- every position of the stretch is reached and in range */
+        const sofar = best[at - from] ?? Infinity;
+        for (const edge of edgesAt(lattice, at)) {
+            /* c8 ignore next -- the target of an edge inside the stretch is in range */
+            const rival = best[edge.to - from] ?? Infinity;
+            if (edge.to <= to && sofar + costOf(edge) < rival) {
+                best[edge.to - from] = sofar + costOf(edge);
+            }
+        }
+    }
+    return best;
+}
+/**
+ * Cheapest cost of reaching the end of a stretch from each position in it.
+ */
+export function backwardCosts(lattice, from, to, costOf) {
+    const best = Array.from({ length: to - from + 1 }, () => Infinity);
+    best[to - from] = 0;
+    for (let at = to - 1; at >= from; at--) {
+        let cheapest = Infinity;
+        for (const edge of edgesAt(lattice, at)) {
+            /* c8 ignore next -- the target of an edge inside the stretch is in range */
+            const onwards = best[edge.to - from] ?? Infinity;
+            if (edge.to <= to && costOf(edge) + onwards < cheapest) {
+                cheapest = costOf(edge) + onwards;
+            }
+        }
+        best[at - from] = cheapest;
+    }
+    return best;
+}
+/**
+ * Price every distinct reading a stretch offers.
+ *
+ * A claim is priced by the cheapest path through the whole stretch that makes
+ * it, which is what makes the figures comparable: a reading can be expensive
+ * because it forces expensive readings around it as much as because it is
+ * itself unlikely. One forward sweep and one backward sweep give that for every
+ * edge at once, which is the same work the decode already does in one
+ * direction.
+ */
+export function scoreClaims(lattice, from, to, costOf) {
+    const forward = forwardCosts(lattice, from, to, costOf);
+    const backward = backwardCosts(lattice, from, to, costOf);
+    const claims = new Map();
+    for (const edge of edgesInside(lattice, from, to)) {
+        /* c8 ignore next 2 -- both ends of an edge in the stretch are in range */
+        const through = (forward[edge.from - from] ?? Infinity) +
+            costOf(edge) +
+            (backward[edge.to - from] ?? Infinity);
+        for (const unit of unitsOf(edge)) {
+            const key = unitKey(unit);
+            const held = claims.get(key);
+            if (held === undefined || through < held.cost) {
+                claims.set(key, { unit, cost: through });
+            }
+        }
+    }
+    /* c8 ignore next -- every position of a stretch is reachable from its start */
+    return { claims, best: forward[to - from] ?? Infinity };
+}
+/**
+ * What a unit beat: the claims overlapping its span, other than its own.
+ */
+//# sourceMappingURL=lattice-costs.js.map

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

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

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

@@ -0,0 +1,29 @@
+/**
+ * The edges one position of a lattice offers.
+ *
+ * A word the dictionary has starting here, or the single character sitting
+ * here — the two ways a reading can cover ground, kept apart from assembling
+ * them into a lattice.
+ */
+import type { Dictionary } from "../dictionary/dictionary.js";
+import { type LatticeEdge } from "./lattice-types.js";
+export { type Lattice, type LatticeEdge, READING_CHARGE, UNKNOWN_COST, } from "./lattice-types.js";
+/**
+ * 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.
+ */
+export declare function wordEdgesAt(dictionary: Dictionary, characters: readonly string[], at: number): readonly LatticeEdge[];
+/**
+ * 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.
+ */
+export declare function characterEdgesAt(dictionary: Dictionary, characters: readonly string[], at: number): readonly LatticeEdge[];
+//# sourceMappingURL=lattice-edges.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lattice-edges.d.ts","sourceRoot":"","sources":["../../src/decode/lattice-edges.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAEL,KAAK,WAAW,EAIjB,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,WAAW,EAChB,cAAc,EACd,YAAY,GACb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,EAAE,EAAE,MAAM,GACT,SAAS,WAAW,EAAE,CA+BxB;AAED;;;;;;;;GAQG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,UAAU,EACtB,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,EAAE,EAAE,MAAM,GACT,SAAS,WAAW,EAAE,CAkCxB"}

package/dist/decode/lattice-edges.js

@@ -0,0 +1,78 @@
+import { ALTERNATE_PENALTY, LONGEST_WORD, READING_CHARGE, UNKNOWN_COST, } from "./lattice-types.js";
+export { READING_CHARGE, UNKNOWN_COST, } from "./lattice-types.js";
+/**
+ * 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.
+ */
+export 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.
+ */
+export 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,
+    }));
+}
+//# sourceMappingURL=lattice-edges.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lattice-edges.js","sourceRoot":"","sources":["../../src/decode/lattice-edges.ts"],"names":[],"mappings":"AAQA,OAAO,EACL,iBAAiB,EAEjB,YAAY,EACZ,cAAc,EACd,YAAY,GACb,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAGL,cAAc,EACd,YAAY,GACb,MAAM,oBAAoB,CAAC;AAE5B;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CACzB,UAAsB,EACtB,UAA6B,EAC7B,EAAU;IAEV,MAAM,KAAK,GAAkB,EAAE,CAAC;IAChC,IAAI,SAAS,GAAG,EAAE,CAAC;IAEnB,KACE,IAAI,MAAM,GAAG,CAAC,EACd,MAAM,GAAG,YAAY,IAAI,EAAE,GAAG,MAAM,GAAG,UAAU,CAAC,MAAM,EACxD,MAAM,EAAE,EACR,CAAC;QACD,mEAAmE;QACnE,SAAS,IAAI,UAAU,CAAC,EAAE,GAAG,MAAM,CAAC,IAAI,EAAE,CAAC;QAC3C,IAAI,CAAC,UAAU,CAAC,SAAS,CAAC,SAAS,CAAC,EAAE,CAAC;YACrC,MAAM;QACR,CAAC;QACD,MAAM,KAAK,GAAG,MAAM,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;QACtE,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;YACxB,KAAK,CAAC,IAAI,CAAC;gBACT,IAAI,EAAE,EAAE;gBACR,EAAE,EAAE,EAAE,GAAG,MAAM,GAAG,CAAC;gBACnB,IAAI,EAAE,SAAS;gBACf,OAAO,EAAE,KAAK,CAAC,OAAO;gBACtB,IAAI,EAAE,KAAK,CAAC,IAAI;gBAChB,WAAW,EAAE,KAAK,CAAC,IAAI,GAAG,cAAc;gBACxC,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,YAAY,EAAE,KAAK,CAAC,YAAY;gBAChC,OAAO,EAAE,IAAI;aACd,CAAC,CAAC;QACL,CAAC;IACH,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC9B,UAAsB,EACtB,UAA6B,EAC7B,EAAU;IAEV,uEAAuE;IACvE,MAAM,SAAS,GAAG,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC;IACvC,MAAM,KAAK,GAAG,UAAU,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAE3C,IAAI,KAAK,KAAK,SAAS,EAAE,CAAC;QACxB,4EAA4E;QAC5E,6DAA6D;QAC7D,OAAO;YACL;gBACE,IAAI,EAAE,EAAE;gBACR,EAAE,EAAE,EAAE,GAAG,CAAC;gBACV,IAAI,EAAE,SAAS;gBACf,OAAO,EAAE,EAAE;gBACX,IAAI,EAAE,YAAY;gBAClB,WAAW,EAAE,YAAY,GAAG,cAAc;gBAC1C,YAAY,EAAE,KAAK;gBACnB,YAAY,EAAE,EAAE;gBAChB,OAAO,EAAE,KAAK;aACf;SACF,CAAC;IACJ,CAAC;IAED,OAAO,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,CAAC,CAAC;QAC9D,IAAI,EAAE,EAAE;QACR,EAAE,EAAE,EAAE,GAAG,CAAC;QACV,IAAI,EAAE,SAAS;QACf,OAAO;QACP,IAAI,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,iBAAiB;QAC3C,WAAW,EAAE,KAAK,CAAC,IAAI,GAAG,IAAI,GAAG,iBAAiB,GAAG,cAAc;QACnE,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,YAAY,EAAE,KAAK,CAAC,YAAY;QAChC,OAAO,EAAE,IAAI;KACd,CAAC,CAAC,CAAC;AACN,CAAC"}

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

@@ -0,0 +1,37 @@
+/**
+ * Cutting a lattice down to one run and lining the edges back up.
+ *
+ * A run is decoded on its own, so its edges are shifted to start at zero and
+ * shifted back afterwards.
+ */
+import type { Dictionary } from "../dictionary/dictionary.js";
+import { type Lattice } from "./lattice.js";
+import type { EdgeRule } from "./rules.js";
+import { type ResolvedHints } from "./hints.js";
+/**
+ * A lattice to decode over, and where in it the run itself starts.
+ */
+export interface RunLattice {
+    readonly lattice: Lattice;
+    readonly at: number;
+}
+/**
+ * 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 declare function isJoinedAt(lattice: Lattice, at: number): boolean;
+/**
+ * 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 declare function runLattice(dictionary: Dictionary, run: string, rules: readonly EdgeRule[], before: string, hints: ResolvedHints | undefined): RunLattice;
+//# sourceMappingURL=lattice-slice.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"lattice-slice.d.ts","sourceRoot":"","sources":["../../src/decode/lattice-slice.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAY,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AACtD,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,OAAO,EAAc,KAAK,aAAa,EAAE,MAAM,YAAY,CAAC;AAG5D;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,EAAE,MAAM,GAAG,OAAO,CAOhE;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,UAAU,EACtB,GAAG,EAAE,MAAM,EACX,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,aAAa,GAAG,SAAS,GAC/B,UAAU,CAoBZ"}

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,101 @@
+/**
+ * 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*, and the charge is what a word is
+ * worth against the frequencies around it. The whole frequency scale is 15
+ * buckets wide, so a charge of 15 already makes the rarest possible word beat
+ * the two commonest possible characters. This was 16 for most of the project's
+ * life, and with `WORD_CHARGE` on top of it the real price of a word boundary
+ * was 20.62 — five buckets past the point where frequency can say anything at
+ * all. Every 那是 in the language read `nà shi` on the strength of one
+ * colloquial CC-CEDICT entry no corpus has ever counted, and 都会, 过得, 得了
+ * and 的哥 went the same way.
+ *
+ * At 6 the price is 10.62 and the arithmetic decides something. A word loses
+ * its span to a two-character split when the two characters are more than
+ * 25.62 buckets better than it, which needs a word nothing attests standing
+ * against two characters near the top of the scale. An attested word survives
+ * whatever is beside it, so 地气 is still `dì qì`.
+ *
+ * Measured over the 88,866 lines of Tatoeba and zh.wikipedia the stage-4 rules
+ * were sized against, moving 16 to 6 changes 822 of 139,682 Han runs. The
+ * changes are 那是 (303), 都 read `dū` (141), 得 read `dé` after a verb (98),
+ * 为 read `wéi` where it means *for* (36), 一个 (27), and a tail of 了, 只, 中,
+ * 说 and 的. Against them stand 21 老是, 11 等地 and 10 倒是, where the word
+ * really was one word. On CPP's 20,139 hand-labelled polyphones it is 91.48%
+ * either way, and the gold corpus does not move.
+ *
+ * Word frequency survives as the tiebreak between paths covering the same span
+ * with the same number of words.
+ */
+export declare const READING_CHARGE = 6;
+/**
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,eAAO,MAAM,cAAc,IAAI,CAAC;AAEhC;;;;;GAKG;AACH,eAAO,MAAM,YAAY,KAAK,CAAC"}

package/dist/decode/lattice-types.js

@@ -0,0 +1,63 @@
+/**
+ * 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*, and the charge is what a word is
+ * worth against the frequencies around it. The whole frequency scale is 15
+ * buckets wide, so a charge of 15 already makes the rarest possible word beat
+ * the two commonest possible characters. This was 16 for most of the project's
+ * life, and with `WORD_CHARGE` on top of it the real price of a word boundary
+ * was 20.62 — five buckets past the point where frequency can say anything at
+ * all. Every 那是 in the language read `nà shi` on the strength of one
+ * colloquial CC-CEDICT entry no corpus has ever counted, and 都会, 过得, 得了
+ * and 的哥 went the same way.
+ *
+ * At 6 the price is 10.62 and the arithmetic decides something. A word loses
+ * its span to a two-character split when the two characters are more than
+ * 25.62 buckets better than it, which needs a word nothing attests standing
+ * against two characters near the top of the scale. An attested word survives
+ * whatever is beside it, so 地气 is still `dì qì`.
+ *
+ * Measured over the 88,866 lines of Tatoeba and zh.wikipedia the stage-4 rules
+ * were sized against, moving 16 to 6 changes 822 of 139,682 Han runs. The
+ * changes are 那是 (303), 都 read `dū` (141), 得 read `dé` after a verb (98),
+ * 为 read `wéi` where it means *for* (36), 一个 (27), and a tail of 了, 只, 中,
+ * 说 and 的. Against them stand 21 老是, 11 等地 and 10 倒是, where the word
+ * really was one word. On CPP's 20,139 hand-labelled polyphones it is 91.48%
+ * either way, and the gold corpus does not move.
+ *
+ * Word frequency survives as the tiebreak between paths covering the same span
+ * with the same number of words.
+ */
+export const READING_CHARGE = 6;
+/**
+ * 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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC;AAEhC;;;;;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"}