@kensio/pinyinjs 1.6.0 → 1.7.0

package/dist/search/match.js

@@ -0,0 +1,419 @@
+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;
+    }
+}
+/**
+ * Find where a pinyin query matches a Chinese text, for filtering and
+ * highlighting.
+ *
+ * ```ts
+ * match(dictionary, "北京大学", "bjdx")?.ranges; // [{ at: 0, length: 4 }]
+ * ```
+ *
+ * The query is what somebody types on a Latin keyboard with no Chinese input
+ * method in front of them: full syllables joined or spaced, `beijing` and
+ * `bei jing`; initials, `bj`; the two mixed, `beij` and `bjing`; tones as
+ * digits where they are worth writing, `bei3jing1`; and `v` or `u:` for ü.
+ * Returns undefined where none of it matches.
+ *
+ * **No index is built and none is needed.** The haystack is Chinese, so the
+ * query is tested as a path over each character's readings rather than the text
+ * being spelled out in advance and searched — which is what makes every reading
+ * of a polyphone matchable rather than whichever one a default table picked.
+ * 行 is found by `xing` and by `hang`, and 长江 by `cj` as well as by `zj`.
+ *
+ * The reading the decoder settles on in context is then what ranks them, so the
+ * one that reads correctly here sorts above the one that merely could:
+ *
+ * ```ts
+ * const scoreOf = (query: string) => match(dictionary, "银行", query)?.score;
+ * scoreOf("yh") > scoreOf("yx"); // true — 银行 is yínháng, not yínxíng
+ * ```
+ *
+ * Ranges rather than a boolean, so that a caller can mark what matched, in code
+ * points from the start of the text. Everything this needs is in the `core`
+ * dictionary, so a page that never loads a word list can still do it.
+ */
+export function match(dictionary, haystack, query) {
+    const normalised = normaliseQuery(query);
+    if (normalised === "" || haystack === "") {
+        return undefined;
+    }
+    return new Search(dictionary, haystack, normalised).best();
+}
+//# sourceMappingURL=match.js.map

package/dist/search/match.js.map

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

package/dist/search/query.d.ts

@@ -0,0 +1,49 @@
+import { type Syllable } from "../syllable/syllable.js";
+/**
+ * Put a typed query into the one form the matcher reads.
+ *
+ * Case is dropped, every separator becomes a single space, and the `v` and `u:`
+ * conventions become ü — all three are ways of writing the same query, and
+ * folding them here is what keeps the matcher itself about syllables.
+ *
+ * **A tone written as a mark is dropped rather than honoured.** Constraining a
+ * match by tone needs to know where the syllable the mark sits inside ends, and
+ * a query is exactly the text where that is not yet known: `bei` may still
+ * become `beijing`. A tone written as a digit says where the syllable ends by
+ * being there at all, so that one is honoured — see {@link readQueryChunks}.
+ */
+export declare function normaliseQuery(query: string): string;
+/**
+ * Step over any separators at a position, which fall between syllables.
+ */
+export declare function skipSeparators(query: string, at: number): number;
+/**
+ * One way a query can account for one syllable.
+ */
+export interface QueryChunk {
+    /** Where the query has been read up to, once this chunk is taken. */
+    readonly next: number;
+    /** Whether the syllable was written out in full, rather than abbreviated. */
+    readonly isFull: boolean;
+}
+/**
+ * Every way the query at a position can account for one syllable.
+ *
+ * Three forms, which between them are every way a syllable gets typed:
+ *
+ * - written out in full, `bei`, optionally with the tone as a digit, `bei3`,
+ *   which matches only where the reading carries that tone;
+ * - abbreviated to its initial, `b`, which is what a query of initials is;
+ * - cut short by the query simply ending, `bei` against `běijīng` — anything
+ *   the syllable starts with, so that a search box still matches while the
+ *   query is being typed.
+ *
+ * The third is confined to the end of the query on purpose. A part-syllable in
+ * the middle would let `bejing` through as `be` + `jing`, which is a typo
+ * rather than an abbreviation, and nothing in front of a search box means it.
+ *
+ * Returns one chunk per distinct position the query can be read up to, since
+ * the forms overlap: `b` is both an initial and the whole of what is left.
+ */
+export declare function readQueryChunks(query: string, at: number, syllable: Syllable): readonly QueryChunk[];
+//# sourceMappingURL=query.d.ts.map

package/dist/search/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/search/query.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,yBAAyB,CAAC;AAoBjC;;;;;;;;;;;;GAYG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIpD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,qEAAqE;IACrE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B;AAyBD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,EACb,EAAE,EAAE,MAAM,EACV,QAAQ,EAAE,QAAQ,GACjB,SAAS,UAAU,EAAE,CA2CvB"}

package/dist/search/query.js

@@ -0,0 +1,115 @@
+import { normaliseUmlaut, writeSyllableSpelling, } from "../syllable/syllable.js";
+import { stripToneMarks } from "../tone/tone-mark.js";
+import { toneFromNotation } from "../tone/tone.js";
+/**
+ * What a query may write between syllables.
+ *
+ * Whitespace is what anybody types; the apostrophe is the 隔音符号 and the
+ * hyphen is what a 成语 or a reduplicated word is written with, so both arrive
+ * in a query pasted from written pinyin rather than typed.
+ */
+const QUERY_SEPARATORS = /[\s'’‘-]+/gu;
+/**
+ * The one separator a normalised query is written with.
+ */
+const SEPARATOR = " ";
+const TONE_DIGIT = /^[0-5]$/u;
+/**
+ * Put a typed query into the one form the matcher reads.
+ *
+ * Case is dropped, every separator becomes a single space, and the `v` and `u:`
+ * conventions become ü — all three are ways of writing the same query, and
+ * folding them here is what keeps the matcher itself about syllables.
+ *
+ * **A tone written as a mark is dropped rather than honoured.** Constraining a
+ * match by tone needs to know where the syllable the mark sits inside ends, and
+ * a query is exactly the text where that is not yet known: `bei` may still
+ * become `beijing`. A tone written as a digit says where the syllable ends by
+ * being there at all, so that one is honoured — see {@link readQueryChunks}.
+ */
+export function normaliseQuery(query) {
+    return normaliseUmlaut(stripToneMarks(query.normalize("NFC").toLowerCase()))
+        .replaceAll(QUERY_SEPARATORS, SEPARATOR)
+        .trim();
+}
+/**
+ * Step over any separators at a position, which fall between syllables.
+ */
+export function skipSeparators(query, at) {
+    let next = at;
+    while (query[next] === SEPARATOR) {
+        next++;
+    }
+    return next;
+}
+/**
+ * How a syllable may be abbreviated in a query.
+ *
+ * The first letter is the abbreviation everybody means by "initials only" —
+ * 北京 is `bj` and 西安 is `xa`, which is why this is taken from the spelling
+ * rather than from {@link Syllable.initial}: 安 has no initial and is still
+ * typed `a`. The initial itself is offered alongside it so that a retroflex
+ * keeps its h — 中文 is `zw` to one typist and `zhw` to another.
+ */
+function abbreviationsOf(syllable, spelling) {
+    const first = spelling.slice(0, 1);
+    const { initial } = syllable;
+    return [first, initial].filter((abbreviation, at, all) => abbreviation !== "" &&
+        abbreviation.length < spelling.length &&
+        all.indexOf(abbreviation) === at);
+}
+/**
+ * Every way the query at a position can account for one syllable.
+ *
+ * Three forms, which between them are every way a syllable gets typed:
+ *
+ * - written out in full, `bei`, optionally with the tone as a digit, `bei3`,
+ *   which matches only where the reading carries that tone;
+ * - abbreviated to its initial, `b`, which is what a query of initials is;
+ * - cut short by the query simply ending, `bei` against `běijīng` — anything
+ *   the syllable starts with, so that a search box still matches while the
+ *   query is being typed.
+ *
+ * The third is confined to the end of the query on purpose. A part-syllable in
+ * the middle would let `bejing` through as `be` + `jing`, which is a typo
+ * rather than an abbreviation, and nothing in front of a search box means it.
+ *
+ * Returns one chunk per distinct position the query can be read up to, since
+ * the forms overlap: `b` is both an initial and the whole of what is left.
+ */
+export function readQueryChunks(query, at, syllable) {
+    const spelling = writeSyllableSpelling(syllable);
+    const found = new Map();
+    /**
+     * Note that the query can be read up to here, keeping the fuller reading of
+     * the two where a position is reached both ways.
+     */
+    const take = (next, isFull) => {
+        found.set(next, (found.get(next) ?? false) || isFull);
+    };
+    if (query.startsWith(spelling, at)) {
+        const after = at + spelling.length;
+        const digit = query[after] ?? "";
+        // A reading with no tone written cannot contradict one, and a few hundred
+        // characters are stored that way: 西 is `xi`, with `xī` listed beside it.
+        if (TONE_DIGIT.test(digit) &&
+            (syllable.tone === undefined ||
+                toneFromNotation(Number(digit)) === syllable.tone)) {
+            take(after + 1, true);
+        }
+        take(after, true);
+    }
+    for (const abbreviation of abbreviationsOf(syllable, spelling)) {
+        if (query.startsWith(abbreviation, at)) {
+            take(at + abbreviation.length, false);
+        }
+    }
+    const tail = query.slice(at);
+    if (tail !== "" &&
+        tail.length < spelling.length &&
+        spelling.startsWith(tail)) {
+        take(query.length, false);
+    }
+    return [...found].map(([next, isFull]) => ({ next, isFull }));
+}
+//# sourceMappingURL=query.js.map

package/dist/search/query.js.map

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