feature: vor und nachteile

praesentation/node_modules/fuse.js/dist/fuse-worker.cjs

@@ -0,0 +1,257 @@
+/**
+ * Fuse.js v7.4.0 - Lightweight fuzzy-search (http://fusejs.io)
+ *
+ * Copyright (c) 2026 Kiro Risk (http://kiro.me)
+ * All Rights Reserved. Apache Software License 2.0
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+'use strict';
+
+var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
+const FUSE_WORKER_UNSUPPORTED_FN_OPTION = option => `FuseWorker does not support function-valued option '${option}': ` + `functions cannot be transferred to Web Workers via postMessage. ` + `Remove this option or fall back to Fuse.`;
+const FUSE_WORKER_TOKEN_SEARCH_UNSUPPORTED = `FuseWorker does not support useTokenSearch: token search depends on ` + `corpus-level statistics (df, fieldCount) that are computed per shard, ` + `so per-shard scores would diverge from single-thread Fuse. Use Fuse on ` + `the main thread for token search.`;
+
+/// <reference lib="dom" />
+
+const DEFAULT_MAX_WORKERS = 8;
+function getDefaultWorkerCount() {
+  const hw = typeof navigator !== 'undefined' ? navigator.hardwareConcurrency || 4 : 4;
+  return Math.min(hw, DEFAULT_MAX_WORKERS);
+}
+class FuseWorker {
+  _shards = null;
+  _addCursor = 0;
+  _initPromise = null;
+  _pending = new Map();
+  _nextId = 0;
+  constructor(docs, options, workerOptions) {
+    this._docs = docs.slice();
+    this._options = options || {};
+    this._workerOptions = workerOptions || {};
+    // Reject function-valued options eagerly. Without this check, postMessage
+    // throws DataCloneError on first search() rather than at construction.
+    FuseWorker._assertNoFunctionOptions(this._options);
+    // Token search needs global corpus statistics, but each shard would build
+    // its own — scores would diverge from single-thread Fuse. Refuse upfront
+    // rather than silently returning ordering that doesn't match.
+    if (this._options.useTokenSearch) {
+      throw new Error(FUSE_WORKER_TOKEN_SEARCH_UNSUPPORTED);
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore -- import.meta.url is resolved by Rollup at build time
+    this._workerUrl = this._workerOptions.workerUrl || new URL('./fuse.worker.mjs', (typeof document === 'undefined' ? require('u' + 'rl').pathToFileURL(__filename).href : (_documentCurrentScript && _documentCurrentScript.tagName.toUpperCase() === 'SCRIPT' && _documentCurrentScript.src || new URL('fuse-worker.cjs', document.baseURI).href)));
+  }
+  static _assertNoFunctionOptions(options) {
+    if (typeof options.sortFn === 'function') {
+      throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION('sortFn'));
+    }
+    if (typeof options.getFn === 'function') {
+      throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION('getFn'));
+    }
+    if (typeof options.tokenize === 'function') {
+      throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION('tokenize'));
+    }
+    const keys = options.keys;
+    if (Array.isArray(keys)) {
+      for (let i = 0, len = keys.length; i < len; i += 1) {
+        const key = keys[i];
+        if (key && typeof key === 'object' && !Array.isArray(key)) {
+          if (typeof key.getFn === 'function') {
+            const name = key.name;
+            const label = Array.isArray(name) ? name.join('.') : name ?? String(i);
+            throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION(`keys[${label}].getFn`));
+          }
+        }
+      }
+    }
+  }
+  _getNumWorkers() {
+    return this._workerOptions.numWorkers || getDefaultWorkerCount();
+  }
+  _ensureInit() {
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = this._init();
+    return this._initPromise;
+  }
+  _spawnWorker() {
+    const worker = new Worker(this._workerUrl, {
+      type: 'module'
+    });
+    worker.onmessage = e => {
+      const {
+        id,
+        result,
+        error
+      } = e.data;
+      const handler = this._pending.get(id);
+      if (!handler) return;
+      this._pending.delete(id);
+      if (error) {
+        handler.reject(new Error(error));
+      } else {
+        handler.resolve(result);
+      }
+    };
+    worker.onerror = e => {
+      for (const [, handler] of this._pending) {
+        handler.reject(new Error(e.message));
+      }
+    };
+    return worker;
+  }
+  _workerInitOptions() {
+    // Force includeScore so the main thread can do a global (score, idx)
+    // tie-break across shards. Score is stripped from the final result if the
+    // caller didn't ask for it.
+    return {
+      ...this._options,
+      includeScore: true
+    };
+  }
+  async _init() {
+    const numWorkers = this._getNumWorkers();
+    const chunkSize = Math.ceil(this._docs.length / numWorkers);
+    this._shards = [];
+    this._addCursor = 0;
+    const workerInitOptions = this._workerInitOptions();
+    const initPromises = [];
+    for (let i = 0; i < numWorkers; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, this._docs.length);
+      const chunk = this._docs.slice(start, end);
+      const globalIndices = [];
+      for (let j = start; j < end; j += 1) globalIndices.push(j);
+      const shard = {
+        worker: this._spawnWorker(),
+        globalIndices
+      };
+      this._shards.push(shard);
+      initPromises.push(this._call(shard.worker, 'init', [chunk, workerInitOptions]));
+    }
+    await Promise.all(initPromises);
+  }
+  _call(worker, method, args) {
+    const id = this._nextId++;
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, {
+        resolve,
+        reject
+      });
+      worker.postMessage({
+        id,
+        method,
+        args
+      });
+    });
+  }
+  async search(query, options) {
+    await this._ensureInit();
+    const shards = this._shards;
+    const results = await Promise.all(shards.map(s => this._call(s.worker, 'search', [query, options])));
+
+    // Merge results from all shards, rewriting refIndex from shard-local to global
+    const merged = [];
+    for (let i = 0, len = results.length; i < len; i += 1) {
+      const {
+        globalIndices
+      } = shards[i];
+      for (const r of results[i]) {
+        merged.push({
+          ...r,
+          refIndex: globalIndices[r.refIndex]
+        });
+      }
+    }
+    const shouldSort = this._options.shouldSort !== false;
+    if (shouldSort) {
+      // Mirror Fuse's default sortFn: (score, idx) tie-break, but on the
+      // GLOBAL refIndex so equal-score results across shards collapse into a
+      // deterministic order matching single-thread Fuse.
+      merged.sort((a, b) => {
+        const sa = a.score ?? 0;
+        const sb = b.score ?? 0;
+        if (sa === sb) {
+          return a.refIndex < b.refIndex ? -1 : 1;
+        }
+        return sa < sb ? -1 : 1;
+      });
+    } else {
+      // Restore global collection order. Round-robin add() and
+      // shard-concatenation order otherwise leak through.
+      merged.sort((a, b) => a.refIndex - b.refIndex);
+    }
+
+    // Workers always include score so the merge above can tie-break; strip it
+    // here if the caller didn't ask for it. Rebuild the object instead of
+    // `delete`-ing — `delete` deopts the shape and roughly doubles the
+    // post-sort cost on large result sets.
+    if (!this._options.includeScore) {
+      for (let i = 0, len = merged.length; i < len; i += 1) {
+        const r = merged[i];
+        merged[i] = r.matches !== undefined ? {
+          item: r.item,
+          refIndex: r.refIndex,
+          matches: r.matches
+        } : {
+          item: r.item,
+          refIndex: r.refIndex
+        };
+      }
+    }
+    const limit = options?.limit;
+    if (limit && limit > 0) {
+      return merged.slice(0, limit);
+    }
+    return merged;
+  }
+  async add(doc) {
+    await this._ensureInit();
+    const shards = this._shards;
+    const shard = shards[this._addCursor % shards.length];
+    this._addCursor += 1;
+    const globalIdx = this._docs.length;
+    this._docs.push(doc);
+    shard.globalIndices.push(globalIdx);
+    await this._call(shard.worker, 'add', [doc]);
+  }
+  async setCollection(docs) {
+    this._docs = docs.slice();
+    if (!this._shards) {
+      this._initPromise = null;
+      return;
+    }
+    const shards = this._shards;
+    const chunkSize = Math.ceil(this._docs.length / shards.length);
+    this._addCursor = 0;
+    const tasks = [];
+    for (let i = 0, len = shards.length; i < len; i += 1) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, this._docs.length);
+      const chunk = this._docs.slice(start, end);
+      const globalIndices = [];
+      for (let j = start; j < end; j += 1) globalIndices.push(j);
+      shards[i].globalIndices = globalIndices;
+      tasks.push(this._call(shards[i].worker, 'setCollection', [chunk]));
+    }
+    await Promise.all(tasks);
+  }
+  terminate() {
+    if (this._shards) {
+      for (const {
+        worker
+      } of this._shards) {
+        worker.terminate();
+      }
+      this._shards = null;
+    }
+    this._initPromise = null;
+    for (const [, handler] of this._pending) {
+      handler.reject(new Error('FuseWorker terminated'));
+    }
+    this._pending.clear();
+  }
+}
+
+exports.FuseWorker = FuseWorker;

praesentation/node_modules/fuse.js/dist/fuse-worker.mjs

@@ -0,0 +1,254 @@
+/**
+ * Fuse.js v7.4.0 - Lightweight fuzzy-search (http://fusejs.io)
+ *
+ * Copyright (c) 2026 Kiro Risk (http://kiro.me)
+ * All Rights Reserved. Apache Software License 2.0
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ */
+
+const FUSE_WORKER_UNSUPPORTED_FN_OPTION = option => `FuseWorker does not support function-valued option '${option}': ` + `functions cannot be transferred to Web Workers via postMessage. ` + `Remove this option or fall back to Fuse.`;
+const FUSE_WORKER_TOKEN_SEARCH_UNSUPPORTED = `FuseWorker does not support useTokenSearch: token search depends on ` + `corpus-level statistics (df, fieldCount) that are computed per shard, ` + `so per-shard scores would diverge from single-thread Fuse. Use Fuse on ` + `the main thread for token search.`;
+
+/// <reference lib="dom" />
+
+const DEFAULT_MAX_WORKERS = 8;
+function getDefaultWorkerCount() {
+  const hw = typeof navigator !== 'undefined' ? navigator.hardwareConcurrency || 4 : 4;
+  return Math.min(hw, DEFAULT_MAX_WORKERS);
+}
+class FuseWorker {
+  _shards = null;
+  _addCursor = 0;
+  _initPromise = null;
+  _pending = new Map();
+  _nextId = 0;
+  constructor(docs, options, workerOptions) {
+    this._docs = docs.slice();
+    this._options = options || {};
+    this._workerOptions = workerOptions || {};
+    // Reject function-valued options eagerly. Without this check, postMessage
+    // throws DataCloneError on first search() rather than at construction.
+    FuseWorker._assertNoFunctionOptions(this._options);
+    // Token search needs global corpus statistics, but each shard would build
+    // its own — scores would diverge from single-thread Fuse. Refuse upfront
+    // rather than silently returning ordering that doesn't match.
+    if (this._options.useTokenSearch) {
+      throw new Error(FUSE_WORKER_TOKEN_SEARCH_UNSUPPORTED);
+    }
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore -- import.meta.url is resolved by Rollup at build time
+    this._workerUrl = this._workerOptions.workerUrl || new URL('./fuse.worker.mjs', import.meta.url);
+  }
+  static _assertNoFunctionOptions(options) {
+    if (typeof options.sortFn === 'function') {
+      throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION('sortFn'));
+    }
+    if (typeof options.getFn === 'function') {
+      throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION('getFn'));
+    }
+    if (typeof options.tokenize === 'function') {
+      throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION('tokenize'));
+    }
+    const keys = options.keys;
+    if (Array.isArray(keys)) {
+      for (let i = 0, len = keys.length; i < len; i += 1) {
+        const key = keys[i];
+        if (key && typeof key === 'object' && !Array.isArray(key)) {
+          if (typeof key.getFn === 'function') {
+            const name = key.name;
+            const label = Array.isArray(name) ? name.join('.') : name ?? String(i);
+            throw new Error(FUSE_WORKER_UNSUPPORTED_FN_OPTION(`keys[${label}].getFn`));
+          }
+        }
+      }
+    }
+  }
+  _getNumWorkers() {
+    return this._workerOptions.numWorkers || getDefaultWorkerCount();
+  }
+  _ensureInit() {
+    if (this._initPromise) return this._initPromise;
+    this._initPromise = this._init();
+    return this._initPromise;
+  }
+  _spawnWorker() {
+    const worker = new Worker(this._workerUrl, {
+      type: 'module'
+    });
+    worker.onmessage = e => {
+      const {
+        id,
+        result,
+        error
+      } = e.data;
+      const handler = this._pending.get(id);
+      if (!handler) return;
+      this._pending.delete(id);
+      if (error) {
+        handler.reject(new Error(error));
+      } else {
+        handler.resolve(result);
+      }
+    };
+    worker.onerror = e => {
+      for (const [, handler] of this._pending) {
+        handler.reject(new Error(e.message));
+      }
+    };
+    return worker;
+  }
+  _workerInitOptions() {
+    // Force includeScore so the main thread can do a global (score, idx)
+    // tie-break across shards. Score is stripped from the final result if the
+    // caller didn't ask for it.
+    return {
+      ...this._options,
+      includeScore: true
+    };
+  }
+  async _init() {
+    const numWorkers = this._getNumWorkers();
+    const chunkSize = Math.ceil(this._docs.length / numWorkers);
+    this._shards = [];
+    this._addCursor = 0;
+    const workerInitOptions = this._workerInitOptions();
+    const initPromises = [];
+    for (let i = 0; i < numWorkers; i++) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, this._docs.length);
+      const chunk = this._docs.slice(start, end);
+      const globalIndices = [];
+      for (let j = start; j < end; j += 1) globalIndices.push(j);
+      const shard = {
+        worker: this._spawnWorker(),
+        globalIndices
+      };
+      this._shards.push(shard);
+      initPromises.push(this._call(shard.worker, 'init', [chunk, workerInitOptions]));
+    }
+    await Promise.all(initPromises);
+  }
+  _call(worker, method, args) {
+    const id = this._nextId++;
+    return new Promise((resolve, reject) => {
+      this._pending.set(id, {
+        resolve,
+        reject
+      });
+      worker.postMessage({
+        id,
+        method,
+        args
+      });
+    });
+  }
+  async search(query, options) {
+    await this._ensureInit();
+    const shards = this._shards;
+    const results = await Promise.all(shards.map(s => this._call(s.worker, 'search', [query, options])));
+
+    // Merge results from all shards, rewriting refIndex from shard-local to global
+    const merged = [];
+    for (let i = 0, len = results.length; i < len; i += 1) {
+      const {
+        globalIndices
+      } = shards[i];
+      for (const r of results[i]) {
+        merged.push({
+          ...r,
+          refIndex: globalIndices[r.refIndex]
+        });
+      }
+    }
+    const shouldSort = this._options.shouldSort !== false;
+    if (shouldSort) {
+      // Mirror Fuse's default sortFn: (score, idx) tie-break, but on the
+      // GLOBAL refIndex so equal-score results across shards collapse into a
+      // deterministic order matching single-thread Fuse.
+      merged.sort((a, b) => {
+        const sa = a.score ?? 0;
+        const sb = b.score ?? 0;
+        if (sa === sb) {
+          return a.refIndex < b.refIndex ? -1 : 1;
+        }
+        return sa < sb ? -1 : 1;
+      });
+    } else {
+      // Restore global collection order. Round-robin add() and
+      // shard-concatenation order otherwise leak through.
+      merged.sort((a, b) => a.refIndex - b.refIndex);
+    }
+
+    // Workers always include score so the merge above can tie-break; strip it
+    // here if the caller didn't ask for it. Rebuild the object instead of
+    // `delete`-ing — `delete` deopts the shape and roughly doubles the
+    // post-sort cost on large result sets.
+    if (!this._options.includeScore) {
+      for (let i = 0, len = merged.length; i < len; i += 1) {
+        const r = merged[i];
+        merged[i] = r.matches !== undefined ? {
+          item: r.item,
+          refIndex: r.refIndex,
+          matches: r.matches
+        } : {
+          item: r.item,
+          refIndex: r.refIndex
+        };
+      }
+    }
+    const limit = options?.limit;
+    if (limit && limit > 0) {
+      return merged.slice(0, limit);
+    }
+    return merged;
+  }
+  async add(doc) {
+    await this._ensureInit();
+    const shards = this._shards;
+    const shard = shards[this._addCursor % shards.length];
+    this._addCursor += 1;
+    const globalIdx = this._docs.length;
+    this._docs.push(doc);
+    shard.globalIndices.push(globalIdx);
+    await this._call(shard.worker, 'add', [doc]);
+  }
+  async setCollection(docs) {
+    this._docs = docs.slice();
+    if (!this._shards) {
+      this._initPromise = null;
+      return;
+    }
+    const shards = this._shards;
+    const chunkSize = Math.ceil(this._docs.length / shards.length);
+    this._addCursor = 0;
+    const tasks = [];
+    for (let i = 0, len = shards.length; i < len; i += 1) {
+      const start = i * chunkSize;
+      const end = Math.min(start + chunkSize, this._docs.length);
+      const chunk = this._docs.slice(start, end);
+      const globalIndices = [];
+      for (let j = start; j < end; j += 1) globalIndices.push(j);
+      shards[i].globalIndices = globalIndices;
+      tasks.push(this._call(shards[i].worker, 'setCollection', [chunk]));
+    }
+    await Promise.all(tasks);
+  }
+  terminate() {
+    if (this._shards) {
+      for (const {
+        worker
+      } of this._shards) {
+        worker.terminate();
+      }
+      this._shards = null;
+    }
+    this._initPromise = null;
+    for (const [, handler] of this._pending) {
+      handler.reject(new Error('FuseWorker terminated'));
+    }
+    this._pending.clear();
+  }
+}
+
+export { FuseWorker };

praesentation/node_modules/fuse.js/dist/fuse.d.ts

@@ -0,0 +1,333 @@
+// Type definitions for Fuse.js v7.4.0
+// TypeScript v6.0.3
+type RangeTuple = [number, number];
+interface SearchResult {
+    isMatch: boolean;
+    score: number;
+    indices?: ReadonlyArray<RangeTuple>;
+    /** @internal Aggregation flag for extended-search inverse terms. */
+    hasInverse?: boolean;
+    /**
+     * @internal Token-search `tokenMatch: 'all'` coverage for this text.
+     * `matchedMask` bit `i` ⇒ query term `i` matched here (≤31-term fast path);
+     * `matchedTerms` is the equivalent set for the ≥32-term fallback.
+     */
+    matchedMask?: number;
+    /** @internal */
+    matchedTerms?: Set<number>;
+    /** @internal Query token count; descriptor for the record-level AND gate. */
+    termCount?: number;
+}
+interface Searcher {
+    searchIn(text: string): SearchResult;
+}
+interface FuseOptionKeyObject<T> {
+    name: string | string[];
+    weight?: number;
+    getFn?: (obj: T) => ReadonlyArray<string> | string | null | undefined;
+}
+type FuseOptionKey<T> = FuseOptionKeyObject<T> | string | string[];
+interface KeyObject {
+    path: string[];
+    id: string;
+    weight: number;
+    src: string | string[];
+    getFn?: ((obj: any) => ReadonlyArray<string> | string | null | undefined) | null;
+}
+type FuseGetFunction<T> = (obj: T, path: string | string[]) => ReadonlyArray<string> | string;
+type GetFunction = (obj: any, path: string | string[]) => any;
+/**
+ * Custom tokenizer for `useTokenSearch`. Receives the field/query text after
+ * case-folding and diacritic-stripping (per `isCaseSensitive` /
+ * `ignoreDiacritics`) and must return the term list. Functions must be
+ * deterministic — non-deterministic output silently breaks `df` accounting.
+ */
+type FuseTokenizeFunction = (text: string) => string[];
+interface NormInterface {
+    get(value: string): number;
+    clear(): void;
+}
+interface RecordEntryObject {
+    /** The text value */
+    v: string;
+    /** The field-length norm */
+    n: number;
+}
+type RecordEntryArrayItem = ReadonlyArray<RecordEntryObject & {
+    i: number;
+}>;
+type RecordEntry = {
+    [key: string]: RecordEntryObject | RecordEntryArrayItem;
+};
+interface FuseIndexObjectRecord {
+    /** The index of the record in the source list */
+    i: number;
+    $: RecordEntry;
+}
+interface FuseIndexStringRecord {
+    /** The index of the record in the source list */
+    i: number;
+    /** The text value */
+    v: string;
+    /** The field-length norm */
+    n: number;
+}
+type FuseIndexRecords = ReadonlyArray<FuseIndexObjectRecord> | ReadonlyArray<FuseIndexStringRecord>;
+interface IndexRecord {
+    i: number;
+    v?: string;
+    n?: number;
+    $?: Record<number, SubRecord | SubRecord[]>;
+}
+interface SubRecord {
+    v: string;
+    i?: number;
+    n: number;
+}
+type FuseSortFunctionItem = {
+    [key: string]: {
+        $: string;
+    } | {
+        $: string;
+        idx: number;
+    }[];
+};
+type FuseSortFunctionMatch = {
+    score: number;
+    key: KeyObject;
+    value: string;
+    indices: ReadonlyArray<number>[];
+};
+type FuseSortFunctionMatchList = FuseSortFunctionMatch & {
+    idx: number;
+};
+type FuseSortFunctionArg = {
+    idx: number;
+    item: FuseSortFunctionItem;
+    score: number;
+    matches?: (FuseSortFunctionMatch | FuseSortFunctionMatchList)[];
+};
+type FuseSortFunction = (a: FuseSortFunctionArg, b: FuseSortFunctionArg) => number;
+interface MatchScore {
+    score: number;
+    key?: KeyObject | null;
+    value: string;
+    idx?: number;
+    hasInverse?: boolean;
+    norm: number;
+    indices?: ReadonlyArray<RangeTuple>;
+    /** @internal Token-search `tokenMatch: 'all'` coverage carried up for record-level gating. */
+    matchedMask?: number;
+    /** @internal */
+    matchedTerms?: Set<number>;
+    /** @internal */
+    termCount?: number;
+}
+interface InternalResult {
+    idx: number;
+    item: any;
+    score?: number;
+    matches: MatchScore[];
+}
+interface IFuseOptions<T> {
+    /** Indicates whether comparisons should be case sensitive. */
+    isCaseSensitive?: boolean;
+    /** Indicates whether comparisons should ignore diacritics (accents). */
+    ignoreDiacritics?: boolean;
+    /** Determines how close the match must be to the fuzzy location. */
+    distance?: number;
+    /** When true, the matching function will continue to the end of a search pattern even if a perfect match has already been located in the string. */
+    findAllMatches?: boolean;
+    /** The function to use to retrieve an object's value at the provided path. */
+    getFn?: FuseGetFunction<T>;
+    /** When `true`, search will ignore `location` and `distance`. */
+    ignoreLocation?: boolean;
+    /** When `true`, the calculation for the relevance score will ignore the field-length norm. */
+    ignoreFieldNorm?: boolean;
+    /** Determines how much the field-length norm affects scoring. */
+    fieldNormWeight?: number;
+    /** Whether the matches should be included in the result set. */
+    includeMatches?: boolean;
+    /** Whether the score should be included in the result set. */
+    includeScore?: boolean;
+    /** List of keys that will be searched. */
+    keys?: Array<FuseOptionKey<T>>;
+    /** Determines approximately where in the text is the pattern expected to be found. */
+    location?: number;
+    /** Only the matches whose length exceeds this value will be returned. */
+    minMatchCharLength?: number;
+    /** Whether to sort the result list, by score. */
+    shouldSort?: boolean;
+    /** The function to use to sort all the results. */
+    sortFn?: FuseSortFunction;
+    /** At what point does the match algorithm give up. */
+    threshold?: number;
+    /** When `true`, it enables the use of unix-like search commands. */
+    useExtendedSearch?: boolean;
+    /** When `true`, enables token search with TF-IDF scoring. */
+    useTokenSearch?: boolean;
+    /**
+     * Tokenizer used by `useTokenSearch`, applied identically at index-build
+     * and query time. Accepts either a global `RegExp` or a function returning
+     * `string[]`. Defaults to `/[\p{L}\p{M}\p{N}_]+/gu`, which handles CJK,
+     * Cyrillic, Greek, Arabic, Hebrew, Devanagari, etc. out of the box. Use a
+     * function form (e.g. wrapping `Intl.Segmenter`) for word-segmentation in
+     * scripts without whitespace boundaries.
+     */
+    tokenize?: RegExp | FuseTokenizeFunction;
+    /**
+     * How the words of a multi-word query combine, for `useTokenSearch` only.
+     * `'any'` (default) returns a record if it matches any query word (OR);
+     * `'all'` returns it only when every query word matches somewhere in the
+     * record — any field or array element (AND). Use `'all'` for filtering,
+     * where adding a word should narrow the results. Has no effect unless
+     * `useTokenSearch` is `true`.
+     */
+    tokenMatch?: 'all' | 'any';
+}
+interface FuseIndexOptions<T> {
+    getFn?: FuseGetFunction<T>;
+    fieldNormWeight?: number;
+}
+interface FuseSearchOptions {
+    limit?: number;
+}
+interface FuseResultMatch {
+    indices: ReadonlyArray<RangeTuple>;
+    key?: string;
+    refIndex?: number;
+    value?: string;
+}
+interface FuseResult<T> {
+    item: T;
+    refIndex: number;
+    score?: number;
+    matches?: ReadonlyArray<FuseResultMatch>;
+}
+type Expression = string | {
+    [key: string]: string;
+} | {
+    $path: ReadonlyArray<string>;
+    $val: string;
+} | {
+    $and?: Expression[];
+} | {
+    $or?: Expression[];
+};
+
+declare class FuseIndex<T = any> {
+    norm: NormInterface;
+    getFn: GetFunction;
+    isCreated: boolean;
+    docs: ReadonlyArray<T>;
+    records: IndexRecord[];
+    keys: KeyObject[];
+    _keysMap: Record<string, number>;
+    constructor({ getFn, fieldNormWeight }?: FuseIndexOptions<T>);
+    setSources(docs?: ReadonlyArray<T>): void;
+    setIndexRecords(records?: IndexRecord[]): void;
+    setKeys(keys?: KeyObject[]): void;
+    create(): void;
+    add(doc: T, docIndex: number): IndexRecord | null;
+    removeAt(idx: number): void;
+    removeAll(indices: number[]): void;
+    getValueForItemAtKeyId(item: any, keyId: string): any;
+    size(): number;
+    _createStringRecord(doc: string, docIndex: number): IndexRecord | null;
+    _createObjectRecord(doc: any, docIndex: number): IndexRecord;
+    toJSON(): {
+        keys: ReadonlyArray<Omit<KeyObject, 'getFn'>>;
+        records: IndexRecord[];
+    };
+}
+declare function createIndex<T>(keys: FuseOptionKey<T>[], docs: ReadonlyArray<T>, { getFn, fieldNormWeight }?: FuseIndexOptions<T>): FuseIndex<T>;
+declare function parseIndex<T>(data: {
+    keys: ReadonlyArray<KeyObject>;
+    records: IndexRecord[];
+}, { getFn, fieldNormWeight }?: FuseIndexOptions<T>): FuseIndex<T>;
+
+declare class KeyStore {
+    _keys: KeyObject[];
+    _keyMap: Record<string, KeyObject>;
+    constructor(keys: FuseOptionKey<any>[]);
+    get(keyId: string): KeyObject;
+    keys(): KeyObject[];
+    toJSON(): string;
+}
+
+interface ParsedLeaf {
+    keyId: string | null;
+    pattern: string;
+    searcher?: Searcher;
+}
+interface ParsedOperator {
+    children: ParsedNode[];
+    operator: string;
+}
+type ParsedNode = ParsedLeaf | ParsedOperator;
+declare function parse(query: Expression, options: any, { auto }?: {
+    auto?: boolean | undefined;
+}): ParsedNode;
+
+declare const Config: Required<IFuseOptions<any>>;
+
+declare class MaxHeap {
+    limit: number;
+    heap: InternalResult[];
+    constructor(limit: number);
+    get size(): number;
+    shouldInsert(score: number): boolean;
+    insert(item: InternalResult): void;
+    extractSorted(sortFn: (a: InternalResult, b: InternalResult) => number): InternalResult[];
+    _bubbleUp(i: number): void;
+    _sinkDown(i: number): void;
+}
+
+interface InvertedIndexData {
+    fieldCount: number;
+    df: Map<string, number>;
+    docFieldCount: Map<number, number>;
+    docTermFieldHits: Map<number, Map<string, number>>;
+}
+
+interface HeapSearchOptions {
+    heap?: MaxHeap;
+    ignoreFieldNorm?: boolean;
+}
+declare class Fuse<T> {
+    options: Required<IFuseOptions<T>>;
+    _keyStore: KeyStore;
+    _docs: T[];
+    _myIndex: FuseIndex<T>;
+    _invertedIndex: InvertedIndexData | null;
+    _lastQuery: string | null;
+    _lastSearcher: Searcher | null;
+    static version: string;
+    static createIndex: typeof createIndex;
+    static parseIndex: typeof parseIndex;
+    static config: typeof Config;
+    static parseQuery: typeof parse;
+    static use: (...plugins: any[]) => void;
+    static match: (pattern: string, text: string, options?: IFuseOptions<any>) => SearchResult;
+    constructor(docs: ReadonlyArray<T>, options?: IFuseOptions<T>, index?: FuseIndex<T>);
+    _getSearcher(query: string): Searcher;
+    setCollection(docs: ReadonlyArray<T>, index?: FuseIndex<T>): void;
+    add(doc: T): void;
+    remove(predicate?: (doc: T, idx: number) => boolean): T[];
+    removeAt(idx: number): T;
+    _invalidateSearcherCache(): void;
+    getIndex(): FuseIndex<T>;
+    search(query: string | Expression, options?: FuseSearchOptions): FuseResult<T>[];
+    _searchStringList(query: string, { heap, ignoreFieldNorm }?: HeapSearchOptions): InternalResult[] | null;
+    _searchLogical(query: Expression): InternalResult[];
+    _searchObjectList(query: string, { heap, ignoreFieldNorm }?: HeapSearchOptions): InternalResult[] | null;
+    _findMatches({ key, value, searcher }: {
+        key: KeyObject | null;
+        value: SubRecord | SubRecord[] | undefined;
+        searcher: Searcher;
+    }): MatchScore[];
+    _coversAllTokens(matches: MatchScore[]): boolean;
+}
+
+export { FuseIndex, Fuse as default };
+export type { Expression, FuseGetFunction, FuseIndexObjectRecord, FuseIndexOptions, FuseIndexRecords, FuseIndexStringRecord, FuseOptionKey, FuseOptionKeyObject, FuseResult, FuseResultMatch, FuseSearchOptions, FuseSortFunction, FuseSortFunctionArg, FuseSortFunctionItem, FuseSortFunctionMatch, FuseSortFunctionMatchList, FuseTokenizeFunction, IFuseOptions, RangeTuple, RecordEntry, RecordEntryArrayItem, RecordEntryObject, SearchResult };