pixelize-design-library 2.4.2-beta.64 → 2.4.2-beta.66

package/dist/esm/Components/NavLauncher/ScopeBar.js

@@ -0,0 +1,136 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Flex } from "@chakra-ui/react";
+import { ChevronLeft, ChevronRight } from "lucide-react";
+import { useCallback, useEffect, useRef, useState, } from "react";
+import { focusVisibleStyles } from "../../Theme/chakra/focusRing.styles.js";
+import { reducedMotionSx, usePrefersReducedMotion, } from "../../Theme/chakra/motion.js";
+import { AA_NON_TEXT, liftToContrast, } from "../../Theme/tokens/builders/outlineRung.js";
+import { listRowBackgrounds } from "../../Theme/tokens/builders/rowStates.js";
+import { raisedRule } from "../../Theme/tokens/builders/surfaceRaised.js";
+import { transitionFor } from "../../Theme/tokens/primitives/motion.js";
+import { useCustomTheme } from "../../Theme/useCustomTheme.js";
+const EDGE = 36;
+const MAX_COUNT = 99;
+const STEPS = {
+    ArrowRight: 1,
+    ArrowDown: 1,
+    ArrowLeft: -1,
+    ArrowUp: -1,
+};
+const HIDDEN_SCROLLBAR = {
+    scrollbarWidth: "none",
+    "&::-webkit-scrollbar": { display: "none" },
+};
+const NO_EDGES = { start: false, end: false };
+const fadeMask = ({ start, end }) => start || end
+    ? `linear-gradient(to right, ${start ? "transparent" : "black"}, black ${EDGE}px, black calc(100% - ${EDGE}px), ${end ? "transparent" : "black"})`
+    : "none";
+function PageArrow({ side, onPage, }) {
+    const { colors } = useCustomTheme();
+    const Icon = side === "start" ? ChevronLeft : ChevronRight;
+    return (_jsx(Box, { as: "button", type: "button", tabIndex: -1, "aria-hidden": true, "data-testid": `launcher-scopes-${side}`, onMouseDown: (event) => event.preventDefault(), onClick: onPage, position: "absolute", top: "50%", left: side === "start" ? 0 : undefined, right: side === "end" ? 0 : undefined, transform: "translateY(-50%)", display: "inline-flex", alignItems: "center", justifyContent: "center", boxSize: "28px", borderRadius: "full", borderWidth: "1px", borderColor: raisedRule(colors), bg: colors.surfaceRaised, boxShadow: `0 1px 3px ${colors.boxShadow.default}`, color: colors.textMuted, cursor: "pointer", _hover: { color: colors.text[900] }, sx: { "@media (hover: none)": { display: "none" } }, children: _jsx(Icon, { size: 16, "aria-hidden": true }) }));
+}
+export function ScopeBar({ scopes, value, onChange, label, countLabel, }) {
+    const { colors } = useCustomTheme();
+    const stripRef = useRef(null);
+    const chipRefs = useRef([]);
+    const [edges, setEdges] = useState(NO_EDGES);
+    const reduced = usePrefersReducedMotion();
+    const selected = Math.max(0, scopes.findIndex((scope) => scope.id === value));
+    const layoutKey = scopes.map((s) => { var _a; return `${s.id}:${(_a = s.count) !== null && _a !== void 0 ? _a : ""}`; }).join("|");
+    const edge = liftToContrast(colors.primary[500], colors.surfaceRaised, AA_NON_TEXT);
+    const rule = raisedRule(colors);
+    const measure = useCallback(() => {
+        const strip = stripRef.current;
+        if (!strip)
+            return;
+        const start = strip.scrollLeft > 1;
+        const end = strip.scrollLeft + strip.clientWidth < strip.scrollWidth - 1;
+        setEdges((prev) => prev.start === start && prev.end === end ? prev : { start, end });
+    }, []);
+    useEffect(() => {
+        const strip = stripRef.current;
+        if (!strip || typeof ResizeObserver === "undefined")
+            return undefined;
+        const observer = new ResizeObserver(measure);
+        observer.observe(strip);
+        if (strip.firstElementChild)
+            observer.observe(strip.firstElementChild);
+        return () => observer.disconnect();
+    }, [measure]);
+    useEffect(() => {
+        const strip = stripRef.current;
+        const chip = chipRefs.current[selected];
+        if (strip && chip) {
+            const from = chip.offsetLeft - EDGE;
+            const to = chip.offsetLeft + chip.offsetWidth + EDGE - strip.clientWidth;
+            if (from < strip.scrollLeft)
+                strip.scrollLeft = Math.max(0, from);
+            else if (to > strip.scrollLeft)
+                strip.scrollLeft = to;
+        }
+        measure();
+    }, [selected, layoutKey, measure]);
+    const onKeyDown = (event) => {
+        var _a;
+        if (event.altKey || event.ctrlKey || event.metaKey)
+            return;
+        const step = STEPS[event.key];
+        const last = scopes.length - 1;
+        const next = step !== undefined
+            ? (selected + step + scopes.length) % scopes.length
+            : event.key === "Home"
+                ? 0
+                : event.key === "End"
+                    ? last
+                    : -1;
+        if (next < 0)
+            return;
+        event.preventDefault();
+        (_a = chipRefs.current[next]) === null || _a === void 0 ? void 0 : _a.focus();
+        onChange(scopes[next].id);
+    };
+    const onWheel = (event) => {
+        const strip = event.currentTarget;
+        if (Math.abs(event.deltaY) <= Math.abs(event.deltaX))
+            return;
+        if (strip.scrollWidth > strip.clientWidth)
+            strip.scrollLeft += event.deltaY;
+    };
+    const page = (direction) => {
+        const strip = stripRef.current;
+        if (!strip)
+            return;
+        const step = Math.max(strip.clientWidth - EDGE * 2, EDGE);
+        const max = Math.max(0, strip.scrollWidth - strip.clientWidth);
+        const left = Math.min(max, Math.max(0, strip.scrollLeft + direction * step));
+        if (reduced || typeof strip.scrollTo !== "function")
+            strip.scrollLeft = left;
+        else
+            strip.scrollTo({ left, behavior: "smooth" });
+    };
+    const mask = fadeMask(edges);
+    return (_jsxs(Box, { position: "relative", minW: 0, flexShrink: 1, children: [_jsx(Box, { ref: stripRef, "data-testid": "launcher-scopes", overflowX: "auto", overflowY: "hidden", onScroll: measure, onWheel: onWheel, sx: { ...HIDDEN_SCROLLBAR, maskImage: mask, WebkitMaskImage: mask }, children: _jsx(Flex, { role: "radiogroup", "aria-label": label, onKeyDown: onKeyDown, gap: "6px", w: "max-content", p: "5px", children: scopes.map((scope, index) => {
+                        var _a, _b;
+                        const isSelected = index === selected;
+                        const hasCount = scope.count !== undefined;
+                        return (_jsxs(Box, { as: "button", type: "button", ref: (node) => {
+                                chipRefs.current[index] = node;
+                            }, role: "radio", "aria-checked": isSelected, "aria-label": hasCount
+                                ? countLabel(scope.label, (_a = scope.count) !== null && _a !== void 0 ? _a : 0)
+                                : undefined, tabIndex: isSelected ? 0 : -1, onClick: () => onChange(scope.id), display: "inline-flex", alignItems: "center", gap: "6px", flexShrink: 0, h: "32px", pl: "12px", pr: hasCount ? "6px" : "12px", borderRadius: "full", borderWidth: "1px", borderColor: isSelected ? edge : rule, bg: isSelected ? colors.primary[50] : colors.surfaceRaised, color: isSelected ? colors.accentText : colors.textMuted, fontSize: "xs-plus", fontWeight: isSelected ? 600 : 500, whiteSpace: "nowrap", cursor: "pointer", transition: transitionFor([
+                                "background-color",
+                                "border-color",
+                                "color",
+                            ]), _hover: isSelected
+                                ? undefined
+                                : {
+                                    bg: listRowBackgrounds(colors).active,
+                                    color: colors.text[900],
+                                }, sx: { ...focusVisibleStyles(colors), ...reducedMotionSx() }, children: [scope.label, hasCount ? (_jsx(Box, { as: "span", minW: "20px", h: "20px", px: "6px", borderRadius: "full", bg: isSelected
+                                        ? colors.surfaceRaised
+                                        : colors.backgroundColor.subtle, fontSize: "11.5px", fontWeight: 600, display: "inline-flex", alignItems: "center", justifyContent: "center", sx: { fontVariantNumeric: "tabular-nums" }, children: ((_b = scope.count) !== null && _b !== void 0 ? _b : 0) > MAX_COUNT
+                                        ? `${MAX_COUNT}+`
+                                        : scope.count })) : null] }, scope.id));
+                    }) }) }), edges.start ? _jsx(PageArrow, { side: "start", onPage: () => page(-1) }) : null, edges.end ? _jsx(PageArrow, { side: "end", onPage: () => page(1) }) : null] }));
+}

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

@@ -0,0 +1,37 @@
+/** Damerau-Levenshtein (optimal string alignment) distance; returns `max + 1` once it exceeds `max`. */
+export const editDistance = (a, b, max) => {
+    if (a === b)
+        return 0;
+    const la = a.length;
+    const lb = b.length;
+    if (Math.abs(la - lb) > max)
+        return max + 1;
+    if (la === 0 || lb === 0)
+        return Math.max(la, lb);
+    let before = new Int32Array(lb + 1);
+    let prev = new Int32Array(lb + 1);
+    let cur = new Int32Array(lb + 1);
+    for (let j = 0; j <= lb; j += 1)
+        prev[j] = j;
+    for (let i = 1; i <= la; i += 1) {
+        cur[0] = i;
+        let rowMin = i;
+        for (let j = 1; j <= lb; j += 1) {
+            const cost = a[i - 1] === b[j - 1] ? 0 : 1;
+            let value = Math.min(prev[j] + 1, cur[j - 1] + 1, prev[j - 1] + cost);
+            if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
+                value = Math.min(value, before[j - 2] + 1);
+            }
+            cur[j] = value;
+            if (value < rowMin)
+                rowMin = value;
+        }
+        if (rowMin > max)
+            return max + 1;
+        const spare = before;
+        before = prev;
+        prev = cur;
+        cur = spare;
+    }
+    return Math.min(prev[lb], max + 1);
+};

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

@@ -0,0 +1,459 @@
+import { editDistance } from "./distance.js";
+import { foldText, foldWithMap, hasMarks, letters, splitWords, tokenize, } from "./fold.js";
+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 ? letters(text).length : text.length;
+const indexField = ({ name, text, weight = 1, }) => {
+    var _a;
+    const folded = 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 = hasMarks(folded) ? words.map(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,
+    };
+};
+export 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 };
+};
+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 = 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 = 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 ? letters(token) : token;
+    for (let k = 0; k < words.length; k += 1) {
+        const have = marked ? 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(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) && letters(text).length > 2
+    ? text.slice(0, -TAMIL_FINAL_MA.length)
+    : null;
+const toToken = (text, fuzzy) => {
+    const written = hasMarks(text) ? 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,
+}));
+export const searchIndex = (index, query, options = {}) => {
+    var _a, _b, _c;
+    const tokens = 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);
+};
+export const searchDocuments = (documents, query, options) => searchIndex(createSearchIndex(documents), query, options);
+/** Compiles `query` once; every query word must hit some text of the row. */
+export const createMatcher = (query, options = {}) => {
+    const tokens = 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);
+    };
+};
+/** One-off form of `createMatcher`: does `query` match the row made of `texts`? */
+export const matchesQuery = (query, ...texts) => createMatcher(query)(...texts);
+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 = hasMarks(token) || hasMarks(folded);
+    const firsts = words.map((w) => (marked ? letters(w)[0] : w[0]));
+    if (words.length >= 2 && firsts.join("").startsWith(token)) {
+        return Array.from(marked ? letters(token) : token, (_, i) => [starts[i], starts[i] + firsts[i].length]);
+    }
+    if (fuzzy && writtenSize(token, marked) >= 4) {
+        words.forEach((word, i) => {
+            if (fuzzyScore(marked ? letters(token) : token, [
+                marked ? 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. */
+export const highlightRanges = (text, query, options = {}) => {
+    var _a;
+    const tokens = Array.from(new Set(alternatives(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 } = 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)];
+    });
+};
+/** Additive ranking points from usage: pinned flat, frequent and recent decaying by position. */
+export 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;
+};
+export { editDistance, foldText, splitWords, tokenize };