pixelize-design-library 3.0.1-beta.1 → 3.1.1

package/dist/Components/NavLauncher/engine/engine.d.ts

@@ -0,0 +1,103 @@
+import { editDistance } from "./distance";
+import { foldText, splitWords, tokenize } from "./fold";
+/** One searchable string; `weight` scales its matches (label 1, keyword 0.75, context 0.4). */
+export type LauncherSearchField = {
+    /** Field identifier, reported back in `LauncherTokenMatch.field`. */
+    name: string;
+    /** String to match, compared without case or accents. */
+    text: string;
+    /** Scales this field's matches; defaults to 1. */
+    weight?: number;
+};
+/** Anything searchable: an id plus its weighted fields, in the order results should tie-break. */
+export type LauncherSearchDocument = {
+    /** Identifier returned on the matching hit. */
+    id: string;
+    /** Fields searched; each query token scores against its best field. */
+    fields: readonly LauncherSearchField[];
+};
+/** How a query token matched a field, strongest first. */
+export type LauncherMatchKind = "exact" | "prefix" | "word" | "word-prefix" | "initialism" | "substring" | "fuzzy" | "subsequence";
+/** The field that gave a query token its best score. */
+export type LauncherTokenMatch = {
+    /** The query token this entry explains. */
+    token: string;
+    /** `name` of the field that scored best for the token. */
+    field: string;
+    /** Text of that field. */
+    text: string;
+    /** How the token matched that field. */
+    kind: LauncherMatchKind;
+};
+/** A ranked document: `index` is its input position, `synonym` the expansion used. */
+export type LauncherSearchHit = {
+    /** `id` of the matching document. */
+    id: string;
+    /** Position of the document in the list that was indexed. */
+    index: number;
+    /** Relevance, including any `boosts`; higher ranks first. */
+    score: number;
+    /** Best match for each query token. */
+    matches: LauncherTokenMatch[];
+    /** The synonym expansion that produced the hit; absent when the literal query matched. */
+    synonym?: string;
+};
+/** Term -> equivalent phrases, matched both ways: `{ pf: ["provident fund"] }`. */
+export type LauncherSynonyms = Readonly<Record<string, readonly string[]>>;
+/** Ranking knobs; `boosts` adds points per document id to documents that already match. */
+export type LauncherSearchOptions = {
+    /** Equivalent terms expanded in both directions. */
+    synonyms?: LauncherSynonyms;
+    /** Points added per document id to documents that already match; never adds a non-match. */
+    boosts?: Readonly<Record<string, number>>;
+    /** Typo tolerance; defaults to true. */
+    fuzzy?: boolean;
+    /** Drops hits under this share of the best score; 0 keeps all. */
+    relativeCutoff?: number;
+    /** Maximum hits returned; unlimited when omitted. */
+    limit?: number;
+};
+type IndexedField = {
+    name: string;
+    text: string;
+    weight: number;
+    folded: string;
+    compact: string;
+    words: string[];
+    starts: number[];
+    initials: string;
+    mask: number;
+    letterWords: readonly (readonly string[])[] | null;
+};
+type IndexedDocument = {
+    id: string;
+    index: number;
+    fields: IndexedField[];
+    mask: number;
+};
+/** Pre-folded documents; build once with `createIndex`, query many times. */
+export type LauncherSearchIndex = {
+    /** Number of indexed documents. */
+    readonly size: number;
+    /** Pre-folded records; internal shape, pass the index to the engine rather than reading it. */
+    readonly documents: readonly IndexedDocument[];
+};
+export declare const createSearchIndex: (documents: readonly LauncherSearchDocument[]) => LauncherSearchIndex;
+type CompileOptions = Pick<LauncherSearchOptions, "synonyms" | "fuzzy">;
+export declare const searchIndex: (index: LauncherSearchIndex, query: string, options?: LauncherSearchOptions) => LauncherSearchHit[];
+export declare const searchDocuments: (documents: readonly LauncherSearchDocument[], query: string, options?: LauncherSearchOptions) => LauncherSearchHit[];
+/** Boolean test over one row's texts; an empty query matches every row. */
+export type LauncherMatcher = (...texts: ReadonlyArray<string | null | undefined>) => boolean;
+/** Compiles `query` once; every query word must hit some text of the row. */
+export declare const createMatcher: (query: string, options?: CompileOptions) => LauncherMatcher;
+/** One-off form of `createMatcher`: does `query` match the row made of `texts`? */
+export declare const matchesQuery: (query: string, ...texts: ReadonlyArray<string | null | undefined>) => boolean;
+/** Character ranges of `text` a query matched, in original-text offsets, merged and sorted. */
+export declare const highlightRanges: (text: string, query: string, options?: Pick<LauncherSearchOptions, "synonyms" | "fuzzy">) => Array<[number, number]>;
+/** Additive ranking points from usage: pinned flat, frequent and recent decaying by position. */
+export declare const usageBoosts: (usage: {
+    pinnedIds?: readonly string[];
+    frequentIds?: readonly string[];
+    recentIds?: readonly string[];
+}) => Record<string, number>;
+export { editDistance, foldText, splitWords, tokenize };

package/dist/Components/NavLauncher/engine/engine.js

@@ -0,0 +1,472 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tokenize = exports.splitWords = exports.foldText = exports.editDistance = exports.usageBoosts = exports.highlightRanges = exports.matchesQuery = exports.createMatcher = exports.searchDocuments = exports.searchIndex = exports.createSearchIndex = void 0;
+const distance_1 = require("./distance");
+Object.defineProperty(exports, "editDistance", { enumerable: true, get: function () { return distance_1.editDistance; } });
+const fold_1 = require("./fold");
+Object.defineProperty(exports, "foldText", { enumerable: true, get: function () { return fold_1.foldText; } });
+Object.defineProperty(exports, "splitWords", { enumerable: true, get: function () { return fold_1.splitWords; } });
+Object.defineProperty(exports, "tokenize", { enumerable: true, get: function () { return fold_1.tokenize; } });
+const KIND_SCORE = {
+    exact: 100,
+    prefix: 88,
+    word: 78,
+    "word-prefix": 68,
+    initialism: 60,
+    substring: 46,
+    fuzzy: 34,
+    subsequence: 16,
+};
+const COMPLETENESS = 6;
+const SYNONYM_FACTOR = 0.92;
+const STEM_PENALTY = 1;
+const MAX_ALTERNATIVES = 12;
+const UNBOUNDED_SLACK = 32;
+// NOTE: code points, not a literal; see ANUSVARA in fold.ts.
+const TAMIL_FINAL_MA = String.fromCodePoint(0x0bae, 0x0bcd);
+const WORD_RE = /[\p{L}\p{N}\p{M}]+/gu;
+const charBit = (code) => {
+    if (code >= 97 && code <= 122)
+        return 1 << (code - 97);
+    return code >= 48 && code <= 57 ? 1 << 26 : 1 << (27 + (code % 4));
+};
+const maskOf = (text) => {
+    let mask = 0;
+    for (let i = 0; i < text.length; i += 1)
+        mask |= charBit(text.charCodeAt(i));
+    return mask;
+};
+const missingChars = (token, field) => {
+    let rest = token & ~field;
+    let count = 0;
+    for (; rest; count += 1)
+        rest &= rest - 1;
+    return count;
+};
+const maxEdits = (size) => (size >= 8 ? 2 : 1);
+const writtenSize = (text, marked) => marked ? (0, fold_1.letters)(text).length : text.length;
+const indexField = ({ name, text, weight = 1, }) => {
+    var _a;
+    const folded = (0, fold_1.foldText)(text).trim();
+    const words = [];
+    const starts = [];
+    for (const match of folded.matchAll(WORD_RE)) {
+        words.push(match[0]);
+        starts.push((_a = match.index) !== null && _a !== void 0 ? _a : 0);
+    }
+    const letterWords = (0, fold_1.hasMarks)(folded) ? words.map(fold_1.letters) : null;
+    return {
+        name,
+        text,
+        weight,
+        folded,
+        compact: words.join(""),
+        words,
+        starts,
+        initials: (letterWords !== null && letterWords !== void 0 ? letterWords : words).map((w) => w[0]).join(""),
+        mask: maskOf(folded),
+        letterWords,
+    };
+};
+const createSearchIndex = (documents) => {
+    const indexed = documents.map((doc, index) => {
+        const fields = doc.fields.filter((f) => f.text).map(indexField);
+        return {
+            id: doc.id,
+            index,
+            fields,
+            mask: fields.reduce((mask, f) => mask | f.mask, 0),
+        };
+    });
+    return { size: indexed.length, documents: indexed };
+};
+exports.createSearchIndex = createSearchIndex;
+const startsLikely = (token, word) => word[0][0] === token[0][0] || (word[0] === token[1] && word[1] === token[0]);
+const fuzzyScore = (token, words) => {
+    const max = maxEdits(token.length);
+    let best = 0;
+    for (let w = 0; w < words.length; w += 1) {
+        const word = words[w];
+        if (!startsLikely(token, word))
+            continue;
+        if (Math.abs(word.length - token.length) <= max) {
+            const d = (0, distance_1.editDistance)(token, word, max);
+            if (d <= max)
+                best = Math.max(best, KIND_SCORE.fuzzy - 8 * (d - 1));
+        }
+        if (token.length < 5 || best >= KIND_SCORE.fuzzy)
+            continue;
+        for (let len = token.length - 1; len <= token.length + 1; len += 1) {
+            if (len >= word.length)
+                break;
+            const d = (0, distance_1.editDistance)(token, word.slice(0, len), max);
+            if (d <= max)
+                best = Math.max(best, KIND_SCORE.fuzzy - 4 - 8 * (d - 1));
+        }
+    }
+    return best;
+};
+const subsequenceOf = (need, have) => {
+    if (have.length <= need.length || have[0] !== need[0])
+        return null;
+    const positions = [0];
+    for (let i = 1, at = 1; i < need.length; i += 1) {
+        const next = have.indexOf(need[i], at);
+        if (next < 0)
+            return null;
+        positions.push(next);
+        at = next + 1;
+    }
+    return positions;
+};
+const offsetIn = (have, index) => typeof have === "string" ? index : have.slice(0, index).join("").length;
+const subsequenceAt = (token, words, starts, marked) => {
+    const need = marked ? (0, fold_1.letters)(token) : token;
+    for (let k = 0; k < words.length; k += 1) {
+        const have = marked ? (0, fold_1.letters)(words[k]) : words[k];
+        const positions = subsequenceOf(need, have);
+        if (positions)
+            return positions.map((p) => starts[k] + offsetIn(have, p));
+    }
+    return null;
+};
+const fuzzyOnly = (token, field, floor) => {
+    var _a, _b;
+    if (KIND_SCORE.fuzzy < floor)
+        return null;
+    const score = fuzzyScore((_a = token.letters) !== null && _a !== void 0 ? _a : token.text, (_b = field.letterWords) !== null && _b !== void 0 ? _b : field.words);
+    return score > 0 ? { kind: "fuzzy", base: score } : null;
+};
+const matchToken = (tokenInfo, field, floor) => {
+    var _a, _b;
+    const { text: token, mask, edits, slack } = tokenInfo;
+    const missing = missingChars(mask, field.mask);
+    if (missing > 0)
+        return missing <= slack ? fuzzyOnly(tokenInfo, field, floor) : null;
+    const ratio = (COMPLETENESS * token.length) / Math.max(field.folded.length, token.length);
+    if (field.folded === token)
+        return { kind: "exact", base: KIND_SCORE.exact + COMPLETENESS };
+    if (field.folded.startsWith(token))
+        return { kind: "prefix", base: KIND_SCORE.prefix + ratio };
+    if (KIND_SCORE.word + COMPLETENESS < floor)
+        return null;
+    let isWordPrefix = false;
+    const { words } = field;
+    for (let w = 0; w < words.length; w += 1) {
+        if (words[w] === token)
+            return { kind: "word", base: KIND_SCORE.word + ratio };
+        if (words[w].startsWith(token))
+            isWordPrefix = true;
+    }
+    if (isWordPrefix)
+        return { kind: "word-prefix", base: KIND_SCORE["word-prefix"] + ratio };
+    if (token.length < 2 || KIND_SCORE.initialism < floor)
+        return null;
+    if (field.words.length >= 2 && field.initials.startsWith(token)) {
+        return { kind: "initialism", base: KIND_SCORE.initialism };
+    }
+    if (field.folded.includes(token) || field.compact.includes(token)) {
+        return { kind: "substring", base: KIND_SCORE.substring };
+    }
+    if (tokenInfo.exact)
+        return null;
+    if (edits > 0) {
+        const match = fuzzyOnly(tokenInfo, field, floor);
+        if (match)
+            return match;
+    }
+    if (KIND_SCORE.subsequence < floor)
+        return null;
+    const need = (_a = tokenInfo.letters) !== null && _a !== void 0 ? _a : token;
+    const lists = (_b = field.letterWords) !== null && _b !== void 0 ? _b : field.words;
+    return lists.some((have) => subsequenceOf(need, have))
+        ? { kind: "subsequence", base: KIND_SCORE.subsequence }
+        : null;
+};
+const reachable = (token, doc) => missingChars(token.mask, doc.mask) <= token.slack ||
+    (token.stem !== null && missingChars(token.stem.mask, doc.mask) === 0);
+const scoreTokens = (doc, alt) => {
+    const { tokens } = alt;
+    const { fields } = doc;
+    for (let t = 0; t < tokens.length; t += 1) {
+        if (!reachable(tokens[t], doc))
+            return null;
+    }
+    let total = 0;
+    const matches = [];
+    for (let t = 0; t < tokens.length; t += 1) {
+        const token = tokens[t];
+        let best = 0;
+        let found = null;
+        for (let f = 0; f < fields.length; f += 1) {
+            const field = fields[f];
+            for (let form = token, penalty = 0; form; form = form.stem, penalty = STEM_PENALTY) {
+                const match = matchToken(form, field, best / field.weight + penalty);
+                if (!match)
+                    continue;
+                const score = (match.base - penalty) * field.weight;
+                if (score > best) {
+                    best = score;
+                    found = {
+                        token: token.text,
+                        field: field.name,
+                        text: field.text,
+                        kind: match.kind,
+                    };
+                }
+            }
+        }
+        if (!found)
+            return null;
+        total += best;
+        matches.push(found);
+    }
+    let score = total / tokens.length;
+    if (tokens.length > 1) {
+        const { phrase } = alt;
+        for (let f = 0; f < fields.length; f += 1) {
+            const field = fields[f];
+            if (field.weight < 1)
+                continue;
+            if (field.folded === phrase)
+                score += 20;
+            else if (field.folded.startsWith(phrase))
+                score += 10;
+            else if (field.folded.includes(phrase))
+                score += 5;
+        }
+    }
+    return { score, matches };
+};
+const compiled = new WeakMap();
+const synonymGroups = (synonyms) => {
+    const cached = compiled.get(synonyms);
+    if (cached)
+        return cached;
+    const groups = Object.entries(synonyms).map(([term, phrases]) => [term, ...phrases].map(fold_1.tokenize).filter((tokens) => tokens.length > 0));
+    compiled.set(synonyms, groups);
+    return groups;
+};
+const findRun = (tokens, run) => {
+    for (let at = 0; at + run.length <= tokens.length; at += 1) {
+        if (run.every((t, i) => tokens[at + i] === t))
+            return at;
+    }
+    return -1;
+};
+const alternatives = (tokens, synonyms) => {
+    const out = [{ tokens }];
+    if (!synonyms || tokens.length === 0)
+        return out;
+    const seen = new Set([tokens.join(" ")]);
+    for (const group of synonymGroups(synonyms)) {
+        for (const member of group) {
+            const at = findRun(tokens, member);
+            if (at < 0)
+                continue;
+            for (const other of group) {
+                if (other === member)
+                    continue;
+                const next = [
+                    ...tokens.slice(0, at),
+                    ...other,
+                    ...tokens.slice(at + member.length),
+                ];
+                const key = next.join(" ");
+                if (seen.has(key))
+                    continue;
+                seen.add(key);
+                out.push({ tokens: Array.from(new Set(next)), via: other.join(" ") });
+                if (out.length >= MAX_ALTERNATIVES)
+                    return out;
+            }
+        }
+    }
+    return out;
+};
+const stemOf = (text) => text.endsWith(TAMIL_FINAL_MA) && (0, fold_1.letters)(text).length > 2
+    ? text.slice(0, -TAMIL_FINAL_MA.length)
+    : null;
+const toToken = (text, fuzzy) => {
+    const written = (0, fold_1.hasMarks)(text) ? (0, fold_1.letters)(text) : null;
+    const size = written ? written.length : text.length;
+    const edits = fuzzy && size >= 4 ? maxEdits(size) : 0;
+    const stem = stemOf(text);
+    return {
+        text,
+        mask: maskOf(text),
+        edits,
+        slack: written && edits > 0 ? UNBOUNDED_SLACK : edits,
+        letters: written,
+        exact: false,
+        stem: stem === null
+            ? null
+            : {
+                text: stem,
+                mask: maskOf(stem),
+                edits: 0,
+                slack: 0,
+                letters: null,
+                exact: true,
+                stem: null,
+            },
+    };
+};
+const compileQuery = (tokens, options) => alternatives(tokens, options.synonyms).map(({ tokens: words, via }) => ({
+    tokens: words.map((text) => toToken(text, options.fuzzy !== false)),
+    phrase: words.join(" "),
+    via,
+}));
+const searchIndex = (index, query, options = {}) => {
+    var _a, _b, _c;
+    const tokens = (0, fold_1.tokenize)(query);
+    if (tokens.length === 0)
+        return [];
+    const alts = compileQuery(tokens, options);
+    const hits = [];
+    const { documents } = index;
+    for (let d = 0; d < documents.length; d += 1) {
+        const doc = documents[d];
+        let best = null;
+        for (let a = 0; a < alts.length; a += 1) {
+            const alt = alts[a];
+            const result = scoreTokens(doc, alt);
+            if (!result)
+                continue;
+            const score = alt.via ? result.score * SYNONYM_FACTOR : result.score;
+            if (!best || score > best.score) {
+                best = {
+                    id: doc.id,
+                    index: doc.index,
+                    score,
+                    matches: result.matches,
+                    synonym: alt.via,
+                };
+            }
+        }
+        if (!best)
+            continue;
+        best.score += (_b = (_a = options.boosts) === null || _a === void 0 ? void 0 : _a[doc.id]) !== null && _b !== void 0 ? _b : 0;
+        hits.push(best);
+    }
+    hits.sort((a, b) => b.score - a.score || a.index - b.index);
+    const floor = hits.length ? hits[0].score * ((_c = options.relativeCutoff) !== null && _c !== void 0 ? _c : 0) : 0;
+    const kept = floor > 0 ? hits.filter((hit) => hit.score >= floor) : hits;
+    return options.limit === undefined ? kept : kept.slice(0, options.limit);
+};
+exports.searchIndex = searchIndex;
+const searchDocuments = (documents, query, options) => (0, exports.searchIndex)((0, exports.createSearchIndex)(documents), query, options);
+exports.searchDocuments = searchDocuments;
+/** Compiles `query` once; every query word must hit some text of the row. */
+const createMatcher = (query, options = {}) => {
+    const tokens = (0, fold_1.tokenize)(query);
+    if (tokens.length === 0)
+        return () => true;
+    const alts = compileQuery(tokens, options);
+    return (...texts) => {
+        const fields = texts
+            .filter((text) => Boolean(text))
+            .map((text) => indexField({ name: "text", text }));
+        const doc = {
+            id: "",
+            index: 0,
+            fields,
+            mask: fields.reduce((mask, f) => mask | f.mask, 0),
+        };
+        return alts.some((alt) => scoreTokens(doc, alt) !== null);
+    };
+};
+exports.createMatcher = createMatcher;
+/** One-off form of `createMatcher`: does `query` match the row made of `texts`? */
+const matchesQuery = (query, ...texts) => (0, exports.createMatcher)(query)(...texts);
+exports.matchesQuery = matchesQuery;
+const markEnd = (text, end) => {
+    let at = end;
+    while (at < text.length && /\p{M}/u.test(text[at]))
+        at += 1;
+    return at;
+};
+const tokenRanges = (token, folded, words, starts, fuzzy) => {
+    var _a;
+    const ranges = [];
+    if (token.length >= 2) {
+        for (let at = folded.indexOf(token); at !== -1; at = folded.indexOf(token, at + token.length)) {
+            ranges.push([at, at + token.length]);
+        }
+    }
+    else {
+        words.forEach((word, i) => {
+            if (word.startsWith(token))
+                ranges.push([starts[i], starts[i] + 1]);
+        });
+    }
+    if (ranges.length || token.length < 2)
+        return ranges;
+    const marked = (0, fold_1.hasMarks)(token) || (0, fold_1.hasMarks)(folded);
+    const firsts = words.map((w) => (marked ? (0, fold_1.letters)(w)[0] : w[0]));
+    if (words.length >= 2 && firsts.join("").startsWith(token)) {
+        return Array.from(marked ? (0, fold_1.letters)(token) : token, (_, i) => [starts[i], starts[i] + firsts[i].length]);
+    }
+    if (fuzzy && writtenSize(token, marked) >= 4) {
+        words.forEach((word, i) => {
+            if (fuzzyScore(marked ? (0, fold_1.letters)(token) : token, [
+                marked ? (0, fold_1.letters)(word) : word,
+            ]) > 0)
+                ranges.push([starts[i], starts[i] + word.length]);
+        });
+        if (ranges.length)
+            return ranges;
+    }
+    return ((_a = subsequenceAt(token, words, starts, marked)) !== null && _a !== void 0 ? _a : []).map((p) => [p, p + 1]);
+};
+/** Character ranges of `text` a query matched, in original-text offsets, merged and sorted. */
+const highlightRanges = (text, query, options = {}) => {
+    var _a;
+    const tokens = Array.from(new Set(alternatives((0, fold_1.tokenize)(query), options.synonyms)
+        .flatMap((a) => a.tokens)
+        .flatMap((token) => {
+        const stem = stemOf(token);
+        return stem ? [token, stem] : [token];
+    })));
+    if (tokens.length === 0 || !text)
+        return [];
+    const { folded, map } = (0, fold_1.foldWithMap)(text);
+    const words = [];
+    const starts = [];
+    for (const match of folded.matchAll(WORD_RE)) {
+        words.push(match[0]);
+        starts.push((_a = match.index) !== null && _a !== void 0 ? _a : 0);
+    }
+    const ranges = tokens
+        .flatMap((token) => tokenRanges(token, folded, words, starts, options.fuzzy !== false))
+        .sort((a, b) => a[0] - b[0]);
+    const merged = [];
+    for (const [start, end] of ranges) {
+        const last = merged[merged.length - 1];
+        if (last && start <= last[1])
+            last[1] = Math.max(last[1], end);
+        else
+            merged.push([start, end]);
+    }
+    return merged.map(([start, end]) => {
+        var _a;
+        const lastChar = map[end - 1];
+        const width = ((_a = text.codePointAt(lastChar)) !== null && _a !== void 0 ? _a : 0) > 0xffff ? 2 : 1;
+        return [map[start], markEnd(text, lastChar + width)];
+    });
+};
+exports.highlightRanges = highlightRanges;
+/** Additive ranking points from usage: pinned flat, frequent and recent decaying by position. */
+const usageBoosts = (usage) => {
+    const out = {};
+    const add = (ids, weight, decays) => ids === null || ids === void 0 ? void 0 : ids.forEach((id, i) => {
+        var _a;
+        const factor = decays ? Math.max(0.25, 1 - i / ids.length) : 1;
+        out[id] = ((_a = out[id]) !== null && _a !== void 0 ? _a : 0) + weight * factor;
+    });
+    add(usage.pinnedIds, 3, false);
+    add(usage.frequentIds, 4, true);
+    add(usage.recentIds, 2, true);
+    return out;
+};
+exports.usageBoosts = usageBoosts;

package/dist/Components/NavLauncher/engine/fold.d.ts

@@ -0,0 +1,15 @@
+/** Case- and accent-insensitive form used for every comparison: "Crème Brûlée" -> "creme brulee". */
+export declare const foldText: (text: string) => string;
+export declare const splitWords: (folded: string) => string[];
+/** Folded, de-duplicated query tokens in typing order. */
+export declare const tokenize: (query: string) => string[];
+/** True when folded text carries combining marks, so its written letters span several characters. */
+export declare const hasMarks: (folded: string) => boolean;
+/** Written letters: a base with its marks; a Devanagari conjunct counts as one. */
+export declare const letters: (word: string) => string[];
+/** Folded text plus each folded index's position in the original text. */
+export type FoldedText = {
+    folded: string;
+    map: number[];
+};
+export declare const foldWithMap: (text: string) => FoldedText;

package/dist/Components/NavLauncher/engine/fold.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.foldWithMap = exports.letters = exports.hasMarks = exports.tokenize = exports.splitWords = exports.foldText = void 0;
+// Accents, nukta and joiners fold away; vowel signs and viramas belong to the letter.
+const OPTIONAL_MARKS = 
+// eslint-disable-next-line no-misleading-character-class -- each mark is removed on its own
+/[\u0300-\u036f\u0591-\u05c7\u0610-\u061a\u064b-\u065f\u0670\u06d6-\u06ed\u093c\u1ab0-\u1aff\u1dc0-\u1dff\u200c\u200d\u20d0-\u20ff\ufe20-\ufe2f]/g;
+const CHANDRABINDU = /\u0901/g;
+// NOTE: built from code points; minified Indic literals trip consumers' locale-data budget gates.
+const ANUSVARA = String.fromCodePoint(0x0902);
+const MARK = /\p{M}/u;
+const SEPARATOR = /[^\p{L}\p{N}\p{M}]+/u;
+const SPECIAL = {
+    ß: "ss",
+    æ: "ae",
+    œ: "oe",
+    ø: "o",
+    ł: "l",
+    đ: "d",
+    ı: "i",
+};
+const SPECIAL_RE = /[ßæœøłđı]/g;
+const DEVANAGARI_VIRAMA = 0x094d;
+/** Case- and accent-insensitive form used for every comparison: "Crème Brûlée" -> "creme brulee". */
+const foldText = (text) => text
+    .normalize("NFKD")
+    .replace(OPTIONAL_MARKS, "")
+    .replace(CHANDRABINDU, ANUSVARA)
+    .toLowerCase()
+    .replace(SPECIAL_RE, (ch) => SPECIAL[ch]);
+exports.foldText = foldText;
+const splitWords = (folded) => folded.split(SEPARATOR).filter(Boolean);
+exports.splitWords = splitWords;
+/** Folded, de-duplicated query tokens in typing order. */
+const tokenize = (query) => Array.from(new Set((0, exports.splitWords)((0, exports.foldText)(query))));
+exports.tokenize = tokenize;
+/** True when folded text carries combining marks, so its written letters span several characters. */
+const hasMarks = (folded) => MARK.test(folded);
+exports.hasMarks = hasMarks;
+const isDevanagariConsonant = (code) => (code >= 0x0915 && code <= 0x0939) || (code >= 0x0978 && code <= 0x097f);
+const markCodes = new Map();
+const isMarkCode = (code, char) => {
+    if (code < 0x0300)
+        return false;
+    let known = markCodes.get(code);
+    if (known === undefined) {
+        known = MARK.test(char);
+        markCodes.set(code, known);
+    }
+    return known;
+};
+/** Written letters: a base with its marks; a Devanagari conjunct counts as one. */
+const letters = (word) => {
+    var _a;
+    const out = [];
+    let previous = 0;
+    for (const char of word) {
+        const code = (_a = char.codePointAt(0)) !== null && _a !== void 0 ? _a : 0;
+        const joins = isMarkCode(code, char) ||
+            (previous === DEVANAGARI_VIRAMA && isDevanagariConsonant(code));
+        if (joins && out.length > 0)
+            out[out.length - 1] += char;
+        else
+            out.push(char);
+        previous = code;
+    }
+    return out;
+};
+exports.letters = letters;
+const foldWithMap = (text) => {
+    let folded = "";
+    const map = [];
+    let at = 0;
+    for (const char of text) {
+        const piece = (0, exports.foldText)(char);
+        for (let i = 0; i < piece.length; i += 1)
+            map.push(at);
+        folded += piece;
+        at += char.length;
+    }
+    map.push(text.length);
+    return { folded, map };
+};
+exports.foldWithMap = foldWithMap;