cry-search 1.0.6 → 1.0.8

package/dist/common/numeric/AugmentedMetadata.d.ts

@@ -1,111 +1,46 @@
-import type { Id, NumericSearchMetadata, NumericTokenSortedList, SearchableObjectSpec } from '../../types/index.js';
+import type { Id, NumericSearchMetadata, NumericTokenSortedList, NumericTokenUnsortedList, SearchableObjectSpec } from '../../types/index.js';
 /**
- * AugmentedMetadata wraps existing NumericSearchMetadata and allows adding
- * additional search tokens dynamically without modifying the base metadata.
+ * Wraps a base {@link NumericSearchMetadata} and exposes a view that overlays
+ * additional ("augmented") tokens onto `sorted` per item, without modifying base.
  *
- * Use case: Add local/temporary data (e.g., "uparjen"/"neuparjen" status) to
- * existing global metadata for searching.
+ * Use case: layer page-local or session-specific searchable data (e.g. status
+ * flags) onto a globally-built metadata snapshot.
  *
- * Items without augmentation reuse the original Uint32Array (no memory duplication).
- * Items with augmentation get a merged sorted token array.
+ * Augmentation policy:
+ * - `sorted` (retrieval) — base tokens **merged** with augmented tokens. Both
+ *   participate in `searchInData` matching.
+ * - `unsorted` (positional ranking) — **base only**. Augmented tokens are NOT
+ *   included; positional scoring uses base order as authoritative.
  *
  * @example
- * const augmented = new AugmentedMetadata(zdravilaMeta, { searchInFields: ['status', 'notes'] });
- * augmented.updateAugmented(id1, { status: "uparjen", notes: "v teku" });
- * augmented.updateAugmented(id2, { status: "neuparjen" });
- *
- * // Now search works with augmented tokens
- * const results = searchInDataReturnIds("aspirin uparjen", augmented);
+ * ```typescript
+ * const aug = new AugmentedMetadata(zdravilaMeta, { searchInFields: ['status'] });
+ * aug.updateAugmented('id1', { status: 'uparjen' });
+ * const ids = searchInDataReturnIds('aspirin uparjen', aug);
+ * ```
  */
 export declare class AugmentedMetadata implements NumericSearchMetadata {
-    private baseMetadata;
-    private augmentedTokens;
-    private spec;
+    readonly sorted: Map<Id, NumericTokenSortedList>;
+    readonly unsorted: Map<Id, NumericTokenUnsortedList>;
+    private readonly augmentedTokens;
+    private readonly spec;
     /**
      * @param baseMetadata - Base search metadata (not modified)
-     * @param spec - Optional spec for tokenizing augmented objects (searchInFields, fieldMatchModes, etc.)
-     * @param augmentedDataMap - Optional initial augmented data map (id -> object)
+     * @param spec - Optional spec for tokenizing augmented objects
+     * @param augmentedDataMap - Optional initial map of id → augmented object
      */
     constructor(baseMetadata: NumericSearchMetadata, spec?: SearchableObjectSpec<any>, augmentedDataMap?: Map<Id, any>);
     /**
-     * Update augmented data for a single item.
-     * Pass undefined to remove augmentation for this item.
-     *
-     * @param id - Item ID
-     * @param augmentedData - Additional searchable object (will be tokenized using spec)
+     * Update augmented data for a single item. Pass `null`/`undefined` to clear.
+     * Augmented tokens are merged into `sorted` at lookup time; `unsorted` is
+     * unaffected.
      */
     updateAugmented(id: Id, augmentedData: any): void;
-    /**
-     * Batch update augmented data for multiple items.
-     * More efficient than calling updateAugmented multiple times.
-     *
-     * @param augmentedDataMap - Map of id -> augmented object (will be tokenized using spec)
-     */
+    /** Batch update augmented data for multiple items. */
     updateAugmentedBatch(augmentedDataMap: Map<Id, any>): void;
-    /**
-     * Remove augmentation for a single item (reverts to base metadata only).
-     */
+    /** Remove augmentation for a single item (reverts to base only). */
     clearAugmented(id: Id): void;
-    /**
-     * Remove all augmentations (reverts to base metadata for all items).
-     */
+    /** Remove all augmentations. */
     clearAllAugmented(): void;
-    /**
-     * Get merged tokens for an item (base + augmented).
-     * Returns undefined if item doesn't exist in base metadata.
-     */
-    get(id: Id): NumericTokenSortedList | undefined;
-    /**
-     * Check if item exists in base metadata.
-     */
-    has(id: Id): boolean;
-    /**
-     * Get number of items in base metadata.
-     */
-    get size(): number;
-    /**
-     * Iterate over all items (id -> merged tokens).
-     */
-    [Symbol.iterator](): MapIterator<[Id, NumericTokenSortedList]>;
-    /**
-     * Iterate over all IDs.
-     */
-    keys(): MapIterator<Id>;
-    /**
-     * Iterate over all merged token arrays.
-     */
-    values(): MapIterator<NumericTokenSortedList>;
-    /**
-     * Iterate over all [id, merged tokens] entries.
-     */
-    entries(): MapIterator<[Id, NumericTokenSortedList]>;
-    /**
-     * Execute callback for each item.
-     */
-    forEach(callbackfn: (value: NumericTokenSortedList, key: Id, map: Map<Id, NumericTokenSortedList>) => void): void;
-    /**
-     * Not supported - this is a read-only wrapper.
-     * Use updateAugmented() or updateAugmentedBatch() instead.
-     */
-    set(_key: Id, _value: NumericTokenSortedList): this;
-    /**
-     * Not supported - this is a read-only wrapper.
-     * Use clearAugmented() instead.
-     */
-    delete(_key: Id): boolean;
-    /**
-     * Not supported - this is a read-only wrapper.
-     * Use clearAllAugmented() instead.
-     */
-    clear(): void;
-    /**
-     * Symbol.toStringTag for Map interface.
-     */
-    get [Symbol.toStringTag](): string;
-    /**
-     * Merge two sorted Uint32Arrays into a new sorted Uint32Array.
-     * Removes duplicates.
-     */
-    private mergeSortedTokenArrays;
 }
 //# sourceMappingURL=AugmentedMetadata.d.ts.map

package/dist/common/numeric/AugmentedMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"AugmentedMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/AugmentedMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,EAAE,EAAE,qBAAqB,EAAE,sBAAsB,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA;AAInH;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,iBAAkB,YAAW,qBAAqB;IAC7D,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,eAAe,CAAiC;IACxD,OAAO,CAAC,IAAI,CAAuC;IAEnD;;;;OAIG;gBAED,YAAY,EAAE,qBAAqB,EACnC,IAAI,CAAC,EAAE,oBAAoB,CAAC,GAAG,CAAC,EAChC,gBAAgB,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC;IAWjC;;;;;;OAMG;IACH,eAAe,CAAC,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,GAAG,GAAG,IAAI;IAkBjD;;;;;OAKG;IACH,oBAAoB,CAAC,gBAAgB,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI;IAqB1D;;OAEG;IACH,cAAc,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI;IAI5B;;OAEG;IACH,iBAAiB,IAAI,IAAI;IAIzB;;;OAGG;IACH,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,sBAAsB,GAAG,SAAS;IAW/C;;OAEG;IACH,GAAG,CAAC,EAAE,EAAE,EAAE,GAAG,OAAO;IAIpB;;OAEG;IACH,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;OAEG;IACH,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,CAAC,EAAE,EAAE,sBAAsB,CAAC,CAAC;IAwB9D;;OAEG;IACH,IAAI,IAAI,WAAW,CAAC,EAAE,CAAC;IAIvB;;OAEG;IACH,MAAM,IAAI,WAAW,CAAC,sBAAsB,CAAC;IAsB7C;;OAEG;IACH,OAAO,IAAI,WAAW,CAAC,CAAC,EAAE,EAAE,sBAAsB,CAAC,CAAC;IAIpD;;OAEG;IACH,OAAO,CAAC,UAAU,EAAE,CAAC,KAAK,EAAE,sBAAsB,EAAE,GAAG,EAAE,EAAE,EAAE,GAAG,EAAE,GAAG,CAAC,EAAE,EAAE,sBAAsB,CAAC,KAAK,IAAI,GAAG,IAAI;IAMjH;;;OAGG;IACH,GAAG,CAAC,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,sBAAsB,GAAG,IAAI;IAInD;;;OAGG;IACH,MAAM,CAAC,IAAI,EAAE,EAAE,GAAG,OAAO;IAIzB;;;OAGG;IACH,KAAK,IAAI,IAAI;IAIb;;OAEG;IACH,IAAI,CAAC,MAAM,CAAC,WAAW,CAAC,IAAI,MAAM,CAEjC;IAED;;;OAGG;IACH,OAAO,CAAC,sBAAsB;CAoD/B"}
+{"version":3,"file":"AugmentedMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/AugmentedMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACxB,oBAAoB,EACrB,MAAM,sBAAsB,CAAA;AAqJ7B;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,iBAAkB,YAAW,qBAAqB;IAC7D,QAAQ,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,EAAE,sBAAsB,CAAC,CAAA;IAChD,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,EAAE,EAAE,wBAAwB,CAAC,CAAA;IAEpD,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAiC;IAEjE,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAuC;IAE5D;;;;OAIG;gBAED,YAAY,EAAE,qBAAqB,EAEnC,IAAI,CAAC,EAAE,oBAAoB,CAAC,GAAG,CAAC,EAEhC,gBAAgB,CAAC,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC;IAcjC;;;;OAIG;IAEH,eAAe,CAAC,EAAE,EAAE,EAAE,EAAE,aAAa,EAAE,GAAG,GAAG,IAAI;IAiBjD,sDAAsD;IAEtD,oBAAoB,CAAC,gBAAgB,EAAE,GAAG,CAAC,EAAE,EAAE,GAAG,CAAC,GAAG,IAAI;IAmB1D,oEAAoE;IACpE,cAAc,CAAC,EAAE,EAAE,EAAE,GAAG,IAAI;IAI5B,gCAAgC;IAChC,iBAAiB,IAAI,IAAI;CAG1B"}

package/dist/common/numeric/createSearchArrayMetadata.d.ts

@@ -1,4 +1,27 @@
-import type { MatchMode, NumericSearchMetadata, NumericTokenSortedList, SearchableObject, SearchableData, SearchableObjectSpec } from '../../types';
+import type { MatchMode, NumericSearchMetadata, NumericTokenSortedList, NumericTokenUnsortedList, SearchableObject, SearchableData, SearchableObjectSpec } from '../../types';
+/**
+ * Checks if an object is deleted or blocked and should be excluded from search.
+ *
+ * @param obj - The searchable object to check
+ * @returns True if the object has _deleted or _blocked set
+ *
+ * @example
+ * ```typescript
+ * isDeletedOrBlocked({ _id: '1', name: 'Test' })                    // false
+ * isDeletedOrBlocked({ _id: '1', name: 'Test', _deleted: new Date() }) // true
+ * ```
+ */
+export declare function isDeletedOrBlocked(obj: SearchableObject): boolean;
+/**
+ * Prefix characters for per-field match modes (used in {@link SearchableObjectSpec.fieldMatchModes}).
+ * Tokens from designated fields are stored with these prefixes so they match using the specified mode.
+ */
+export declare const MATCH_MODE_PREFIXES: Record<MatchMode, string>;
+/**
+ * Reverse mapping from query prefix to match mode.
+ * Used to parse user query strings like `=word`, `!word`, `?word`, `<word`, `>word`, `+word`, `*word`.
+ */
+export declare const PREFIX_TO_MATCH_MODE: Record<string, MatchMode>;
 /**
  * Prefix characters for per-field match modes.
  * Note: With numeric tokens, prefixes are encoded differently.
@@ -27,14 +50,29 @@ export declare function decodeTokenId(encoded: number): number;
  */
 export declare function decodeMatchMode(encoded: number): MatchMode;
 /**
- * Prepares an object for search, returning numeric token IDs.
+ * Per-item result of {@link prepareObjectForSearchNumeric}.
+ *
+ * - `sorted`: deduplicated, ASC-sorted token IDs (with per-field mode bits) for retrieval.
+ * - `firstN`: first N tokens of `spec.keyFields` content in source order — for
+ *   positional ranking. `undefined` when `keyFields` is not declared or yields no tokens.
+ */
+export interface PreparedObjectTokens {
+    sorted: NumericTokenSortedList;
+    firstN: NumericTokenUnsortedList | undefined;
+}
+/**
+ * Prepares an object for search, returning numeric token IDs for both retrieval and ranking.
+ *
+ * Two parallel outputs:
+ * - `sorted`: full sorted union of tokens from `searchInFields` (or all fields).
+ *   Per-field match modes are encoded in the high bits of each token ID.
+ * - `firstN`: tokens from `keyFields` (in declared order, concatenated), tokenized
+ *   without sort, capped to `spec.firstTokensN` (default 8). Used by
+ *   positional ranking. `undefined` when `keyFields` is not set.
  *
- * @param obj - The searchable object to prepare
- * @param spec - Optional specification for extraction and match modes
- * @param tokensMap - Map for string->number conversion
- * @returns undefined if object is _deleted or _blocked, otherwise sorted Uint32Array
+ * Returns `undefined` for `_deleted` / `_blocked` items.
  */
-export declare function prepareObjectForSearchNumeric<T extends SearchableObject, C = unknown>(obj: T, spec: SearchableObjectSpec<T, C> | undefined, tokensMap: Map<string, number>): NumericTokenSortedList | undefined;
+export declare function prepareObjectForSearchNumeric<T extends SearchableObject, C = unknown>(obj: T, spec: SearchableObjectSpec<T, C> | undefined, tokensMap: Map<string, number>): PreparedObjectTokens | undefined;
 /**
  * Creates numeric search metadata for a collection of items.
  *
@@ -62,4 +100,6 @@ export declare function prepareObjectForSearchNumeric<T extends SearchableObject
  * ```
  */
 export declare function createSearchArrayMetadataNumeric<T extends SearchableObject, C = unknown>(data: SearchableData<T>, spec?: SearchableObjectSpec<T, C>): NumericSearchMetadata;
+/** Constructs an empty {@link NumericSearchMetadata}. */
+export declare function emptyNumericSearchMetadata(): NumericSearchMetadata;
 //# sourceMappingURL=createSearchArrayMetadata.d.ts.map

package/dist/common/numeric/createSearchArrayMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"createSearchArrayMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/createSearchArrayMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EACrB,sBAAsB,EACtB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACrB,MAAM,aAAa,CAAC;AASrB;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAMrD,CAAC;AAKF,mDAAmD;AACnD,eAAO,MAAM,aAAa,QAAwB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAS1D;AAoED;;;;;;;GAOG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACnF,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAC5C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,sBAAsB,GAAG,SAAS,CAgBpC;AA8DD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACtF,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,qBAAqB,CAmBvB"}
+{"version":3,"file":"createSearchArrayMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/createSearchArrayMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EACT,qBAAqB,EACrB,sBAAsB,EACtB,wBAAwB,EACxB,gBAAgB,EAChB,cAAc,EACd,oBAAoB,EACrB,MAAM,aAAa,CAAC;AASrB;;;;;;;;;;;GAWG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,gBAAgB,GAAG,OAAO,CAEjE;AAED;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAMzD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,CAS1D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,SAAS,EAAE,MAAM,CAMrD,CAAC;AAKF,mDAAmD;AACnD,eAAO,MAAM,aAAa,QAAwB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAE5E;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAErD;AAED;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,SAAS,CAS1D;AAoED;;;;;;GAMG;AACH,MAAM,WAAW,oBAAoB;IACnC,MAAM,EAAE,sBAAsB,CAAC;IAC/B,MAAM,EAAE,wBAAwB,GAAG,SAAS,CAAC;CAC9C;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,6BAA6B,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACnF,GAAG,EAAE,CAAC,EACN,IAAI,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,SAAS,EAC5C,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC7B,oBAAoB,GAAG,SAAS,CAoBlC;AA6GD;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACtF,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,qBAAqB,CAoBvB;AAED,yDAAyD;AACzD,wBAAgB,0BAA0B,IAAI,qBAAqB,CAElE"}

package/dist/common/numeric/findInLinkedArrays.d.ts

@@ -1,12 +1,17 @@
 import type { SearchableObject, SearchOpts, LinkedSearchResult, LinkedSearchResultWithMeta } from '../../types';
 import type { NumericLinkedSearchMetadataWithData } from './createSearchLinkedMetadata';
 /**
- * Searches across linked data sets using numeric tokens.
+ * Searches across linked data sets using numeric tokens, ranked by positional relevance.
  *
- * For each primary item, collects all tokens from the primary and all its linked items,
+ * For each primary item, collects all tokens from the primary and its linked items,
  * then matches query tokens against this combined pool. Returns primary items with
  * only the linked items that contributed to the match.
  *
+ * **Ranking:** results are sorted by positional score (using `metadata.unsorted`
+ * of primary + matched linked items, in source order). Items with `keyFields`
+ * declared at build time get accurate positional scoring; items without retain
+ * primary insertion order via the deterministic tiebreaker.
+ *
  * **Key behaviors:**
  * - Tokens that match in the primary are excluded from linked matching (prevents
  *   foreign key redundancy)
@@ -25,8 +30,6 @@ import type { NumericLinkedSearchMetadataWithData } from './createSearchLinkedMe
 export declare function findInLinkedArraysNumeric<TPrimary extends SearchableObject, TLinked extends SearchableObject>(query: string, linked: NumericLinkedSearchMetadataWithData<TPrimary, TLinked>, limit?: number, opts?: SearchOpts): LinkedSearchResultWithMeta<TPrimary, TLinked>;
 /**
  * Simplified version of {@link findInLinkedArraysNumeric} that returns just the results.
- *
- * Use this when you don't need the query tokens metadata.
  */
 export declare function findInLinkedArraysSimpleNumeric<TPrimary extends SearchableObject, TLinked extends SearchableObject>(query: string, linked: NumericLinkedSearchMetadataWithData<TPrimary, TLinked>, limit?: number, opts?: SearchOpts): LinkedSearchResult<TPrimary, TLinked>[];
 //# sourceMappingURL=findInLinkedArrays.d.ts.map

package/dist/common/numeric/findInLinkedArrays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"findInLinkedArrays.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/findInLinkedArrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,8BAA8B,CAAC;AAQxF;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mCAAmC,CAAC,QAAQ,EAAE,OAAO,CAAC,EAC9D,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,0BAA0B,CAAC,QAAQ,EAAE,OAAO,CAAC,CAyJ/C;AAED;;;;GAIG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mCAAmC,CAAC,QAAQ,EAAE,OAAO,CAAC,EAC9D,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAEzC"}
+{"version":3,"file":"findInLinkedArrays.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/findInLinkedArrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,gBAAgB,EAChB,UAAU,EACV,kBAAkB,EAClB,0BAA0B,EAC3B,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,mCAAmC,EAAE,MAAM,8BAA8B,CAAC;AAUxF;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wBAAgB,yBAAyB,CACvC,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mCAAmC,CAAC,QAAQ,EAAE,OAAO,CAAC,EAC9D,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,0BAA0B,CAAC,QAAQ,EAAE,OAAO,CAAC,CA6K/C;AAED;;GAEG;AACH,wBAAgB,+BAA+B,CAC7C,QAAQ,SAAS,gBAAgB,EACjC,OAAO,SAAS,gBAAgB,EAEhC,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,mCAAmC,CAAC,QAAQ,EAAE,OAAO,CAAC,EAC9D,KAAK,GAAE,MAAW,EAClB,IAAI,CAAC,EAAE,UAAU,GAChB,kBAAkB,CAAC,QAAQ,EAAE,OAAO,CAAC,EAAE,CAEzC"}

package/dist/common/numeric/scoring.d.ts

@@ -0,0 +1,95 @@
+/**
+ * Tokenize a string preserving source token order (no alphabetic sort).
+ *
+ * Mirrors `prepareStringForSearch` but skips the trailing `.sort()` —
+ * required for positional / order-aware scoring.
+ *
+ * NOTE: do NOT pass the result to retrieval functions (`searchInData...`); those
+ * assume sorted lists for efficient AND-match.
+ */
+export declare function orderedTokenize(input: string): string[];
+/**
+ * Compute relevance score against a query using positional signals.
+ *
+ * Scoring components (additive):
+ * - **+100_000** if raw `query` equals any `exactKeys` value.
+ * - **+50** base for any subsequence-prefix match in `itemTokens`.
+ * - **+100** if ALL query tokens match (in order).
+ * - **+50** if first matched position is 0 (itemTokens starts with first query token).
+ * - **+80** if matched positions form a contiguous prefix `[0..k-1]` (perfect prefix).
+ * - **+30 * (matchedCount / span)** density bonus.
+ * - **-0.1 * itemTokensJoinedLen** length penalty (weak tiebreaker).
+ *
+ * Returns **1** if no query token matched (e.g. item is in the candidate set
+ * only via a secondary field). Returns **0** for empty query.
+ *
+ * @param query - Raw query string (used only for exact-key match)
+ * @param qTokens - Query tokens in source order (from {@link orderedTokenize})
+ * @param itemTokens - Item tokens in source order
+ * @param exactKeys - Optional values for the +100_000 exact-match boost
+ */
+export declare function scoreOne(query: string, qTokens: string[], itemTokens: string[], exactKeys?: readonly string[] | undefined): number;
+/**
+ * Order-agnostic scoring: each query token that exists anywhere in `itemTokens`
+ * contributes `perTokenWeight`. Source order of either side is ignored.
+ *
+ * Use for fields where token order is conventional but not semantic — typically
+ * **person names** ("Janez Novak" === "Novak Janez"), tag lists, or pet breeds.
+ *
+ * Each query token contributes at most once, and each item token can be consumed
+ * by at most one query token (greedy left-to-right matching).
+ *
+ * Examples (default `perTokenWeight = 30`):
+ * - `query=[janez, novak]`, `item=[janez, novak]` → **60**
+ * - `query=[novak, janez]`, `item=[janez, novak]` → **60**  ← key invariant
+ * - `query=[janez, novak]`, `item=[novak, janez]` → **60**
+ * - `query=[janez, krajnik]`, `item=[janez, novak]` → 30 (only "janez" matches)
+ *
+ * Compare with order-sensitive {@link scoreOrderAndPresence}, which would give
+ * the reversed case (60 vs 40) different scores.
+ *
+ * @param qTokens - Query tokens
+ * @param itemTokens - Item tokens
+ * @param perTokenWeight - Bonus per matched query token (default 30)
+ */
+export declare function scoreBag(qTokens: string[], itemTokens: string[], perTokenWeight?: number): number;
+/**
+ * Per-token bonus weights for {@link scoreOrderAndPresence}.
+ *
+ * `ordered` should be larger than `presence` — in-order matches are stronger
+ * signals than out-of-order presence.
+ */
+export interface OrderAndPresenceWeights {
+    /** Bonus per query token that matches in subsequence-prefix order. @default 30 */
+    ordered?: number;
+    /** Bonus per query token that exists somewhere in `itemTokens` but not in order. @default 10 */
+    presence?: number;
+}
+/**
+ * Compute an additive bonus signal from `metadata.unsorted` ordered tokens.
+ *
+ * Designed to be ADDED to a base score (e.g. `scoreOne` result). Distinguishes
+ * three cases per query token:
+ * 1. **Ordered match** — query token appears in `itemTokens` at a position
+ *    consistent with the previous matches (subsequence-prefix in source order)
+ *    → adds `weights.ordered` (default 30).
+ * 2. **Presence-only** — query token appears somewhere in `itemTokens` but
+ *    breaks the source order → adds `weights.presence` (default 10).
+ * 3. **Absent** — no match in `itemTokens` → adds 0.
+ *
+ * Each query token contributes **at most once** (no double-counting): a token
+ * matched in phase 1 cannot also earn the presence bonus.
+ *
+ * Examples (defaults: ordered=30, presence=10):
+ * - `query=[izdaja, recepta]`, `item=[izdaja, recepta]` → 60 (both in order)
+ * - `query=[izdaja, recepta]`, `item=[izdaja]` → 30 (one in order, second absent)
+ * - `query=[izdaja, recepta]`, `item=[recepta, izdaja]` → 40 (first ordered + second presence)
+ *
+ * @param qTokens - Query tokens in source order (from {@link orderedTokenize})
+ * @param itemTokens - Item tokens in source order (typically from
+ *   `metadata.unsorted` via `tokens[id]` lookup)
+ * @param weights - Optional weight overrides
+ * @returns Additive bonus, ≥ 0
+ */
+export declare function scoreOrderAndPresence(qTokens: string[], itemTokens: string[], weights?: OrderAndPresenceWeights): number;
+//# sourceMappingURL=scoring.d.ts.map

package/dist/common/numeric/scoring.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoring.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/scoring.ts"],"names":[],"mappings":"AAKA;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAKvD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,QAAQ,CACtB,KAAK,EAAE,MAAM,EACb,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,GAAG,SAAS,GACxC,MAAM,CAyCR;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,QAAQ,CACtB,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,MAAM,EAAE,EACpB,cAAc,SAAK,GAClB,MAAM,CAgBR;AAED;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB;IACtC,kFAAkF;IAClF,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,gGAAgG;IAChG,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,MAAM,EAAE,EACjB,UAAU,EAAE,MAAM,EAAE,EACpB,OAAO,CAAC,EAAE,uBAAuB,GAChC,MAAM,CAkCR"}

package/dist/common/numeric/searchAndRank.d.ts

@@ -0,0 +1,48 @@
+import type { Id, NumericSearchMetadata, SearchableData, SearchableObject, SearchOpts } from "../../types";
+export { scoreOne, orderedTokenize, scoreOrderAndPresence, scoreBag } from "./scoring";
+export type { OrderAndPresenceWeights } from "./scoring";
+/**
+ * Result of a scored / ranked search.
+ */
+export interface ScoredResult<T extends SearchableObject> {
+    id: Id;
+    item: T;
+    /** Relevance score (higher = better). 100_000 for exact-key match. */
+    score: number;
+}
+/**
+ * Options controlling {@link searchAndRankNumeric} scoring and retrieval.
+ */
+export interface SearchAndRankOptions<T extends SearchableObject> {
+    /**
+     * Extracts the primary display text for an item. Used as **fallback** when
+     * `metadata.unsorted` has no entry for this id (i.e. spec didn't declare
+     * `keyFields`), and for locale-aware tiebreaker sorting.
+     */
+    primaryTextFn: (item: T) => string | undefined;
+    /**
+     * Optional: extracts values that must equal the raw query string for the
+     * top-priority +100_000 exact-key boost (e.g. crtnaKoda / barcode).
+     */
+    exactKeysFn?: (item: T) => readonly string[] | undefined;
+    /** Maximum number of ranked results returned. Default: Infinity. */
+    limit?: number;
+    /** Underlying search options passed to candidate retrieval. */
+    opts?: SearchOpts;
+}
+/**
+ * Search with positional relevance scoring and return ranked results.
+ *
+ * Combines candidate retrieval ({@link searchInDataReturnIdsNumeric}, AND-match
+ * over sorted token lists) with positional scoring per candidate. For best
+ * performance, declare `spec.keyFields` so item tokens are pre-stored in
+ * `metadata.unsorted` and `searchAndRank` avoids re-tokenizing at query time.
+ *
+ * When `metadata.unsorted` has no entry for an id (i.e. `keyFields` not
+ * declared at build time), this function falls back to `orderedTokenize(
+ * primaryTextFn(item))` — same behavior as before the `keyFields` optimization.
+ *
+ * Sort: score DESC, locale-aware `primaryTextFn(item)` ASC as tiebreaker.
+ */
+export declare function searchAndRankNumeric<T extends SearchableObject>(query: string, data: SearchableData<T>, metadata: NumericSearchMetadata, options: SearchAndRankOptions<T>): ScoredResult<T>[];
+//# sourceMappingURL=searchAndRank.d.ts.map

package/dist/common/numeric/searchAndRank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchAndRank.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/searchAndRank.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,UAAU,EACX,MAAM,aAAa,CAAC;AAMrB,OAAO,EAAE,QAAQ,EAAE,eAAe,EAAE,qBAAqB,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAC;AACvF,YAAY,EAAE,uBAAuB,EAAE,MAAM,WAAW,CAAC;AAgBzD;;GAEG;AACH,MAAM,WAAW,YAAY,CAAC,CAAC,SAAS,gBAAgB;IACtD,EAAE,EAAE,EAAE,CAAC;IACP,IAAI,EAAE,CAAC,CAAC;IACR,sEAAsE;IACtE,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB,CAAC,CAAC,SAAS,gBAAgB;IAC9D;;;;OAIG;IACH,aAAa,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,MAAM,GAAG,SAAS,CAAC;IAC/C;;;OAGG;IACH,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,SAAS,MAAM,EAAE,GAAG,SAAS,CAAC;IACzD,oEAAoE;IACpE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,gBAAgB,EAC7D,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAC/B,YAAY,CAAC,CAAC,CAAC,EAAE,CAiCnB"}

package/dist/common/numeric/searchInData.d.ts

@@ -2,30 +2,38 @@ import type { Id, NumericSearchMetadata, SearchableData, SearchableObject, Searc
 /**
  * Searches in numeric metadata and returns matching IDs.
  *
+ * Results are RANKED by positional relevance when `spec.keyFields` is declared
+ * for the source data: items whose `metadata.unsorted` carries pre-ordered key
+ * tokens get scored via `scoreOne`. Items without an `unsorted` entry land at
+ * the bottom (score 0) in original insertion order.
+ *
  * @param query - The search query string
  * @param metadata - The NumericSearchMetadata to search in
  * @param opts - Optional search options for match mode
- * @returns Array of matching object IDs
+ * @returns Array of matching object IDs sorted by relevance DESC
  */
 export declare function searchInDataReturnIdsNumeric(query: string, metadata: NumericSearchMetadata, opts?: SearchOpts): Id[];
 /**
- * Searches in numeric metadata and returns matching objects.
+ * Searches in numeric metadata and returns matching objects, ranked.
  *
  * @param query - The search query string
  * @param metadata - The NumericSearchMetadata to search in
  * @param data - The SearchableData map for object lookup
  * @param opts - Optional search options for match mode
- * @returns Map of matching objects by ID
+ * @returns Map of matching objects by ID. Iteration order = relevance DESC.
  */
 export declare function searchInDataReturnObjectsNumeric<T extends SearchableObject>(query: string, metadata: NumericSearchMetadata, data: SearchableData<T>, opts?: SearchOpts): Map<Id, T>;
 /**
- * Searches with a limit and returns matching IDs.
+ * Searches with a limit and returns matching IDs, RANKED by positional relevance.
  *
- * @param query - The search query string
- * @param metadata - The NumericSearchMetadata to search in
- * @param limit - Maximum number of results to return
- * @param opts - Optional search options for match mode
- * @returns Array of matching object IDs (up to limit)
+ * Retrieval: AND-match of query tokens against each item's `metadata.sorted` —
+ * same as before. Result order changes: candidates are scored using
+ * `metadata.unsorted` (if present) and sorted by score DESC before `limit` is
+ * applied. Items without `unsorted` entries fall back to score 0 and retain
+ * insertion order among themselves.
+ *
+ * To preserve raw insertion order (no ranking), use a metadata built without
+ * `spec.keyFields` — items will all score 0 and remain in iteration order.
  */
 export declare function searchInDataReturnIdsWithLimitNumeric(query: string, metadata: NumericSearchMetadata, limit: number, opts?: SearchOpts): Id[];
 //# sourceMappingURL=searchInData.d.ts.map

package/dist/common/numeric/searchInData.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchInData.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/searchInData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,UAAU,EACX,MAAM,aAAa,CAAC;AAIrB;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,CAAC,EAAE,UAAU,GAChB,EAAE,EAAE,CAEN;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,gBAAgB,EACzE,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,UAAU,GAChB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAYZ;AAED;;;;;;;;GAQG;AACH,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,UAAU,GAChB,EAAE,EAAE,CAsBN"}
+{"version":3,"file":"searchInData.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/searchInData.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,EAAE,EACF,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,UAAU,EACX,MAAM,aAAa,CAAC;AAMrB;;;;;;;;;;;;GAYG;AACH,wBAAgB,4BAA4B,CAC1C,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,CAAC,EAAE,UAAU,GAChB,EAAE,EAAE,CAEN;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,CAAC,SAAS,gBAAgB,EACzE,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,IAAI,EAAE,cAAc,CAAC,CAAC,CAAC,EACvB,IAAI,CAAC,EAAE,UAAU,GAChB,GAAG,CAAC,EAAE,EAAE,CAAC,CAAC,CAYZ;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,qCAAqC,CACnD,KAAK,EAAE,MAAM,EACb,QAAQ,EAAE,qBAAqB,EAC/B,KAAK,EAAE,MAAM,EACb,IAAI,CAAC,EAAE,UAAU,GAChB,EAAE,EAAE,CAiDN"}

package/dist/common/numeric/syncSearchArrayMetadata.d.ts

@@ -3,62 +3,19 @@ export type { SyncResult, SyncOptions } from '../../types/index.js';
 /**
  * Syncs numeric search metadata with new data.
  *
- * This function performs a full sync of metadata against the provided data:
- * - Adds metadata for new items
- * - Removes metadata for items no longer in data (or marked `_deleted`/`_blocked`)
- * - Updates metadata for items whose tokens have changed
+ * Iterates `metadata.sorted.keys()` to find items absent from `newData` (removals).
+ * Then walks `newData`, tokenizing each item and updating metadata only when the
+ * resulting `sorted` or `firstN` differ from existing entries.
  *
- * Use this when you have completely new data to sync with. If you have both
- * previous and new data available, use {@link syncSearchArrayMetadataNumericWithPrevious}
- * for more efficient diffing.
- *
- * @typeParam T - Type of the searchable objects
- * @typeParam C - Type of the search context
- *
- * @param metadata - The NumericSearchMetadata map to update (mutated in place)
- * @param newData - The new data to sync with
- * @param spec - Optional specification for how to extract searchable text
- * @returns SyncResult with counts and IDs of added/updated/removed items
- *
- * @example
- * ```typescript
- * const newProducts = arrayToSearchableData(freshProductsFromServer);
- * const result = syncSearchArrayMetadataNumeric(metadata, newProducts, spec);
- *
- * console.log(`Added: ${result.added}, Updated: ${result.updated}, Removed: ${result.removed}`);
- * ```
+ * Use {@link syncSearchArrayMetadataNumericWithPrevious} when both previous and new
+ * datasets are on hand — it skips the `metadata.sorted.keys()` scan.
  */
 export declare function syncSearchArrayMetadataNumeric<T extends SearchableObject, C = unknown>(metadata: NumericSearchMetadata, newData: SearchableData<T>, spec?: SearchableObjectSpec<T, C>): SyncResult;
 /**
  * Syncs numeric search metadata using previous and new data for efficient diffing.
  *
- * More efficient than {@link syncSearchArrayMetadataNumeric} when you have both the
- * previous and new data available. Uses the previous data to determine
- * what was removed without iterating through all metadata keys.
- *
- * @typeParam T - Type of the searchable objects
- * @typeParam C - Type of the search context
- *
- * @param metadata - The NumericSearchMetadata map to update (mutated in place)
- * @param previousData - The previous data (used to determine what was removed)
- * @param newData - The new data to sync with
- * @param options - Optional sync options (e.g., skipUpdateCheck)
- * @param spec - Optional specification for how to extract searchable text
- * @returns SyncResult with counts and IDs of added/updated/removed items
- *
- * @example
- * ```typescript
- * const previousProducts = currentData;
- * const newProducts = arrayToSearchableData(freshProductsFromServer);
- *
- * const result = syncSearchArrayMetadataNumericWithPrevious(
- *   metadata,
- *   previousProducts,
- *   newProducts,
- *   { skipUpdateCheck: false },
- *   spec
- * );
- * ```
+ * Determines removals from `previousData` (no scan of metadata.sorted.keys()) and
+ * uses `options.skipUpdateCheck` to avoid re-tokenizing items that already existed.
  */
 export declare function syncSearchArrayMetadataNumericWithPrevious<T extends SearchableObject, C = unknown>(metadata: NumericSearchMetadata, previousData: SearchableData<T>, newData: SearchableData<T>, options?: SyncOptions, spec?: SearchableObjectSpec<T, C>): SyncResult;
 //# sourceMappingURL=syncSearchArrayMetadata.d.ts.map

package/dist/common/numeric/syncSearchArrayMetadata.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"syncSearchArrayMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/syncSearchArrayMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EAEpB,UAAU,EACV,WAAW,EACZ,MAAM,sBAAsB,CAAA;AAK7B,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAkBnE;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACpF,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,UAAU,CAoDZ;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,wBAAgB,0CAA0C,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EAChG,QAAQ,EAAE,qBAAqB,EAC/B,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC,EAC/B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,WAAW,EACrB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,UAAU,CAsDZ"}
+{"version":3,"file":"syncSearchArrayMetadata.d.ts","sourceRoot":"","sources":["../../../src/common/numeric/syncSearchArrayMetadata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,qBAAqB,EACrB,cAAc,EACd,gBAAgB,EAChB,oBAAoB,EAGpB,UAAU,EACV,WAAW,EACZ,MAAM,sBAAsB,CAAA;AAK7B,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAA;AAqCnE;;;;;;;;;GASG;AACH,wBAAgB,8BAA8B,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EACpF,QAAQ,EAAE,qBAAqB,EAC/B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,UAAU,CAqDZ;AAED;;;;;GAKG;AACH,wBAAgB,0CAA0C,CAAC,CAAC,SAAS,gBAAgB,EAAE,CAAC,GAAG,OAAO,EAChG,QAAQ,EAAE,qBAAqB,EAC/B,YAAY,EAAE,cAAc,CAAC,CAAC,CAAC,EAC/B,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC,EAC1B,OAAO,CAAC,EAAE,WAAW,EACrB,IAAI,CAAC,EAAE,oBAAoB,CAAC,CAAC,EAAE,CAAC,CAAC,GAChC,UAAU,CAsDZ"}