@kensio/pinyinjs 1.7.4 → 1.7.6

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"}

package/dist/decode/numbers.js

@@ -0,0 +1,69 @@
+import { isSpaced, numberPieces, runEdge } from "./number-pieces.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 { saidNumeral } from "../numerals/text.js";
+import { surroundingCharacters } from "./runs.js";
+import { plainPiece, sourcePiece, } from "./pieces.js";
+/**
+ * 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 function surrounding(runs, decoded, at) {
+    return {
+        after: {
+            character: surroundingCharacters(runs, at).following,
+            syllable: decoded[at + 1]?.[0]?.word.reading[0],
+        },
+        isAfterHan: runs[at - 1]?.isHan === true,
+    };
+}
+/**
+ * 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 function numeralBefore(segments) {
+    return segments.at(-1)?.hanzi ?? "";
+}
+/**
+ * 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 function writeNumbers(text, segments, context, written, options) {
+    if (segments.every((segment) => segment.reading === undefined)) {
+        return [sourcePiece(text)];
+    }
+    const pieces = [];
+    let before = runEdge(context.isAfterHan);
+    for (const segment of segments) {
+        if (isSpaced(before, segment.text)) {
+            pieces.push(plainPiece(" "));
+        }
+        pieces.push(...(segment.reading === undefined
+            ? [sourcePiece(segment.text)]
+            : numberPieces(saidNumeral(segment, context.after.syllable, options.sandhi), segment, written)));
+        // What decides the next space is what was *written*, not what was read:
+        // 95% ends in a sign and `bǎifēnzhījiǔshíwǔ` ends in a letter.
+        before = pieces.at(-1)?.text ?? before;
+    }
+    if (isSpaced(before, runEdge(context.after.character !== ""))) {
+        pieces.push(plainPiece(" "));
+    }
+    return pieces;
+}
+//# sourceMappingURL=numbers.js.map

package/dist/decode/numbers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"numbers.js","sourceRoot":"","sources":["../../src/decode/numbers.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,EAAE,MAAM,oBAAoB,CAAC;AACrE;;;;;;GAMG;AACH,OAAO,EAAuB,WAAW,EAAE,MAAM,qBAAqB,CAAC;AACvE,OAAO,EAAE,qBAAqB,EAAgB,MAAM,WAAW,CAAC;AAGhE,OAAO,EAEL,UAAU,EACV,WAAW,GAEZ,MAAM,aAAa,CAAC;AAcrB;;;;;;GAMG;AACH,MAAM,UAAU,WAAW,CACzB,IAAwB,EACxB,OAA2C,EAC3C,EAAU;IAEV,OAAO;QACL,KAAK,EAAE;YACL,SAAS,EAAE,qBAAqB,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS;YACpD,QAAQ,EAAE,OAAO,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;SAChD;QACD,UAAU,EAAE,IAAI,CAAC,EAAE,GAAG,CAAC,CAAC,EAAE,KAAK,KAAK,IAAI;KACzC,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,QAAmC;IAC/D,OAAO,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,KAAK,IAAI,EAAE,CAAC;AACtC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,YAAY,CAC1B,IAAY,EACZ,QAAmC,EACnC,OAAmB,EACnB,OAAgB,EAChB,OAAuD;IAEvD,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS,CAAC,EAAE,CAAC;QAC/D,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7B,CAAC;IAED,MAAM,MAAM,GAAqB,EAAE,CAAC;IACpC,IAAI,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC;IAEzC,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,IAAI,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC;YACnC,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;QAC/B,CAAC;QACD,MAAM,CAAC,IAAI,CACT,GAAG,CAAC,OAAO,CAAC,OAAO,KAAK,SAAS;YAC/B,CAAC,CAAC,CAAC,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;YAC7B,CAAC,CAAC,YAAY,CACV,WAAW,CAAC,OAAO,EAAE,OAAO,CAAC,KAAK,CAAC,QAAQ,EAAE,OAAO,CAAC,MAAM,CAAC,EAC5D,OAAO,EACP,OAAO,CACR,CAAC,CACP,CAAC;QACF,wEAAwE;QACxE,+DAA+D;QAC/D,MAAM,GAAG,MAAM,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,IAAI,MAAM,CAAC;IACzC,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,KAAK,CAAC,SAAS,KAAK,EAAE,CAAC,CAAC,EAAE,CAAC;QAC9D,MAAM,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC;IAC/B,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/decode/pieces.d.ts

@@ -0,0 +1,78 @@
+/**
+ * What a conversion is made of: the options it takes, and the pieces it
+ * hands back.
+ *
+ * The leaf layer of the conversion. Everything here builds or describes a
+ * single piece of output, and none of it knows how a text is decoded — which
+ * is what lets `convert.ts` sit on top of it.
+ */
+import type { ConvertedPiece, Written } from "./convert-options.js";
+import type { DecodedWord } from "./word.js";
+import type { Dictionary } from "../dictionary/dictionary.js";
+export type { ConvertedPiece, ConvertOptions, NumberStyle, Written, } from "./convert-options.js";
+import type { Locale } from "../script/script.js";
+import { type Syllable } from "../syllable/syllable.js";
+import type { ReadingConfidence } from "./confidence.js";
+/**
+ * The reading a word takes in a locale.
+ *
+ * `zh-TW` is stored as a delta, so a word with no Taiwan reading simply reads
+ * the same in both.
+ *
+ * The delta is measured against the entry's own 普通话 reading, so it only
+ * applies where the decode settled on that reading. A polyphone the decode read
+ * some other way — 长 as `cháng` where its entry reads `zhǎng`, 差 as `chā`
+ * where its entry reads `chà` — is a different sense of the word, and the delta
+ * beside the entry says nothing about it. Replacing the reading there would
+ * discard what the lattice worked out in favour of a reading of the wrong
+ * syllable entirely.
+ */
+export declare function readingFor(dictionary: Dictionary, word: DecodedWord, locale: Locale): readonly Syllable[];
+/**
+ * Text that writes no syllable: a space, or a run that was never Han.
+ */
+export declare function plainPiece(text: string): ConvertedPiece;
+/**
+ * Source text that is written out but read as nothing.
+ *
+ * The difference from {@link plainPiece} is what the text *is*. Both write no
+ * syllable, but a run that was never Han — punctuation, a Latin word, a digit
+ * left unread — stands for something the author wrote, whereas the space
+ * between two words and the hyphen inside 干干净净 are pinyin orthography that
+ * the source has no trace of.
+ *
+ * A conversion joins them into one string and the distinction does not arise.
+ * An annotation writes the source and the reading in different places, and
+ * putting a hyphen the pinyin needs into the hanzi it annotates would be
+ * inventing text: 干干净净 is `gāngān-jìngjìng` and is not written 干干-净净.
+ *
+ * The text and the source can differ, and the punctuation pass is why: it
+ * rewrites 。 to a full stop in the `text` a conversion writes, and leaves the
+ * `source` as the mark the author actually typed.
+ */
+export declare function sourcePiece(text: string): ConvertedPiece;
+/**
+ * Which characters of a word each of its syllables reads.
+ *
+ * One per syllable, in order, and undefined where a syllable reads on into the
+ * characters the one before it took. Only 儿化 does that: measured over the
+ * committed dictionary, 5,283 of 723,147 keys have fewer syllables than
+ * characters, 4,024 of them because a final 儿 folds into the syllable before
+ * it, and the remaining 1,259 because the word is written with punctuation —
+ * which cannot reach here, since punctuation ends a Han run before the decode
+ * ever sees it.
+ *
+ * The deficit is spent from the right, which is where 儿化 always is. 打哪儿指
+ * 哪儿 is the case that needs it: two syllables short over six characters, and
+ * both 儿 attach to the character in front of them rather than one taking two.
+ */
+export declare function sourcesOf(word: string, reading: readonly Syllable[]): readonly (string | undefined)[];
+/**
+ * Write one decoded word as one piece per syllable.
+ *
+ * Only proper nouns are capitalised here; a sentence capital is applied to the
+ * whole conversion afterwards, since it belongs to whichever run happens to
+ * start the sentence.
+ */
+export declare function writeWord(reading: readonly Syllable[], confidence: readonly ReadingConfidence[], word: DecodedWord, written: Written): readonly ConvertedPiece[];
+//# sourceMappingURL=pieces.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"pieces.d.ts","sourceRoot":"","sources":["../../src/decode/pieces.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,cAAc,EAAE,OAAO,EAAE,MAAM,sBAAsB,CAAC;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,WAAW,CAAC;AAG7C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,YAAY,EACV,cAAc,EACd,cAAc,EACd,WAAW,EACX,OAAO,GACR,MAAM,sBAAsB,CAAC;AAI9B,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAE,KAAK,QAAQ,EAAiB,MAAM,yBAAyB,CAAC;AACvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AACzD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,UAAU,CACxB,UAAU,EAAE,UAAU,EACtB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,MAAM,GACb,SAAS,QAAQ,EAAE,CAWrB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAOvD;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,cAAc,CAOxD;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,SAAS,QAAQ,EAAE,GAC3B,SAAS,CAAC,MAAM,GAAG,SAAS,CAAC,EAAE,CA2BjC;AAED;;;;;;GAMG;AACH,wBAAgB,SAAS,CACvB,OAAO,EAAE,SAAS,QAAQ,EAAE,EAC5B,UAAU,EAAE,SAAS,iBAAiB,EAAE,EACxC,IAAI,EAAE,WAAW,EACjB,OAAO,EAAE,OAAO,GACf,SAAS,cAAc,EAAE,CAqB3B"}