@kensio/pinyinjs 1.7.4 → 1.7.5

package/dist/search/match.js

@@ -1,382 +1,5 @@
-import { isSameReading } from "../dictionary/entry.js";
-import { isErCharacter, withErhua } from "../dictionary/erhua.js";
-import { sourcesOf } from "../decode/convert.js";
-import { segment } from "../decode/segment.js";
-import { toCharacters } from "../script/characters.js";
-import { toCanonicalGlyphs } from "../script/glyphs.js";
-import { normaliseQuery, readQueryChunks, skipSeparators, } from "./query.js";
-/**
- * What a match scores for reading its characters the way the text reads them.
- *
- * The one thing this has that a reverse index cannot: every reading a character
- * takes is matchable, so 行 is found by both `xing` and `hang` — and the decoder
- * has already settled which of them the text in front of it means. So 银行 ranks
- * `yh` above `yx`, and 长江 ranks `cj` above `zj`, without either being refused.
- *
- * Weighted by the share of the matched characters that agree, rather than by how
- * many, so that a long match and a short one are scored on the same scale.
- */
-const CONTEXT_READING = 4;
-/**
- * What a match scores for starting where a word starts.
- *
- * 大学 in 北京大学 is the second half of a word a reader thinks of as one thing;
- * 大学 in 大学生 starts it. Both are matches and the second is the better one.
- */
-const WORD_START = 2;
-/**
- * What a match at the very start of the haystack scores, decaying with position.
- *
- * A tie-break rather than a judgement, and deliberately smaller than
- * {@link WORD_START}: it settles two matches that are otherwise alike, and never
- * outranks starting a word.
- */
-const EARLINESS = 1;
-/**
- * What one character scores for being written out in full rather than initialled.
- *
- * Only used to choose between the ways one query can be read over one haystack,
- * never in the score a caller sees: `beij` over 北京大学 is 北 spelled out and 京
- * initialled, and no other reading of it is on offer. Where two are — `xian` is
- * both 西安 and 县 — the fuller spelling is the one the typist meant.
- *
- * Per character, which is what settles 这儿 against `zher`: read as 这 `zhèr` it
- * spells two characters out at once, where 这 abbreviated to `zh` and 儿 as `er`
- * spells one of them and initials the other.
- */
-const SPELLED_OUT = 1;
-/**
- * What one step down a character's reading list costs, likeliest reading first.
- *
- * The dictionary's own order, applied before the decoder has been asked
- * anything: it is what separates 行 `xíng` from 行 `hàng` when the query could
- * be either and the surrounding text says nothing.
- */
-const RARE_READING = 2;
-/**
- * What crossing one character with no reading costs.
- *
- * A separator inside a name is worth stepping over — 北京·大学 is one thing
- * with a mark in the middle of it — and a query that steps over half a line of
- * Latin to reach its second half has found something more tenuous.
- */
-const CROSSED = 0.5;
-/**
- * The query having been read to its end, with nothing left to account for.
- */
-const COMPLETE = { steps: [], score: 0 };
-/**
- * The steps of a match, gathered into the stretches they cover.
- */
-function rangesOf(steps) {
-    const ranges = [];
-    for (const step of steps) {
-        if (!step.isRead) {
-            continue;
-        }
-        const last = ranges.at(-1);
-        if (last !== undefined && last.at + last.length === step.at) {
-            ranges[ranges.length - 1] = { at: last.at, length: last.length + 1 };
-            continue;
-        }
-        ranges.push({ at: step.at, length: 1 });
-    }
-    return ranges;
-}
-/**
- * Ask the decoder what the haystack says, for the two things ranking needs.
- *
- * Worked out once a match is known to exist rather than before, because this is
- * a decode of the whole text and matching is not: a search box filtering a list
- * asks the cheap question of every item and pays for this on the few that hit.
- */
-function contextOf(dictionary, haystack) {
-    const preferred = [];
-    const wordStarts = new Set();
-    for (const word of segment(dictionary, haystack)) {
-        if (word.reading.length === 0) {
-            continue;
-        }
-        wordStarts.add(word.at);
-        // `sourcesOf` is the decoder's own answer to which characters a syllable
-        // reads, 儿化 included. It names the whole word and then nothing where it
-        // cannot say, which is not an alignment and is dropped rather than guessed.
-        const sources = sourcesOf(word.text, word.reading).filter((source) => source !== undefined);
-        if (sources.length !== word.reading.length) {
-            continue;
-        }
-        let at = word.at;
-        for (const [index, source] of sources.entries()) {
-            for (const _ of toCharacters(source)) {
-                preferred[at] = word.reading[index];
-                at++;
-            }
-        }
-    }
-    return { preferred, wordStarts };
-}
-/**
- * How much of a match was written the way the text is actually read.
- *
- * Asked of what the query wrote rather than of the reading the search happened
- * to take it by: 西 is stored with a neutral-toned `xi` and a first-tone `xī`,
- * and a query writing `xi` has picked neither of them over the other. What it
- * has done is write something the settled reading can account for, which is the
- * question — and the one `yx` over 银行 answers differently from `yh`.
- */
-function agreementOf(query, steps, preferred) {
-    let comparable = 0;
-    let agreeing = 0;
-    for (const step of steps) {
-        const settled = preferred[step.at];
-        if (!step.isRead || settled === undefined) {
-            continue;
-        }
-        comparable++;
-        const written = readQueryChunks(query, step.from, settled);
-        if (written.some((chunk) => chunk.next === step.next)) {
-            agreeing++;
-        }
-    }
-    return comparable === 0 ? 0 : agreeing / comparable;
-}
-/**
- * One query being read over one haystack.
- *
- * The search is a walk over two sequences at once — the haystack's characters
- * and the query's letters — where each character may account for some of the
- * query in more than one way, since it may have more than one reading and each
- * reading may be written out or abbreviated. Memoised on the pair of positions,
- * which is what stops the ways of splitting a long query multiplying out.
- */
-class Search {
-    #dictionary;
-    #haystack;
-    #characters;
-    #query;
-    #readings = [];
-    #paths = new Map();
-    constructor(dictionary, haystack, query) {
-        this.#dictionary = dictionary;
-        this.#haystack = haystack;
-        this.#characters = toCharacters(haystack);
-        this.#query = query;
-    }
-    /**
-     * Every reading a character offers, likeliest first, asked for once.
-     *
-     * Canonicalised here rather than left to the dictionary, so that a Hong Kong
-     * glyph form is matched by the readings of the Taiwan-standard key it folds
-     * to rather than by nothing.
-     *
-     * The 國語 reading goes on the end where it differs, so that 圾 answers to
-     * `se` as well as to `ji`. A search box is not the place to insist on one
-     * standard: somebody typing what they say is not typing it wrongly, and the
-     * decoder's own reading is what ranks the two afterwards.
-     */
-    #readingsAt(at) {
-        const held = this.#readings[at];
-        if (held !== undefined) {
-            return held;
-        }
-        /* c8 ignore next -- only ever asked about a character that is there */
-        const character = toCanonicalGlyphs(this.#characters[at] ?? "");
-        const found = this.#dictionary.readingsOf(character);
-        const taiwan = this.#dictionary.lookup(character)?.taiwanReading;
-        const readings = taiwan === undefined ||
-            found.some((reading) => isSameReading(reading, taiwan))
-            ? found
-            : [...found, taiwan];
-        this.#readings[at] = readings;
-        return readings;
-    }
-    /**
-     * Every reading the query could be accounting for at a character.
-     *
-     * One per reading the character has — and one more for each of them where an
-     * 儿 follows, carrying the r suffix that character stands for. 玩儿 is
-     * `wánr`, one syllable over two characters, and somebody looking for it types
-     * `wanr`: the r is part of how the word is said, so it is part of how the
-     * word is searched for.
-     *
-     * Offered wherever an 儿 follows rather than only where the dictionary
-     * attests the 儿化, because the query is what decides which of them was
-     * meant. 女儿 is `nǚ'ér` and not `nǚr`, and typing `nvr` still finds it —
-     * below `nver`, since the reading the text takes is what ranks them.
-     */
-    #candidatesAt(at) {
-        const readings = this.#readingsAt(at);
-        const plain = readings.map((reading, rank) => ({
-            reading,
-            rank,
-            characters: 1,
-        }));
-        if (!isErCharacter(this.#characters[at + 1] ?? "")) {
-            return plain;
-        }
-        return [
-            ...plain,
-            ...readings.flatMap((reading, rank) => {
-                const last = reading.at(-1);
-                /* c8 ignore next 3 -- a stored reading is never empty or already r-ed */
-                if (last === undefined || last.erhua === true) {
-                    return [];
-                }
-                return [
-                    {
-                        reading: [...reading.slice(0, -1), withErhua(last)],
-                        rank,
-                        characters: 2,
-                    },
-                ];
-            }),
-        ];
-    }
-    /**
-     * Every position the query can be read up to by one whole reading.
-     *
-     * A reading is usually one syllable, and is not always: 瓩 is `qiānwǎ`, one
-     * character read as two. The query accounts for them in order, and may run
-     * out partway through, which is a query still being typed.
-     */
-    #chunksFor(from, reading) {
-        let reached = [{ next: from, isFull: true }];
-        for (const syllable of reading) {
-            const found = [];
-            for (const chunk of reached) {
-                const start = skipSeparators(this.#query, chunk.next);
-                if (start === this.#query.length) {
-                    found.push({ next: start, isFull: chunk.isFull });
-                    continue;
-                }
-                for (const one of readQueryChunks(this.#query, start, syllable)) {
-                    found.push({
-                        next: one.next,
-                        isFull: chunk.isFull && one.isFull,
-                    });
-                }
-            }
-            reached = found;
-        }
-        return reached;
-    }
-    /**
-     * The best way of reading the rest of the query from a character, or nothing.
-     */
-    #from(at, offset) {
-        const start = skipSeparators(this.#query, offset);
-        if (start === this.#query.length) {
-            return COMPLETE;
-        }
-        if (at >= this.#characters.length) {
-            return undefined;
-        }
-        const key = `${String(at)}:${String(start)}`;
-        const held = this.#paths.get(key);
-        if (held !== undefined || this.#paths.has(key)) {
-            return held;
-        }
-        const found = this.#read(at, start);
-        this.#paths.set(key, found);
-        return found;
-    }
-    /**
-     * Read one character, every way it can be read, and keep the best.
-     */
-    #read(at, start) {
-        const candidates = this.#candidatesAt(at);
-        if (candidates.length === 0) {
-            return this.#cross(at, start);
-        }
-        let best;
-        for (const candidate of candidates) {
-            for (const chunk of this.#chunksFor(start, candidate.reading)) {
-                const rest = this.#from(at + candidate.characters, chunk.next);
-                if (rest === undefined) {
-                    continue;
-                }
-                const score = rest.score +
-                    (chunk.isFull ? SPELLED_OUT * candidate.characters : 0) -
-                    candidate.rank * RARE_READING;
-                if (best === undefined || score > best.score) {
-                    best = {
-                        steps: [
-                            ...Array.from({ length: candidate.characters }, (_, covered) => ({
-                                at: at + covered,
-                                isRead: true,
-                                from: start,
-                                next: chunk.next,
-                            })),
-                            ...rest.steps,
-                        ],
-                        score,
-                    };
-                }
-            }
-        }
-        return best;
-    }
-    /**
-     * Step over a character with no reading, which a match may span but not end
-     * on: the query is checked for having been read to its end first.
-     */
-    #cross(at, start) {
-        const rest = this.#from(at + 1, start);
-        return rest === undefined
-            ? undefined
-            : {
-                steps: [
-                    { at, isRead: false, from: start, next: start },
-                    ...rest.steps,
-                ],
-                score: rest.score - CROSSED,
-            };
-    }
-    /**
-     * Where the query matches at all, and how it reads at each of those places.
-     */
-    #everyMatch() {
-        const found = [];
-        for (const [at] of this.#characters.entries()) {
-            if (this.#readingsAt(at).length === 0) {
-                continue;
-            }
-            const path = this.#from(at, 0);
-            if (path !== undefined) {
-                found.push(path);
-            }
-        }
-        return found;
-    }
-    /**
-     * The best match, or undefined where the query matches nowhere.
-     */
-    best() {
-        const found = this.#everyMatch();
-        if (found.length === 0) {
-            return undefined;
-        }
-        const context = contextOf(this.#dictionary, this.#haystack);
-        let best;
-        for (const path of found) {
-            const ranges = rangesOf(path.steps);
-            /* c8 ignore next 3 -- a match always starts on a character it read */
-            if (ranges[0] === undefined) {
-                continue;
-            }
-            const start = ranges[0].at;
-            const score = CONTEXT_READING *
-                agreementOf(this.#query, path.steps, context.preferred) +
-                (context.wordStarts.has(start) ? WORD_START : 0) +
-                EARLINESS / (1 + start);
-            // Strictly better, so that two matches worth the same keep the earlier.
-            if (best === undefined || score > best.score) {
-                best = { ranges, score };
-            }
-        }
-        return best;
-    }
-}
+import { normaliseQuery } from "./query.js";
+import { Search } from "./match-search.js";
 /**
  * Find where a pinyin query matches a Chinese text, for filtering and
  * highlighting.

package/dist/search/match.js.map

@@ -1 +1 @@
-{"version":3,"file":"match.js","sourceRoot":"","sources":["../../src/search/match.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"match.js","sourceRoot":"","sources":["../../src/search/match.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAC5C,OAAO,EAAoB,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAK7D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,UAAU,KAAK,CACnB,UAAsB,EACtB,QAAgB,EAChB,KAAa;IAEb,MAAM,UAAU,GAAG,cAAc,CAAC,KAAK,CAAC,CAAC;IACzC,IAAI,UAAU,KAAK,EAAE,IAAI,QAAQ,KAAK,EAAE,EAAE,CAAC;QACzC,OAAO,SAAS,CAAC;IACnB,CAAC;IACD,OAAO,IAAI,MAAM,CAAC,UAAU,EAAE,QAAQ,EAAE,UAAU,CAAC,CAAC,IAAI,EAAE,CAAC;AAC7D,CAAC"}

package/dist/search/reverse-index-build.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Deriving the reverse index a slice at a time.
+ *
+ * The full tier costs about half a second to derive, so the build is handed
+ * back as a stepper a caller can drive from an idle callback rather than a
+ * function that blocks. What each pass does is `reverse-index-state.ts`; what
+ * is here is how much of it one step is worth.
+ */
+import type { Dictionary } from "../dictionary/dictionary.js";
+import { ReverseIndex } from "./reverse-index.js";
+import { type ReverseIndexBuild } from "./reverse-index-passes.js";
+export { readingKey, type ReverseIndexData } from "./reverse-index-format.js";
+/**
+ * The streaming build, which never holds every reading at once.
+ *
+ * Three passes over the dictionary — count the groups, fill them, rank them —
+ * with a fourth between the first two that lays the groups out. The only things
+ * about them that need the dictionary are the two functions they are driven by:
+ * what a position is read as, and how common the word there is.
+ */
+export declare function startBuild(dictionary: Dictionary): ReverseIndexBuild;
+/**
+ * Derive the whole index in one go, which is {@link ReverseIndex.of}.
+ *
+ * Stepped without a bound rather than built by a separate path, so there is one
+ * implementation of the build and the two entry points differ only in how much
+ * of it they ask for at a time.
+ */
+export declare function buildAll(dictionary: Dictionary): ReverseIndex;
+//# sourceMappingURL=reverse-index-build.d.ts.map

package/dist/search/reverse-index-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-index-build.d.ts","sourceRoot":"","sources":["../../src/search/reverse-index-build.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAE9D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,OAAO,EAAc,KAAK,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAS/E,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE9E;;;;;;;GAOG;AACH,wBAAgB,UAAU,CAAC,UAAU,EAAE,UAAU,GAAG,iBAAiB,CAmDpE;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,YAAY,CAO7D"}

package/dist/search/reverse-index-build.js

@@ -0,0 +1,72 @@
+import { FREQUENCY_BUCKETS } from "../dictionary/frequency-table.js";
+import { ReverseIndex } from "./reverse-index.js";
+import { LINE, readingKey, STEP } from "./reverse-index-format.js";
+import { progressOf } from "./reverse-index-passes.js";
+import { countPass, fillPass, orderPass, rankPass, startState, } from "./reverse-index-state.js";
+export { readingKey } from "./reverse-index-format.js";
+/**
+ * The streaming build, which never holds every reading at once.
+ *
+ * Three passes over the dictionary — count the groups, fill them, rank them —
+ * with a fourth between the first two that lays the groups out. The only things
+ * about them that need the dictionary are the two functions they are driven by:
+ * what a position is read as, and how common the word there is.
+ */
+export function startBuild(dictionary) {
+    const readings = dictionary.readingsInOrder();
+    const state = startState();
+    /** The reading key at a position, or the empty string where there is none. */
+    const keyAt = (position) => readingKey(readings.readingAt(position));
+    /** Where a position sorts, commonest first: the bucket, counted downwards. */
+    const rankOf = (position) => FREQUENCY_BUCKETS - 1 - dictionary.frequencyAt(position);
+    return {
+        get progress() {
+            return progressOf(state.pass, state.at, readings.size, state.layout.keys.length);
+        },
+        step(positions = STEP) {
+            switch (state.pass) {
+                case "counting": {
+                    countPass(state, readings.size, keyAt, positions);
+                    return undefined;
+                }
+                case "ordering": {
+                    orderPass(state);
+                    return undefined;
+                }
+                case "filling": {
+                    fillPass(state, readings.size, keyAt, positions);
+                    return undefined;
+                }
+                case "ranking": {
+                    return rankPass(state, positions, rankOf)
+                        ? ReverseIndex.from(dictionary, {
+                            keys: state.layout.keys.join(LINE),
+                            postings: state.layout.postings,
+                            starts: state.layout.starts,
+                        })
+                        : undefined;
+                }
+                /* c8 ignore next 3 -- a finished build is not stepped again */
+                case "done": {
+                    return undefined;
+                }
+            }
+        },
+    };
+}
+/**
+ * Derive the whole index in one go, which is {@link ReverseIndex.of}.
+ *
+ * Stepped without a bound rather than built by a separate path, so there is one
+ * implementation of the build and the two entry points differ only in how much
+ * of it they ask for at a time.
+ */
+export function buildAll(dictionary) {
+    const build = startBuild(dictionary);
+    let index = build.step(Number.POSITIVE_INFINITY);
+    while (index === undefined) {
+        index = build.step(Number.POSITIVE_INFINITY);
+    }
+    return index;
+}
+//# sourceMappingURL=reverse-index-build.js.map

package/dist/search/reverse-index-build.js.map

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

package/dist/search/reverse-index-format.d.ts

@@ -0,0 +1,60 @@
+/**
+ * How the reverse index is laid out on disk.
+ *
+ * The key a reading is stored under and the packed arrays behind it.
+ * `reverse-index.ts` is the index built on top of both.
+ */
+/**
+ * The separator between reading keys, matching what {@link KeyIndex} expects.
+ */
+export declare const LINE = "\n";
+export declare const SPACE = 32;
+export declare const ZERO = 48;
+export declare const FIVE = 53;
+export declare const UMLAUT_U = "\u00FC";
+export declare const PLAIN_U = "u";
+/**
+ * How many positions one {@link ReverseIndexBuild.step} covers by default.
+ *
+ * Sized so that a step is a frame rather than several: the full tier's build is
+ * about 510 ms of work over 723,147 keys, so 20,000 keys is roughly 14 ms of it.
+ * A caller with a frame budget of its own should pass its own number rather than
+ * trust this one.
+ */
+export declare const STEP = 20000;
+/**
+ * Fold a stored reading into the key a typist's spelling reaches it by.
+ *
+ * `yin2 hang2` becomes `yinhang` and `lü4 se4` becomes `luse`. Three things go:
+ * the spaces, because nobody types them; the tone digits, because a typist
+ * mostly does not write tones and a toned query is answered by filtering a
+ * toneless list rather than by a second index; and the umlaut, because `lu` and
+ * `lv` both have to reach 绿 and the only spelling both of them fold to is `lu`.
+ *
+ * The 儿化 r **stays**, so 玩儿 is keyed `wanr` and not `wan`. It is a letter a
+ * typist writes, and the query side reaches the key from both directions by
+ * searching `wan` and `wanr` alike — see `candidates`.
+ *
+ * Nothing here parses a syllable, which is what keeps a pass over every key in
+ * the dictionary affordable.
+ */
+export declare function readingKey(reading: string): string;
+/**
+ * A reverse index in the form it can be handed between threads.
+ *
+ * Three pieces, the same shape the forward index has: the reading keys as one
+ * sorted newline-joined blob, the dictionary positions grouped under them, and
+ * where each group begins. The two arrays are transferable and the blob is a
+ * string, so a worker can build this and post it back with no copy of the
+ * postings — which is the point, since the full tier's build is over half a
+ * second and does not belong on the main thread.
+ */
+export interface ReverseIndexData {
+    /** Sorted reading keys, newline-joined: a {@link KeyIndex} blob. */
+    readonly keys: string;
+    /** Dictionary positions, grouped by reading key, likeliest first. */
+    readonly postings: Uint32Array;
+    /** Where each key's postings begin, with one past the end on the tail. */
+    readonly starts: Uint32Array;
+}
+//# sourceMappingURL=reverse-index-format.d.ts.map

package/dist/search/reverse-index-format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-index-format.d.ts","sourceRoot":"","sources":["../../src/search/reverse-index-format.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,eAAO,MAAM,IAAI,OAAO,CAAC;AAEzB,eAAO,MAAM,KAAK,KAAK,CAAC;AAExB,eAAO,MAAM,IAAI,KAAK,CAAC;AAEvB,eAAO,MAAM,IAAI,KAAK,CAAC;AAEvB,eAAO,MAAM,QAAQ,WAAM,CAAC;AAE5B,eAAO,MAAM,OAAO,MAAM,CAAC;AAE3B;;;;;;;GAOG;AACH,eAAO,MAAM,IAAI,QAAS,CAAC;AAE3B;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAYlD;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,qEAAqE;IACrE,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,0EAA0E;IAC1E,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC9B"}

package/dist/search/reverse-index-format.js

@@ -0,0 +1,54 @@
+/**
+ * How the reverse index is laid out on disk.
+ *
+ * The key a reading is stored under and the packed arrays behind it.
+ * `reverse-index.ts` is the index built on top of both.
+ */
+/**
+ * The separator between reading keys, matching what {@link KeyIndex} expects.
+ */
+export const LINE = "\n";
+export const SPACE = 32;
+export const ZERO = 48;
+export const FIVE = 53;
+export const UMLAUT_U = "ü";
+export const PLAIN_U = "u";
+/**
+ * How many positions one {@link ReverseIndexBuild.step} covers by default.
+ *
+ * Sized so that a step is a frame rather than several: the full tier's build is
+ * about 510 ms of work over 723,147 keys, so 20,000 keys is roughly 14 ms of it.
+ * A caller with a frame budget of its own should pass its own number rather than
+ * trust this one.
+ */
+export const STEP = 20_000;
+/**
+ * Fold a stored reading into the key a typist's spelling reaches it by.
+ *
+ * `yin2 hang2` becomes `yinhang` and `lü4 se4` becomes `luse`. Three things go:
+ * the spaces, because nobody types them; the tone digits, because a typist
+ * mostly does not write tones and a toned query is answered by filtering a
+ * toneless list rather than by a second index; and the umlaut, because `lu` and
+ * `lv` both have to reach 绿 and the only spelling both of them fold to is `lu`.
+ *
+ * The 儿化 r **stays**, so 玩儿 is keyed `wanr` and not `wan`. It is a letter a
+ * typist writes, and the query side reaches the key from both directions by
+ * searching `wan` and `wanr` alike — see `candidates`.
+ *
+ * Nothing here parses a syllable, which is what keeps a pass over every key in
+ * the dictionary affordable.
+ */
+export function readingKey(reading) {
+    let key = "";
+    for (let at = 0; at < reading.length; at++) {
+        /* c8 ignore next -- `at` is inside the string, so the fallback cannot fire */
+        const code = reading.codePointAt(at) ?? 0;
+        if (code === SPACE || (code >= ZERO && code <= FIVE)) {
+            continue;
+        }
+        const character = reading.charAt(at);
+        key += character === UMLAUT_U ? PLAIN_U : character;
+    }
+    return key;
+}
+//# sourceMappingURL=reverse-index-format.js.map

package/dist/search/reverse-index-format.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-index-format.js","sourceRoot":"","sources":["../../src/search/reverse-index-format.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,IAAI,CAAC;AAEzB,MAAM,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;AAExB,MAAM,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;AAEvB,MAAM,CAAC,MAAM,IAAI,GAAG,EAAE,CAAC;AAEvB,MAAM,CAAC,MAAM,QAAQ,GAAG,GAAG,CAAC;AAE5B,MAAM,CAAC,MAAM,OAAO,GAAG,GAAG,CAAC;AAE3B;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,MAAM,CAAC;AAE3B;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,UAAU,CAAC,OAAe;IACxC,IAAI,GAAG,GAAG,EAAE,CAAC;IACb,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,EAAE,EAAE,EAAE,CAAC;QAC3C,8EAA8E;QAC9E,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;QAC1C,IAAI,IAAI,KAAK,KAAK,IAAI,CAAC,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,IAAI,CAAC,EAAE,CAAC;YACrD,SAAS;QACX,CAAC;QACD,MAAM,SAAS,GAAG,OAAO,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;QACrC,GAAG,IAAI,SAAS,KAAK,QAAQ,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,SAAS,CAAC;IACtD,CAAC;IACD,OAAO,GAAG,CAAC;AACb,CAAC"}