@kensio/pinyinjs 1.7.4 → 1.7.6

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

@@ -0,0 +1,37 @@
+/**
+ * The layout the fill and rank passes are written against.
+ */
+export interface GroupLayout {
+    /** The reading keys, sorted by code unit, which is `KeyIndex` order. */
+    readonly keys: readonly string[];
+    /** Where each group begins, with one past the end on the tail. */
+    readonly starts: Uint32Array;
+    /** Which group a reading key is, for the fill pass. */
+    readonly slots: Map<string, number>;
+    /** The largest group, which is how big the ranking scratch must be. */
+    readonly widest: number;
+    /** Where the fill pass has got to within each group. */
+    readonly cursors: Uint32Array;
+    /** The postings themselves, empty until the fill pass runs. */
+    readonly postings: Uint32Array;
+}
+/**
+ * Sort the reading keys and lay out where each group's postings go.
+ *
+ * Sorted as pairs rather than by key and looked up again, and by code unit
+ * rather than by locale, which is the order `KeyIndex` searches in.
+ */
+export declare function layOutGroups(counts: ReadonlyMap<string, number>): GroupLayout;
+/**
+ * Sort one group likeliest-first, which is a counting sort on the bucket.
+ *
+ * Buckets run 0 to 15, so there is nothing to compare: tally the group, turn
+ * the tally into offsets, and deal the postings out. Stable, so two words in
+ * the same bucket keep the dictionary's own order and the result does not
+ * depend on how the fill pass happened to lay the postings down.
+ *
+ * The scratch and tally arrays are the caller's, so that ranking 723,147
+ * postings allocates twice rather than twice per group.
+ */
+export declare function rankGroup(postings: Uint32Array, from: number, to: number, scratch: Uint32Array, tally: Uint32Array, rankOf: (position: number) => number): void;
+//# sourceMappingURL=reverse-index-groups.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-index-groups.d.ts","sourceRoot":"","sources":["../../src/search/reverse-index-groups.ts"],"names":[],"mappings":"AAUA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,wEAAwE;IACxE,QAAQ,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACjC,kEAAkE;IAClE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;IAC7B,uDAAuD;IACvD,QAAQ,CAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACpC,uEAAuE;IACvE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,wDAAwD;IACxD,QAAQ,CAAC,OAAO,EAAE,WAAW,CAAC;IAC9B,+DAA+D;IAC/D,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;CAChC;AAED;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,WAAW,CAwB7E;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,CACvB,QAAQ,EAAE,WAAW,EACrB,IAAI,EAAE,MAAM,EACZ,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,WAAW,EACpB,KAAK,EAAE,WAAW,EAClB,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GACnC,IAAI,CAoBN"}

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

@@ -0,0 +1,71 @@
+/**
+ * Where each reading's postings go, and what order they go in.
+ *
+ * The two parts of the build that are about a group rather than about a pass:
+ * laying the groups out once the counts are in, and sorting one of them
+ * likeliest-first. Both are ordinary functions over arrays, and neither knows
+ * anything about the state machine that calls them.
+ */
+import { readAt } from "./reverse-index-passes.js";
+/**
+ * Sort the reading keys and lay out where each group's postings go.
+ *
+ * Sorted as pairs rather than by key and looked up again, and by code unit
+ * rather than by locale, which is the order `KeyIndex` searches in.
+ */
+export function layOutGroups(counts) {
+    const ordered = [...counts].toSorted(([left], [right]) => left < right ? -1 : Number(left > right));
+    const keys = ordered.map(([key]) => key);
+    const starts = new Uint32Array(keys.length + 1);
+    const slots = new Map();
+    let running = 0;
+    let widest = 0;
+    for (const [group, [key, held]] of ordered.entries()) {
+        slots.set(key, group);
+        starts[group] = running;
+        running += held;
+        widest = Math.max(widest, held);
+    }
+    starts[keys.length] = running;
+    return {
+        keys,
+        starts,
+        slots,
+        widest,
+        cursors: starts.slice(0, keys.length),
+        postings: new Uint32Array(running),
+    };
+}
+/**
+ * Sort one group likeliest-first, which is a counting sort on the bucket.
+ *
+ * Buckets run 0 to 15, so there is nothing to compare: tally the group, turn
+ * the tally into offsets, and deal the postings out. Stable, so two words in
+ * the same bucket keep the dictionary's own order and the result does not
+ * depend on how the fill pass happened to lay the postings down.
+ *
+ * The scratch and tally arrays are the caller's, so that ranking 723,147
+ * postings allocates twice rather than twice per group.
+ */
+export function rankGroup(postings, from, to, scratch, tally, rankOf) {
+    tally.fill(0);
+    for (let cursor = from; cursor < to; cursor++) {
+        const position = readAt(postings, cursor);
+        scratch[cursor - from] = position;
+        const bucket = rankOf(position);
+        tally[bucket] = readAt(tally, bucket) + 1;
+    }
+    let running = from;
+    for (let bucket = 0; bucket < tally.length; bucket++) {
+        const held = readAt(tally, bucket);
+        tally[bucket] = running;
+        running += held;
+    }
+    for (let cursor = 0; cursor < to - from; cursor++) {
+        const position = readAt(scratch, cursor);
+        const bucket = rankOf(position);
+        postings[readAt(tally, bucket)] = position;
+        tally[bucket] = readAt(tally, bucket) + 1;
+    }
+}
+//# sourceMappingURL=reverse-index-groups.js.map

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

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

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

@@ -0,0 +1,78 @@
+/**
+ * The passes a reverse index build runs, and how far along it is.
+ *
+ * A leaf both the build and the index import, rather than either importing the
+ * other: what the stepper is, what it is doing and how far along it is, plus
+ * the empty posting list and the checked read that both sides use.
+ */
+import type { ReverseIndex } from "./reverse-index.js";
+/**
+ * A reverse index being built, a slice at a time.
+ *
+ * The full tier costs about 510 ms to derive, which is thirty-odd frames, so the
+ * build is a state machine a caller can drive from `requestIdleCallback` rather
+ * than a function that takes the thread. `core` is 4 ms and `standard` is 62 ms,
+ * and both can simply be built with {@link ReverseIndex.of}.
+ *
+ * ```ts
+ * const build = ReverseIndex.building(dictionary);
+ * const tick = (): void => {
+ *   const index = build.step();
+ *   if (index === undefined) {
+ *     requestIdleCallback(tick);
+ *   }
+ * };
+ * requestIdleCallback(tick);
+ * ```
+ */
+export interface ReverseIndexBuild {
+    /**
+     * How much of the build is done, from 0 to 1.
+     */
+    readonly progress: number;
+    /**
+     * Do some more of the work, returning the index once there is none left.
+     *
+     * `positions` bounds a step to that many dictionary positions, or that many
+     * reading groups while the last pass is ranking them. It is a bound rather
+     * than a promise: the pass that sorts the reading keys cannot be divided, and
+     * is one step of its own.
+     */
+    readonly step: (positions?: number) => ReverseIndex | undefined;
+}
+/**
+ * Which pass a build is on.
+ */
+export type Pass = "counting" | "ordering" | "filling" | "ranking" | "done";
+/**
+ * What share of the build each pass is worth, for
+ * {@link import("./reverse-index.js").ReverseIndexBuild.progress}.
+ */
+export declare const SHARE: {
+    counting: number;
+    filling: number;
+    ranking: number;
+};
+/**
+ * The empty posting list, shared rather than allocated per miss.
+ */
+export declare const NONE: Uint32Array<ArrayBuffer>;
+/**
+ * Read a `Uint32Array` at an index that is in range by construction.
+ *
+ * `noUncheckedIndexedAccess` types every read as possibly undefined, and every
+ * one below is bounded by the layout of the array it indexes — a group start, a
+ * cursor inside a group, a bucket between 0 and 15. Gathered here rather than
+ * written as a fallback at each of them, since a fallback that cannot happen
+ * reads as a case somebody considered.
+ */
+export declare function readAt(values: Uint32Array, at: number): number;
+/**
+ * How much of the build is done, from 0 to 1.
+ *
+ * The counting and filling passes are measured in dictionary positions and the
+ * ranking pass in reading groups, so the two counts are both taken and each
+ * pass reports against the one it is walking.
+ */
+export declare function progressOf(pass: Pass, at: number, positions: number, groups: number): number;
+//# sourceMappingURL=reverse-index-passes.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-index-passes.d.ts","sourceRoot":"","sources":["../../src/search/reverse-index-passes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAEvD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,CAAC;CACjE;AAED;;GAEG;AACH,MAAM,MAAM,IAAI,GAAG,UAAU,GAAG,UAAU,GAAG,SAAS,GAAG,SAAS,GAAG,MAAM,CAAC;AAE5E;;;GAGG;AACH,eAAO,MAAM,KAAK;IAAK,QAAQ;IAAQ,OAAO;IAAQ,OAAO;CAAO,CAAC;AAErE;;GAEG;AACH,eAAO,MAAM,IAAI,0BAAqB,CAAC;AAEvC;;;;;;;;GAQG;AAEH,wBAAgB,MAAM,CAAC,MAAM,EAAE,WAAW,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAE9D;AAED;;;;;;GAMG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,IAAI,EACV,EAAE,EAAE,MAAM,EACV,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,MAAM,GACb,MAAM,CAuBR"}

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

@@ -0,0 +1,59 @@
+/**
+ * The passes a reverse index build runs, and how far along it is.
+ *
+ * A leaf both the build and the index import, rather than either importing the
+ * other: what the stepper is, what it is doing and how far along it is, plus
+ * the empty posting list and the checked read that both sides use.
+ */
+/**
+ * What share of the build each pass is worth, for
+ * {@link import("./reverse-index.js").ReverseIndexBuild.progress}.
+ */
+export const SHARE = { counting: 0.45, filling: 0.45, ranking: 0.1 };
+/**
+ * The empty posting list, shared rather than allocated per miss.
+ */
+export const NONE = new Uint32Array(0);
+/**
+ * Read a `Uint32Array` at an index that is in range by construction.
+ *
+ * `noUncheckedIndexedAccess` types every read as possibly undefined, and every
+ * one below is bounded by the layout of the array it indexes — a group start, a
+ * cursor inside a group, a bucket between 0 and 15. Gathered here rather than
+ * written as a fallback at each of them, since a fallback that cannot happen
+ * reads as a case somebody considered.
+ */
+/* c8 ignore next 3 -- the fallback is unreachable; see above */
+export function readAt(values, at) {
+    return values[at] ?? 0;
+}
+/**
+ * How much of the build is done, from 0 to 1.
+ *
+ * The counting and filling passes are measured in dictionary positions and the
+ * ranking pass in reading groups, so the two counts are both taken and each
+ * pass reports against the one it is walking.
+ */
+export function progressOf(pass, at, positions, groups) {
+    const size = Math.max(1, positions);
+    switch (pass) {
+        case "counting": {
+            return (SHARE.counting * at) / size;
+        }
+        case "ordering": {
+            return SHARE.counting;
+        }
+        case "filling": {
+            return SHARE.counting + (SHARE.filling * at) / size;
+        }
+        case "ranking": {
+            return (SHARE.counting +
+                SHARE.filling +
+                (SHARE.ranking * at) / Math.max(1, groups));
+        }
+        case "done": {
+            return 1;
+        }
+    }
+}
+//# sourceMappingURL=reverse-index-passes.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-index-passes.js","sourceRoot":"","sources":["../../src/search/reverse-index-passes.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AA4CH;;;GAGG;AACH,MAAM,CAAC,MAAM,KAAK,GAAG,EAAE,QAAQ,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC;AAErE;;GAEG;AACH,MAAM,CAAC,MAAM,IAAI,GAAG,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAEvC;;;;;;;;GAQG;AACH,gEAAgE;AAChE,MAAM,UAAU,MAAM,CAAC,MAAmB,EAAE,EAAU;IACpD,OAAO,MAAM,CAAC,EAAE,CAAC,IAAI,CAAC,CAAC;AACzB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,UAAU,CACxB,IAAU,EACV,EAAU,EACV,SAAiB,EACjB,MAAc;IAEd,MAAM,IAAI,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,SAAS,CAAC,CAAC;IACpC,QAAQ,IAAI,EAAE,CAAC;QACb,KAAK,UAAU,EAAE,CAAC;YAChB,OAAO,CAAC,KAAK,CAAC,QAAQ,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;QACtC,CAAC;QACD,KAAK,UAAU,EAAE,CAAC;YAChB,OAAO,KAAK,CAAC,QAAQ,CAAC;QACxB,CAAC;QACD,KAAK,SAAS,EAAE,CAAC;YACf,OAAO,KAAK,CAAC,QAAQ,GAAG,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC;QACtD,CAAC;QACD,KAAK,SAAS,EAAE,CAAC;YACf,OAAO,CACL,KAAK,CAAC,QAAQ;gBACd,KAAK,CAAC,OAAO;gBACb,CAAC,KAAK,CAAC,OAAO,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,CAC3C,CAAC;QACJ,CAAC;QACD,KAAK,MAAM,EAAE,CAAC;YACZ,OAAO,CAAC,CAAC;QACX,CAAC;IACH,CAAC;AACH,CAAC"}

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

@@ -0,0 +1,36 @@
+import { type GroupLayout } from "./reverse-index-groups.js";
+import { type Pass } from "./reverse-index-passes.js";
+/**
+ * Everything the passes share.
+ */
+export interface BuildState {
+    pass: Pass;
+    /** A dictionary position while counting and filling, a group while ranking. */
+    at: number;
+    /** How many words each reading has; dropped once the groups are laid out. */
+    counts: Map<string, number>;
+    /** Where the postings go, which the ordering pass settles. */
+    layout: GroupLayout;
+}
+/**
+ * A build that has done nothing yet.
+ */
+export declare function startState(): BuildState;
+/**
+ * Count how many words each reading has, so the postings can be one array.
+ */
+export declare function countPass(state: BuildState, size: number, keyAt: (position: number) => string, positions: number): void;
+/**
+ * Lay the groups out, which is one step of its own because a sort cannot be
+ * resumed part way through.
+ */
+export declare function orderPass(state: BuildState): void;
+/**
+ * Place each position in its reading's group, recomputing the reading.
+ */
+export declare function fillPass(state: BuildState, size: number, keyAt: (position: number) => string, positions: number): void;
+/**
+ * Sort some groups likeliest-first, and say whether that was the last of them.
+ */
+export declare function rankPass(state: BuildState, groups: number, rankOf: (position: number) => number): boolean;
+//# sourceMappingURL=reverse-index-state.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"reverse-index-state.d.ts","sourceRoot":"","sources":["../../src/search/reverse-index-state.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,WAAW,EAGjB,MAAM,2BAA2B,CAAC;AACnC,OAAO,EAAQ,KAAK,IAAI,EAAU,MAAM,2BAA2B,CAAC;AAEpE;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,IAAI,CAAC;IACX,+EAA+E;IAC/E,EAAE,EAAE,MAAM,CAAC;IACX,6EAA6E;IAC7E,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC5B,8DAA8D;IAC9D,MAAM,EAAE,WAAW,CAAC;CACrB;AAYD;;GAEG;AACH,wBAAgB,UAAU,IAAI,UAAU,CAEvC;AAED;;GAEG;AACH,wBAAgB,SAAS,CACvB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,EACnC,SAAS,EAAE,MAAM,GAChB,IAAI,CAWN;AAED;;;GAGG;AACH,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,IAAI,CAKjD;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,EACjB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,EACnC,SAAS,EAAE,MAAM,GAChB,IAAI,CAoBN;AAED;;GAEG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,UAAU,EACjB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,MAAM,GACnC,OAAO,CAoBT"}

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

@@ -0,0 +1,95 @@
+/**
+ * The build as a state machine: what it holds, and what each pass does to it.
+ *
+ * Held as one record rather than as a closure's variables so that the four
+ * transitions can be written as functions and read in order. Two of the fields
+ * are dropped part way through — what is live during counting is not what is
+ * live during ranking — which is the reason the build streams at all: keeping
+ * all 723,147 readings costs 39 MB retained and peaks at 65 MB, where
+ * recomputing them in the fill pass peaks at 25 MB for a 2 MB result.
+ */
+import { FREQUENCY_BUCKETS } from "../dictionary/frequency-table.js";
+import { layOutGroups, rankGroup, } from "./reverse-index-groups.js";
+import { NONE, readAt } from "./reverse-index-passes.js";
+/** A layout with nothing in it, before the ordering pass has run. */
+const NO_LAYOUT = {
+    keys: [],
+    starts: new Uint32Array(1),
+    slots: new Map(),
+    widest: 0,
+    cursors: new Uint32Array(0),
+    postings: NONE,
+};
+/**
+ * A build that has done nothing yet.
+ */
+export function startState() {
+    return { pass: "counting", at: 0, counts: new Map(), layout: NO_LAYOUT };
+}
+/**
+ * Count how many words each reading has, so the postings can be one array.
+ */
+export function countPass(state, size, keyAt, positions) {
+    const end = Math.min(size, state.at + positions);
+    for (; state.at < end; state.at++) {
+        const key = keyAt(state.at);
+        if (key !== "") {
+            state.counts.set(key, (state.counts.get(key) ?? 0) + 1);
+        }
+    }
+    if (state.at >= size) {
+        state.pass = "ordering";
+    }
+}
+/**
+ * Lay the groups out, which is one step of its own because a sort cannot be
+ * resumed part way through.
+ */
+export function orderPass(state) {
+    state.layout = layOutGroups(state.counts);
+    state.counts = new Map();
+    state.at = 0;
+    state.pass = "filling";
+}
+/**
+ * Place each position in its reading's group, recomputing the reading.
+ */
+export function fillPass(state, size, keyAt, positions) {
+    const end = Math.min(size, state.at + positions);
+    for (; state.at < end; state.at++) {
+        const key = keyAt(state.at);
+        const group = key === "" ? undefined : state.layout.slots.get(key);
+        if (group === undefined) {
+            continue;
+        }
+        const cursor = readAt(state.layout.cursors, group);
+        state.layout.postings[cursor] = state.at;
+        state.layout.cursors[group] = cursor + 1;
+    }
+    if (state.at >= size) {
+        // The slots and the cursors are the fill pass's own, and the ranking pass
+        // is about to walk arrays as big as the dictionary. Dropped rather than
+        // carried, which on the full tier is 42 MB the build never holds.
+        state.layout = { ...state.layout, slots: new Map(), cursors: NONE };
+        state.at = 0;
+        state.pass = "ranking";
+    }
+}
+/**
+ * Sort some groups likeliest-first, and say whether that was the last of them.
+ */
+export function rankPass(state, groups, rankOf) {
+    const { keys, starts, postings, widest } = state.layout;
+    const scratch = new Uint32Array(widest);
+    const tally = new Uint32Array(FREQUENCY_BUCKETS);
+    const end = Math.min(keys.length, state.at + groups);
+    for (; state.at < end; state.at++) {
+        rankGroup(postings, readAt(starts, state.at), readAt(starts, state.at + 1), scratch, tally, rankOf);
+    }
+    if (state.at < keys.length) {
+        return false;
+    }
+    state.pass = "done";
+    return true;
+}
+//# sourceMappingURL=reverse-index-state.js.map

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

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

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

@@ -1,73 +1,14 @@
-import type { Dictionary } from "../dictionary/dictionary.js";
-/**
- * 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;
-}
 /**
- * A reverse index being built, a slice at a time.
- *
- * The full tier costs about 510 ms to derive, which is thirty-odd frames, so the
- * build is a state machine a caller can drive from `requestIdleCallback` rather
- * than a function that takes the thread. `core` is 4 ms and `standard` is 62 ms,
- * and both can simply be built with {@link ReverseIndex.of}.
+ * The reverse index itself: reading key → the words read that way.
  *
- * ```ts
- * const build = ReverseIndex.building(dictionary);
- * const tick = (): void => {
- *   const index = build.step();
- *   if (index === undefined) {
- *     requestIdleCallback(tick);
- *   }
- * };
- * requestIdleCallback(tick);
- * ```
+ * How it is derived is `reverse-index-build.ts`, and the vocabulary the two
+ * share sits below both in `reverse-index-passes.ts`.
  */
-export interface ReverseIndexBuild {
-    /**
-     * How much of the build is done, from 0 to 1.
-     */
-    readonly progress: number;
-    /**
-     * Do some more of the work, returning the index once there is none left.
-     *
-     * `positions` bounds a step to that many dictionary positions, or that many
-     * reading groups while the last pass is ranking them. It is a bound rather
-     * than a promise: the pass that sorts the reading keys cannot be divided, and
-     * is one step of its own.
-     */
-    readonly step: (positions?: number) => ReverseIndex | undefined;
-}
+import type { Dictionary } from "../dictionary/dictionary.js";
+import type { ReverseIndexData } from "./reverse-index-format.js";
+import { type ReverseIndexBuild } from "./reverse-index-passes.js";
+export type { ReverseIndexBuild } from "./reverse-index-passes.js";
+export { readingKey, type ReverseIndexData } from "./reverse-index-format.js";
 /**
  * Which readings each word in the dictionary can be reached by.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"reverse-index.d.ts","sourceRoot":"","sources":["../../src/search/reverse-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AA6B9D;;;;;;;;;;;;;;;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;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,WAAW,iBAAiB;IAChC;;OAEG;IACH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;;OAOG;IACH,QAAQ,CAAC,IAAI,EAAE,CAAC,SAAS,CAAC,EAAE,MAAM,KAAK,YAAY,GAAG,SAAS,CAAC;CACjE;AA+BD;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,YAAY;;IACvB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,GAAG,YAAY,CAO9C;IAED;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,iBAAiB,CAEzD;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAOxE;IAOD;;;OAGG;IACH,OAAO,eAUN;IAED;;;OAGG;IACH,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;OAQG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CASrC;IAED;;OAEG;IACH,SAAS,IAAI,gBAAgB,CAM5B;CACF"}
+{"version":3,"file":"reverse-index.d.ts","sourceRoot":"","sources":["../../src/search/reverse-index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,6BAA6B,CAAC;AAG9D,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAGL,KAAK,iBAAiB,EACvB,MAAM,2BAA2B,CAAC;AAEnC,YAAY,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AAEnE,OAAO,EAAE,UAAU,EAAE,KAAK,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAE9E;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,YAAY;;IACvB;;;;;;OAMG;IACH,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,UAAU,GAAG,YAAY,CAE9C;IAED;;OAEG;IACH,MAAM,CAAC,QAAQ,CAAC,UAAU,EAAE,UAAU,GAAG,iBAAiB,CAEzD;IAED;;;;;;;OAOG;IACH,MAAM,CAAC,IAAI,CAAC,UAAU,EAAE,UAAU,EAAE,IAAI,EAAE,gBAAgB,GAAG,YAAY,CAOxE;IAOD;;;OAGG;IACH,OAAO,eAUN;IAED;;;OAGG;IACH,IAAI,UAAU,IAAI,UAAU,CAE3B;IAED;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;;;;;;OAQG;IACH,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,WAAW,CASrC;IAED;;OAEG;IACH,SAAS,IAAI,gBAAgB,CAM5B;CACF"}