@stll/text-normalize 0.3.0 → 0.5.0

package/README.md

@@ -53,6 +53,15 @@ one); a plain mark strip leaves `ł` standing and under-matches the
 lexemes the index actually stored. Non-Latin scripts are out of contract
 and pass through with their marks stripped.
 
+`foldLikePostgresSearch` (`@stll/text-normalize/postgres-search-fold`) is PostgreSQL's `lower(unaccent(...))` itself,
+code point for code point and every script included, from the
+extension's full rule set (`POSTGRES_UNACCENT_RULES`). Use it where a
+client must agree with a server-side `unaccent` match exactly, such as a
+highlighter marking what the server found:
+`findPostgresSearchFoldRanges` returns those marks as ranges into the
+original text. It is narrower than the client search fold below: it keeps
+marks and letters the extension keeps.
+
 `stripDiacriticsForSlug` is the same strip but decomposes with NFKD, so
 compatibility characters (ligatures, full-width forms, superscripts) fold
 to their base before a `[a-z0-9]` slug filter runs. Slugs are persisted,
@@ -61,8 +70,18 @@ generated with.
 
 ## Substring matching with highlight offsets
 
-`foldSearchMatchText` is the client-side match key for interactive
-filtering: NFKD, the `unaccent()`-parity ASCII folds, mark strip, Arabic
+`createSearchQueryMatcher(query)` (from `@stll/text-normalize/search-query-matcher`) is the client-side answer to "does this
+text match what the user typed": it trims and folds the query once and returns
+a predicate over candidate texts (a blank query matches everything, a missing
+candidate nothing). `filterBySearchQuery({ items, query, fields })` applies it
+to a list, keeping the items any field of which matches. Use these for every
+picker, list filter and typeahead, so a query typed without accents (`dvorak`,
+`strasse`, `lodz`) finds the same items everywhere and in every UI locale. An
+`Intl.Collator` with `sensitivity: "base"` is not an alternative: it compares
+equal-length windows (`strasse` misses `Straße`), its verdict depends on the
+runtime locale, and it keeps Arabic tashkeel significant.
+
+`foldSearchMatchText` is the match key both sides are folded with: NFKD, the `unaccent()`-parity ASCII folds, mark strip, Arabic
 folds, lowercase — `capek` matches `Čapek` and `wroclaw` matches
 `Wrocław`, both ways. `findSearchMatchRanges` finds a folded query in
 folded content and returns ranges into the **original** string, so
@@ -80,9 +99,9 @@ import {
 ```
 
 `containsSearchMatchKey(content, query)` checks a literal substring in keys
-already prepared by the caller. It does not trim or fold either input, so a
-picker can retain locale-specific casing or accent-sensitive matching. Empty
-queries match every key. For accent-insensitive highlight ranges into original
+already prepared by the caller, such as fixed tokens in a message or keys a
+caller folded itself. It does not trim or fold either input; a user-typed query
+goes through `createSearchQueryMatcher` instead. Empty queries match every key. For accent-insensitive highlight ranges into original
 text, use `findSearchMatchRanges` from `@stll/text-normalize` instead.
 
 `findSearchMatchKeyRanges(content, query, { start?, end?, maxMatches? })`

package/dist/postgres-search-fold.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The client half of PostgreSQL's `search_fold(text)`: `lower(unaccent(...))`
+ * with the extension's default dictionary, reproduced code point for code
+ * point so a highlighter marks exactly what a server-side fold matched.
+ *
+ * Deliberately narrower than `foldSearchMatchText`, which also decomposes,
+ * strips every combining mark and folds Arabic and final sigma: marking a run
+ * the server did not match would claim a match that never happened. Here a
+ * character the extension has no rule for keeps its marks, `ς` stays `ς`, and
+ * precomposed and decomposed spellings agree only because the extension maps
+ * the precomposed letter and deletes the combining mark.
+ *
+ * Both halves are per code point: `unaccent` replaces single code points (its
+ * rules have no multi-character sources), and `lower()` under a libc or
+ * builtin collation maps each code point on its own. The parity test in
+ * `apps/api/src/lib/search/postgres-search-fold-parity.db.test.ts` holds this
+ * against a live database for every assigned code point.
+ */
+import type { FoldedSearchText, SearchMatchRange } from "./search-match.js";
+/** `search_fold(value)` as PostgreSQL computes it. */
+export declare const foldLikePostgresSearch: (value: string) => string;
+/**
+ * `foldLikePostgresSearch` with each folded UTF-16 unit mapped back to the
+ * code point it came from. A code point the fold deletes (a combining mark)
+ * joins the range of the one before it, so a match that ends on `e` in
+ * `é` covers the accent the reader sees on it.
+ */
+export declare const foldLikePostgresSearchWithOffsets: (content: string) => FoldedSearchText;
+/**
+ * Non-overlapping occurrences of `term` in `content` under the PostgreSQL
+ * search fold, as ranges into the original `content`. The term is folded as
+ * given, not trimmed.
+ */
+export declare const findPostgresSearchFoldRanges: (content: string, term: string) => SearchMatchRange[];

package/dist/postgres-search-fold.js

@@ -0,0 +1,98 @@
+/**
+ * The client half of PostgreSQL's `search_fold(text)`: `lower(unaccent(...))`
+ * with the extension's default dictionary, reproduced code point for code
+ * point so a highlighter marks exactly what a server-side fold matched.
+ *
+ * Deliberately narrower than `foldSearchMatchText`, which also decomposes,
+ * strips every combining mark and folds Arabic and final sigma: marking a run
+ * the server did not match would claim a match that never happened. Here a
+ * character the extension has no rule for keeps its marks, `ς` stays `ς`, and
+ * precomposed and decomposed spellings agree only because the extension maps
+ * the precomposed letter and deletes the combining mark.
+ *
+ * Both halves are per code point: `unaccent` replaces single code points (its
+ * rules have no multi-character sources), and `lower()` under a libc or
+ * builtin collation maps each code point on its own. The parity test in
+ * `apps/api/src/lib/search/postgres-search-fold-parity.db.test.ts` holds this
+ * against a live database for every assigned code point.
+ */
+import { findFoldedRanges } from "./search-match.js";
+import { POSTGRES_UNACCENT_RULES } from "./unaccent-rules.js";
+/**
+ * `toLowerCase` applies Unicode's full mapping, while `lower()` maps one code
+ * point to one (the simple mapping). The two differ only where the full
+ * mapping expands, and the one unconditional expansion (U+0130 to `i` plus
+ * U+0307) keeps the simple mapping as its first code point. Lowering one code
+ * point at a time also keeps JavaScript's contextual final sigma out, which
+ * `lower()` never applies.
+ */
+const lowerCodePoint = (character) => {
+    // Destructuring a string iterates code points, so this is the first one.
+    const [simple = character] = character.toLowerCase();
+    return simple;
+};
+/**
+ * One code point's fold. Lone surrogates cannot reach the database (a UTF-8
+ * database refuses them), so they fold as the replacement character the way
+ * `toWellFormed` spells them.
+ */
+const foldCodePoint = (character) => {
+    const wellFormed = character.toWellFormed();
+    const unaccented = POSTGRES_UNACCENT_RULES[wellFormed] ?? wellFormed;
+    let lowered = "";
+    for (const codePoint of unaccented) {
+        lowered += lowerCodePoint(codePoint);
+    }
+    return lowered;
+};
+/** `search_fold(value)` as PostgreSQL computes it. */
+export const foldLikePostgresSearch = (value) => {
+    let folded = "";
+    for (const character of value) {
+        folded += foldCodePoint(character);
+    }
+    return folded;
+};
+/**
+ * `foldLikePostgresSearch` with each folded UTF-16 unit mapped back to the
+ * code point it came from. A code point the fold deletes (a combining mark)
+ * joins the range of the one before it, so a match that ends on `e` in
+ * `é` covers the accent the reader sees on it.
+ */
+export const foldLikePostgresSearchWithOffsets = (content) => {
+    const parts = [];
+    const originalRanges = [];
+    let previous;
+    let offset = 0;
+    for (const character of content) {
+        const range = { start: offset, end: offset + character.length };
+        offset = range.end;
+        const folded = foldCodePoint(character);
+        if (folded === "") {
+            if (previous !== undefined) {
+                previous.end = range.end;
+            }
+            continue;
+        }
+        parts.push(folded);
+        // One entry per UTF-16 unit, not per code point: matches index units.
+        let unit = 0;
+        while (unit < folded.length) {
+            originalRanges.push(range);
+            unit += 1;
+        }
+        previous = range;
+    }
+    return { originalRanges, text: parts.join("") };
+};
+/**
+ * Non-overlapping occurrences of `term` in `content` under the PostgreSQL
+ * search fold, as ranges into the original `content`. The term is folded as
+ * given, not trimmed.
+ */
+export const findPostgresSearchFoldRanges = (content, term) => findFoldedRanges({
+    content: foldLikePostgresSearchWithOffsets(content),
+    maxMatches: Number.MAX_SAFE_INTEGER,
+    query: foldLikePostgresSearch(term),
+});
+//# sourceMappingURL=postgres-search-fold.js.map

package/dist/postgres-search-fold.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres-search-fold.js","sourceRoot":"","sources":["../src/postgres-search-fold.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAErD,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAE9D;;;;;;;GAOG;AACH,MAAM,cAAc,GAAG,CAAC,SAAiB,EAAU,EAAE;IACnD,yEAAyE;IACzE,MAAM,CAAC,MAAM,GAAG,SAAS,CAAC,GAAG,SAAS,CAAC,WAAW,EAAE,CAAC;IACrD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,aAAa,GAAG,CAAC,SAAiB,EAAU,EAAE;IAClD,MAAM,UAAU,GAAG,SAAS,CAAC,YAAY,EAAE,CAAC;IAC5C,MAAM,UAAU,GAAG,uBAAuB,CAAC,UAAU,CAAC,IAAI,UAAU,CAAC;IACrE,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,KAAK,MAAM,SAAS,IAAI,UAAU,EAAE,CAAC;QACnC,OAAO,IAAI,cAAc,CAAC,SAAS,CAAC,CAAC;IACvC,CAAC;IACD,OAAO,OAAO,CAAC;AACjB,CAAC,CAAC;AAEF,sDAAsD;AACtD,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,KAAa,EAAU,EAAE;IAC9D,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,MAAM,SAAS,IAAI,KAAK,EAAE,CAAC;QAC9B,MAAM,IAAI,aAAa,CAAC,SAAS,CAAC,CAAC;IACrC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,iCAAiC,GAAG,CAC/C,OAAe,EACG,EAAE;IACpB,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,MAAM,cAAc,GAAuB,EAAE,CAAC;IAC9C,IAAI,QAAsC,CAAC;IAC3C,IAAI,MAAM,GAAG,CAAC,CAAC;IACf,KAAK,MAAM,SAAS,IAAI,OAAO,EAAE,CAAC;QAChC,MAAM,KAAK,GAAG,EAAE,KAAK,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC;QAChE,MAAM,GAAG,KAAK,CAAC,GAAG,CAAC;QACnB,MAAM,MAAM,GAAG,aAAa,CAAC,SAAS,CAAC,CAAC;QACxC,IAAI,MAAM,KAAK,EAAE,EAAE,CAAC;YAClB,IAAI,QAAQ,KAAK,SAAS,EAAE,CAAC;gBAC3B,QAAQ,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;YAC3B,CAAC;YACD,SAAS;QACX,CAAC;QACD,KAAK,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACnB,sEAAsE;QACtE,IAAI,IAAI,GAAG,CAAC,CAAC;QACb,OAAO,IAAI,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC;YAC5B,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;YAC3B,IAAI,IAAI,CAAC,CAAC;QACZ,CAAC;QACD,QAAQ,GAAG,KAAK,CAAC;IACnB,CAAC;IACD,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;AAClD,CAAC,CAAC;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,CAC1C,OAAe,EACf,IAAY,EACQ,EAAE,CACtB,gBAAgB,CAAC;IACf,OAAO,EAAE,iCAAiC,CAAC,OAAO,CAAC;IACnD,UAAU,EAAE,MAAM,CAAC,gBAAgB;IACnC,KAAK,EAAE,sBAAsB,CAAC,IAAI,CAAC;CACpC,CAAC,CAAC"}

package/dist/search-match.d.ts

@@ -1,20 +1,3 @@
-/**
- * Diacritic-insensitive substring matching with original-index mapping.
- *
- * `foldSearchMatchText` builds the client-side match key: NFKD
- * decomposition, the `unaccent()`-parity ASCII folds (letters with no
- * decomposition: `ł`, `ø`, `đ`, `ß`), combining-mark strip, Arabic
- * orthographic folds, then lowercase — so a `capek` query matches `Čapek`
- * and `wroclaw` matches `Wrocław`, both ways. It is deliberately distinct
- * from `arabicNormalize` (normalize.ts), which is pinned to the SQL
- * `arabic_normalize()` contract and must not strip Latin diacritics.
- *
- * `findSearchMatchRanges` locates a folded query inside folded content and
- * reports matches as ranges into the ORIGINAL string, so highlights wrap the
- * text the user actually sees. Folding changes string length (per-character
- * decomposition, mark removal, contextual lowercasing), so the folded form
- * carries a per-code-unit map back to the originating character's range.
- */
 export type SearchMatchRange = {
     end: number;
     start: number;
@@ -26,6 +9,18 @@ export type FoldedSearchText = {
 };
 export declare const foldSearchMatchText: (value: string) => string;
 export declare const foldSearchMatchTextWithOffsets: (content: string) => FoldedSearchText;
+type FindFoldedRangesOptions = {
+    content: FoldedSearchText;
+    maxMatches: number;
+    /** Already folded by the same fold as `content`. */
+    query: string;
+};
+/**
+ * Non-overlapping occurrences of a folded query in folded content, as ranges
+ * into the original string. Shared by every fold that carries
+ * `originalRanges`, so they agree on what "non-overlapping" means.
+ */
+export declare const findFoldedRanges: ({ content, maxMatches, query, }: FindFoldedRangesOptions) => SearchMatchRange[];
 type FindSearchMatchRangesOptions = {
     maxMatches?: number;
 };

package/dist/search-match.js

@@ -1,3 +1,4 @@
+// parser-output-unchanged: `findSearchMatchRanges` hands its scan to `findFoldedRanges` with the same folded content, query and budget; the ranges it returns are unchanged.
 /**
  * Diacritic-insensitive substring matching with original-index mapping.
  *
@@ -71,32 +72,24 @@ export const foldSearchMatchTextWithOffsets = (content) => {
     return { text: loweredParts.join(""), originalRanges };
 };
 /**
- * Non-overlapping occurrences of the folded query in the content, as ranges
- * into the original string. Accepts pre-folded content so callers matching
- * many queries against the same text fold it once.
+ * Non-overlapping occurrences of a folded query in folded content, as ranges
+ * into the original string. Shared by every fold that carries
+ * `originalRanges`, so they agree on what "non-overlapping" means.
  */
-export const findSearchMatchRanges = (content, query, options = {}) => {
-    const maxMatches = Math.max(0, Math.floor(options.maxMatches ?? Number.MAX_SAFE_INTEGER));
-    if (maxMatches === 0) {
-        return [];
-    }
-    const foldedContent = typeof content === "string"
-        ? foldSearchMatchTextWithOffsets(content)
-        : content;
-    const foldedQuery = foldSearchMatchText(query.trim());
-    if (foldedQuery.length === 0) {
+export const findFoldedRanges = ({ content, maxMatches, query, }) => {
+    if (maxMatches <= 0 || query.length === 0) {
         return [];
     }
     const matches = [];
     let searchFrom = 0;
-    while (searchFrom <= foldedContent.text.length - foldedQuery.length) {
-        const foldedStart = foldedContent.text.indexOf(foldedQuery, searchFrom);
+    while (searchFrom <= content.text.length - query.length) {
+        const foldedStart = content.text.indexOf(query, searchFrom);
         if (foldedStart === -1) {
             break;
         }
-        const foldedEnd = foldedStart + foldedQuery.length;
-        const firstRange = foldedContent.originalRanges.at(foldedStart);
-        const lastRange = foldedContent.originalRanges.at(foldedEnd - 1);
+        const foldedEnd = foldedStart + query.length;
+        const firstRange = content.originalRanges.at(foldedStart);
+        const lastRange = content.originalRanges.at(foldedEnd - 1);
         if (!firstRange || !lastRange) {
             break;
         }
@@ -108,11 +101,28 @@ export const findSearchMatchRanges = (content, query, options = {}) => {
         // character; resume after the last unit inside the matched characters so
         // that character is reported once and the budget reaches later hits.
         searchFrom = foldedEnd;
-        while ((foldedContent.originalRanges.at(searchFrom)?.start ?? Infinity) <
-            lastRange.end) {
+        while ((content.originalRanges.at(searchFrom)?.start ?? Infinity) < lastRange.end) {
             searchFrom += 1;
         }
     }
     return matches;
 };
+/**
+ * Non-overlapping occurrences of the folded query in the content, as ranges
+ * into the original string. Accepts pre-folded content so callers matching
+ * many queries against the same text fold it once.
+ */
+export const findSearchMatchRanges = (content, query, options = {}) => {
+    const maxMatches = Math.max(0, Math.floor(options.maxMatches ?? Number.MAX_SAFE_INTEGER));
+    if (maxMatches === 0) {
+        return [];
+    }
+    return findFoldedRanges({
+        content: typeof content === "string"
+            ? foldSearchMatchTextWithOffsets(content)
+            : content,
+        maxMatches,
+        query: foldSearchMatchText(query.trim()),
+    });
+};
 //# sourceMappingURL=search-match.js.map

package/dist/search-match.js.map

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

package/dist/search-query-matcher.d.ts

@@ -0,0 +1,38 @@
+/**
+ * The client-side match for user-typed queries, kept out of the package root
+ * so the corpus parsers that read the root do not depend on it.
+ */
+/** Whether one candidate text contains the query a matcher was built for. */
+export type SearchQueryMatcher = (candidate: string | null | undefined) => boolean;
+/**
+ * The client-side answer to "does this text match what the user typed".
+ *
+ * Both sides go through `foldSearchMatchText`, so case, accents, letters
+ * without a decomposition (`ł`, `ø`, `ß` → `ss`), compatibility ligatures and
+ * Arabic orthographic variants are ignored identically in every UI locale,
+ * and a filtered list agrees with the highlights `findSearchMatchRanges`
+ * draws in it. The query is trimmed and folded once and candidate keys are
+ * cached; a blank query matches every candidate, and a missing candidate
+ * matches none. Lone surrogates become U+FFFD on both sides, so a query can
+ * never match half of an astral character.
+ *
+ * Preferred over an `Intl.Collator` with `sensitivity: "base"`: a collator
+ * compares equal-length windows, so `strasse` never finds `Straße`; its
+ * verdict depends on the runtime locale (Turkish `ISTANBUL` misses
+ * `istanbul`, German `Müller` misses `muller`); it keeps Arabic tashkeel
+ * significant; and it compares every window of every item per keystroke,
+ * where a fold key is computed once per text.
+ */
+export declare const createSearchQueryMatcher: (query: string) => SearchQueryMatcher;
+type FilterBySearchQueryOptions<T> = {
+    /** The texts an item is found by; it matches when any of them does. */
+    fields: (item: T) => readonly (string | null | undefined)[];
+    items: readonly T[];
+    query: string;
+};
+/**
+ * The items any of whose fields matches the query, in their given order,
+ * through `createSearchQueryMatcher`. A blank query keeps every item.
+ */
+export declare const filterBySearchQuery: <T>({ fields, items, query, }: FilterBySearchQueryOptions<T>) => T[];
+export {};

package/dist/search-query-matcher.js

@@ -0,0 +1,65 @@
+/**
+ * The client-side match for user-typed queries, kept out of the package root
+ * so the corpus parsers that read the root do not depend on it.
+ */
+import { foldSearchMatchText } from "./search-match.js";
+// A list filter folds the same names on every keystroke. Remembering their
+// keys turns a keystroke over 2,000 three-field rows from about 3 ms into
+// about 0.2 ms, level with a bare `toLowerCase().includes()`. The fold is
+// pure, so the cache is unobservable; clearing it whole when full bounds its
+// memory without an eviction policy.
+const CANDIDATE_KEY_CACHE_LIMIT = 10_000;
+const candidateKeys = new Map();
+const candidateKey = (candidate) => {
+    const cached = candidateKeys.get(candidate);
+    if (cached !== undefined) {
+        return cached;
+    }
+    if (candidateKeys.size >= CANDIDATE_KEY_CACHE_LIMIT) {
+        candidateKeys.clear();
+    }
+    const key = foldSearchMatchText(candidate.toWellFormed());
+    candidateKeys.set(candidate, key);
+    return key;
+};
+/**
+ * The client-side answer to "does this text match what the user typed".
+ *
+ * Both sides go through `foldSearchMatchText`, so case, accents, letters
+ * without a decomposition (`ł`, `ø`, `ß` → `ss`), compatibility ligatures and
+ * Arabic orthographic variants are ignored identically in every UI locale,
+ * and a filtered list agrees with the highlights `findSearchMatchRanges`
+ * draws in it. The query is trimmed and folded once and candidate keys are
+ * cached; a blank query matches every candidate, and a missing candidate
+ * matches none. Lone surrogates become U+FFFD on both sides, so a query can
+ * never match half of an astral character.
+ *
+ * Preferred over an `Intl.Collator` with `sensitivity: "base"`: a collator
+ * compares equal-length windows, so `strasse` never finds `Straße`; its
+ * verdict depends on the runtime locale (Turkish `ISTANBUL` misses
+ * `istanbul`, German `Müller` misses `muller`); it keeps Arabic tashkeel
+ * significant; and it compares every window of every item per keystroke,
+ * where a fold key is computed once per text.
+ */
+export const createSearchQueryMatcher = (query) => {
+    const foldedQuery = foldSearchMatchText(query.trim().toWellFormed());
+    if (foldedQuery === "") {
+        return () => true;
+    }
+    return (candidate) => candidate !== null &&
+        candidate !== undefined &&
+        candidateKey(candidate).includes(foldedQuery);
+};
+/**
+ * The items any of whose fields matches the query, in their given order,
+ * through `createSearchQueryMatcher`. A blank query keeps every item.
+ */
+export const filterBySearchQuery = ({ fields, items, query, }) => {
+    const matches = createSearchQueryMatcher(query);
+    // A query that matches empty text also keeps items with no search fields.
+    if (matches("")) {
+        return [...items];
+    }
+    return items.filter((item) => fields(item).some(matches));
+};
+//# sourceMappingURL=search-query-matcher.js.map

package/dist/search-query-matcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"search-query-matcher.js","sourceRoot":"","sources":["../src/search-query-matcher.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAExD,2EAA2E;AAC3E,0EAA0E;AAC1E,0EAA0E;AAC1E,6EAA6E;AAC7E,qCAAqC;AACrC,MAAM,yBAAyB,GAAG,MAAM,CAAC;AACzC,MAAM,aAAa,GAAG,IAAI,GAAG,EAAkB,CAAC;AAEhD,MAAM,YAAY,GAAG,CAAC,SAAiB,EAAU,EAAE;IACjD,MAAM,MAAM,GAAG,aAAa,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;IAC5C,IAAI,MAAM,KAAK,SAAS,EAAE,CAAC;QACzB,OAAO,MAAM,CAAC;IAChB,CAAC;IACD,IAAI,aAAa,CAAC,IAAI,IAAI,yBAAyB,EAAE,CAAC;QACpD,aAAa,CAAC,KAAK,EAAE,CAAC;IACxB,CAAC;IACD,MAAM,GAAG,GAAG,mBAAmB,CAAC,SAAS,CAAC,YAAY,EAAE,CAAC,CAAC;IAC1D,aAAa,CAAC,GAAG,CAAC,SAAS,EAAE,GAAG,CAAC,CAAC;IAClC,OAAO,GAAG,CAAC;AACb,CAAC,CAAC;AAOF;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,KAAa,EAAsB,EAAE;IAC5E,MAAM,WAAW,GAAG,mBAAmB,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,YAAY,EAAE,CAAC,CAAC;IACrE,IAAI,WAAW,KAAK,EAAE,EAAE,CAAC;QACvB,OAAO,GAAG,EAAE,CAAC,IAAI,CAAC;IACpB,CAAC;IACD,OAAO,CAAC,SAAS,EAAE,EAAE,CACnB,SAAS,KAAK,IAAI;QAClB,SAAS,KAAK,SAAS;QACvB,YAAY,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,WAAW,CAAC,CAAC;AAClD,CAAC,CAAC;AASF;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAI,EACrC,MAAM,EACN,KAAK,EACL,KAAK,GACyB,EAAO,EAAE;IACvC,MAAM,OAAO,GAAG,wBAAwB,CAAC,KAAK,CAAC,CAAC;IAChD,0EAA0E;IAC1E,IAAI,OAAO,CAAC,EAAE,CAAC,EAAE,CAAC;QAChB,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC;IACpB,CAAC;IACD,OAAO,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;AAC5D,CAAC,CAAC"}

package/dist/slug.d.ts

@@ -7,10 +7,11 @@
  * characters into one separator, clip, trim a trailing separator, fall back
  * when nothing is left — was identical in all four and is fixed here.
  *
- * Deliberately does NOT transliterate. `slugify("café")` is `"caf"` under the
- * `ascii` charset, not `"cafe"`: slugs are persisted, and folding here would
- * quietly start minting different keys for the same labels. The folding
- * primitives in this package are for search text, where nothing is stored.
+ * The `ascii` charset transliterates Latin letters before filtering:
+ * `slugify("Łódź")` is `"lodz"`, not `"odz"`. A key minted before
+ * transliteration is not recomputed by its owner; a caller that re-derives a
+ * stored key at lookup (the case-law routes) recognises the earlier fold
+ * itself.
  *
  * Single-pass by construction: a regex pipeline over untrusted label text is
  * what the slow-regex guard exists to prevent.
@@ -19,7 +20,7 @@
  * Which characters survive.
  *
  * - `ascii` keeps `[a-z0-9]`, for keys that end up in URLs and columns
- *   validated against that charset.
+ *   validated against that charset. Latin letters are transliterated first.
  * - `unicode` keeps any Unicode letter or number, for paths shown back to the
  *   person who typed them.
  */

package/dist/slug.js

@@ -1,3 +1,4 @@
+// parser-output-unchanged: no case-law or legislation adapter or parser calls slugify; adapters reach this module only through the package index.
 /**
  * One slug generator for the key-shaped strings the apps derive from a label.
  *
@@ -7,15 +8,28 @@
  * characters into one separator, clip, trim a trailing separator, fall back
  * when nothing is left — was identical in all four and is fixed here.
  *
- * Deliberately does NOT transliterate. `slugify("café")` is `"caf"` under the
- * `ascii` charset, not `"cafe"`: slugs are persisted, and folding here would
- * quietly start minting different keys for the same labels. The folding
- * primitives in this package are for search text, where nothing is stored.
+ * The `ascii` charset transliterates Latin letters before filtering:
+ * `slugify("Łódź")` is `"lodz"`, not `"odz"`. A key minted before
+ * transliteration is not recomputed by its owner; a caller that re-derives a
+ * stored key at lookup (the case-law routes) recognises the earlier fold
+ * itself.
  *
  * Single-pass by construction: a regex pipeline over untrusted label text is
  * what the slow-regex guard exists to prevent.
  */
+import { applyAsciiFolds } from "./ascii-fold.js";
 const UNICODE_SLUG_CHARACTER = /[\p{L}\p{N}]/u;
+/** Compatibility decomposition, the search fold's mark strip and the table. */
+const spellInAscii = (text) => applyAsciiFolds(text.normalize("NFKD"));
+/**
+ * Latin letters spelled in ASCII: compatibility decomposition (`fi`, `Ａ`), the
+ * search fold's mark strip (`č`), and the `unaccent()` table for letters no
+ * decomposition reaches (`ł`, `ø`, `ß`, `þ`, `ı`). The table is not closed
+ * under case (`Ɩ` folds and its small letter `ɩ` does not; `ɡ` folds and its
+ * capital `Ɡ` does not), so it applies on both sides of the lowercase. Other
+ * scripts pass through and are filtered out.
+ */
+const transliterateToAscii = (value) => spellInAscii(spellInAscii(value).toLowerCase()).toLowerCase();
 const isSlugCharacter = (character, charset) => {
     if (charset === "unicode") {
         return UNICODE_SLUG_CHARACTER.test(character);
@@ -24,9 +38,10 @@ const isSlugCharacter = (character, charset) => {
         (character >= "0" && character <= "9"));
 };
 export const slugify = (value, { charset, separator, maxLength, fallback }) => {
+    const source = charset === "ascii" ? transliterateToAscii(value) : value.toLowerCase();
     let buffer = "";
     let lastWasSeparator = true;
-    for (const character of value.toLowerCase()) {
+    for (const character of source) {
         if (isSlugCharacter(character, charset)) {
             buffer += character;
             lastWasSeparator = false;

package/dist/slug.js.map

@@ -1 +1 @@
-{"version":3,"file":"slug.js","sourceRoot":"","sources":["../src/slug.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAgCH,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAE/C,MAAM,eAAe,GAAG,CAAC,SAAiB,EAAE,OAAoB,EAAW,EAAE;IAC3E,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,CACL,CAAC,SAAS,IAAI,GAAG,IAAI,SAAS,IAAI,GAAG,CAAC;QACtC,CAAC,SAAS,IAAI,GAAG,IAAI,SAAS,IAAI,GAAG,CAAC,CACvC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,KAAa,EACb,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAkB,EACnD,EAAE;IACV,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,gBAAgB,GAAG,IAAI,CAAC;IAE5B,KAAK,MAAM,SAAS,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE,CAAC;QAC5C,IAAI,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,SAAS,CAAC;YACpB,gBAAgB,GAAG,KAAK,CAAC;YACzB,SAAS;QACX,CAAC;QACD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,MAAM,IAAI,SAAS,CAAC;YACpB,gBAAgB,GAAG,IAAI,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,KAAK,MAAM,SAAS,IAAI,MAAM,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,MAAM;QACR,CAAC;QACD,OAAO,IAAI,SAAS,CAAC;IACvB,CAAC;IACD,0EAA0E;IAC1E,OAAO,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACnC,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,OAAO,OAAO,IAAI,QAAQ,CAAC;AAC7B,CAAC,CAAC"}
+{"version":3,"file":"slug.js","sourceRoot":"","sources":["../src/slug.ts"],"names":[],"mappings":"AAAA,kJAAkJ;AAClJ;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAgClD,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAE/C,+EAA+E;AAC/E,MAAM,YAAY,GAAG,CAAC,IAAY,EAAU,EAAE,CAC5C,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,CAAC;AAE1C;;;;;;;GAOG;AACH,MAAM,oBAAoB,GAAG,CAAC,KAAa,EAAU,EAAE,CACrD,YAAY,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;AAEhE,MAAM,eAAe,GAAG,CAAC,SAAiB,EAAE,OAAoB,EAAW,EAAE;IAC3E,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;QAC1B,OAAO,sBAAsB,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;IAChD,CAAC;IACD,OAAO,CACL,CAAC,SAAS,IAAI,GAAG,IAAI,SAAS,IAAI,GAAG,CAAC;QACtC,CAAC,SAAS,IAAI,GAAG,IAAI,SAAS,IAAI,GAAG,CAAC,CACvC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG,CACrB,KAAa,EACb,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAkB,EACnD,EAAE;IACV,MAAM,MAAM,GACV,OAAO,KAAK,OAAO,CAAC,CAAC,CAAC,oBAAoB,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;IAC1E,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,IAAI,gBAAgB,GAAG,IAAI,CAAC;IAE5B,KAAK,MAAM,SAAS,IAAI,MAAM,EAAE,CAAC;QAC/B,IAAI,eAAe,CAAC,SAAS,EAAE,OAAO,CAAC,EAAE,CAAC;YACxC,MAAM,IAAI,SAAS,CAAC;YACpB,gBAAgB,GAAG,KAAK,CAAC;YACzB,SAAS;QACX,CAAC;QACD,IAAI,CAAC,gBAAgB,EAAE,CAAC;YACtB,MAAM,IAAI,SAAS,CAAC;YACpB,gBAAgB,GAAG,IAAI,CAAC;QAC1B,CAAC;IACH,CAAC;IAED,IAAI,OAAO,GAAG,EAAE,CAAC;IACjB,KAAK,MAAM,SAAS,IAAI,MAAM,EAAE,CAAC;QAC/B,IAAI,OAAO,CAAC,MAAM,GAAG,SAAS,CAAC,MAAM,GAAG,SAAS,EAAE,CAAC;YAClD,MAAM;QACR,CAAC;QACD,OAAO,IAAI,SAAS,CAAC;IACvB,CAAC;IACD,0EAA0E;IAC1E,OAAO,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACnC,OAAO,GAAG,OAAO,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,OAAO,OAAO,IAAI,QAAQ,CAAC;AAC7B,CAAC,CAAC"}

package/dist/unaccent-rules.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Every rule PostgreSQL's `unaccent` extension applies with its default
+ * `unaccent` dictionary: each key is one code point, each value what
+ * `unaccent()` replaces it with (empty for the combining and enclosing marks
+ * it deletes). A code point without an entry passes through unchanged.
+ *
+ * Generated from the extension itself, so the two sides cannot drift by hand:
+ *
+ * ```sql
+ * SELECT cp, unaccent(chr(cp))
+ * FROM generate_series(1, 196607) AS cp
+ * WHERE NOT (cp BETWEEN 55296 AND 57343)
+ *   AND unaccent(chr(cp)) IS DISTINCT FROM chr(cp);
+ * ```
+ *
+ * `apps/api/src/lib/search/postgres-search-fold-parity.db.test.ts` re-runs
+ * the query against a live PostgreSQL and asserts both directions, so an
+ * extension upgrade that adds, drops or retargets a rule fails CI instead of
+ * splitting a client-side fold from the server's.
+ *
+ * Unlike `ASCII_FOLD_TABLE`, which holds only the Latin rules NFD cannot
+ * express, this is the whole rule set, every script included: a caller that
+ * must agree with `unaccent()` character for character (a highlighter
+ * marking what a server-side match found) cannot approximate any of it.
+ */
+export declare const POSTGRES_UNACCENT_RULES: Readonly<Record<string, string>>;