albex 0.1.0 → 0.6.0

package/README.md

@@ -1,31 +1,27 @@
 # Albex
 
-Local full-text search for documents. Runs entirely in the browser — no server, no upload, no network request after the initial load.
+Local full-text search for documents. Runs entirely in the browser — no server,
+no upload, no network request after the initial load.
 
-Drop a DOCX, PDF, XLSX, TXT or XML file, start typing, get results in milliseconds.
+Drop a DOCX, PDF, XLSX, HTML, Markdown, JSON, CSV, EML, RTF, TXT, or XML file,
+start typing, get results in milliseconds.
 
 ---
 
-## Features
-
-- **Zero server** — all text stays on the user's machine.
-- **Fuzzy matching** — finds "contrato" even if you type "conttrato" (adaptive edit distance).
-- **Accent-insensitive** — "accion" matches "acción", "espana" matches "España".
-- **Multi-format** — DOCX, XLSX, PDF (text-based), TXT, XML.
-- **Phrase search** — `"contrato marco"` requires the words to appear together.
-- **OR search** — `contrato | acuerdo` unions two independent searches.
-- **No dependencies** — one TypeScript file, two WASM binaries, nothing else.
-- **Tiny footprint** — main WASM is ~14 KB on disk; PDF module (~1 MB) loads on demand.
-
----
-
-## Installation
+## Install
 
 ```bash
 npm install albex
 ```
 
-Or copy `dist/albex.js`, `wasm/pkg/albex_wasm_bg.wasm` (and optionally `albex_pdf.wasm`) to your project.
+The WASM binary ships inside the package. Bundlers that recognise the
+`new URL('…', import.meta.url)` pattern (Vite, Webpack 5+, esbuild, Rollup,
+Parcel 2) copy it to the output and rewrite the URL automatically.
+
+Matrix-tested in CI today: **Vite** and **Node** (via the test suite).
+Other bundlers and runtimes (Next SSR, Bun, Deno) should work through the
+same pattern but are not currently exercised by the test matrix — if you
+hit a problem, open an issue.
 
 ---
 
@@ -34,184 +30,320 @@ Or copy `dist/albex.js`, `wasm/pkg/albex_wasm_bg.wasm` (and optionally `albex_pd
 ```ts
 import { AlbexEngine } from 'albex';
 
-const engine = new AlbexEngine({
-  wasmUrl:    '/assets/albex_wasm_bg.wasm',
-  pdfWasmUrl: '/assets/albex_pdf.wasm',   // only needed for PDFs
-});
-
+const engine = new AlbexEngine();
 await engine.init();
 
-// Index a file from a <input type="file"> or drag-and-drop
+// Index a file from <input type="file"> or drag-and-drop.
 const file = inputElement.files[0];
 const doc  = await engine.indexFile(file);
 console.log(`Indexed ${doc.chunks} chunks in ${doc.indexTimeMs.toFixed(0)} ms`);
 
-// Search
+// Search.
 const results = engine.search('contrato marco');
 for (const r of results) {
   console.log(`[${r.score}] ${r.documentName} — ${r.snippet}`);
 }
 ```
 
+Cooperative search — yields to the scheduler between slices so the UI thread
+keeps a chance to paint while a long search runs:
+
+```ts
+for await (const r of engine.searchCooperative('contrato', { frameBudgetMs: 8 })) {
+  renderResult(r);
+}
+```
+
+`searchCooperative` returns the same shape as `search`. The "stream" is not
+incremental yet — results arrive in one batch after the search completes,
+but the work is split into frame-budget slices that yield to the scheduler.
+Real incremental streaming is on the backlog.
+
+That's the entire onboarding. Read on for what else the engine can do.
+
+---
+
+## Features
+
+- **Zero server** — all text stays on the user's machine.
+- **Bundler-friendly default** — `new AlbexEngine()` works without extra
+  configuration in bundlers that recognise the `new URL(..., import.meta.url)`
+  asset pattern (see the "Install" section for the tested matrix).
+- **Fuzzy matching** — finds `"contrato"` even if you type `"conttrato"` (Bitap with adaptive edit distance). Sound under a two-stage pre-filter (character Bloom for exact tokens, a 256-bit **trigram q-gram signature** for everything) that prunes the candidate set ~10× on prose without ever dropping a real approximate match.
+- **Accent-insensitive** — `"accion"` matches `"acción"`, `"espana"` matches `"España"`, plus Latin Extended (Polish, Czech, Slovak, Turkish…).
+- **11 formats with varying depth** — DOCX · XLSX · PDF · HTML · MD · JSON · CSV · EML · RTF · TXT · XML. See the support table below; several formats are deliberately "lite" (CSV is RFC-4180-lite, EML is MIME-lite, RTF is regex-stripped, etc.).
+- **Phrase + OR queries** — `"contrato marco"` and `contrato | acuerdo` work out of the box.
+- **Cooperative search** — `searchCooperative(query, { frameBudgetMs })` yields to the scheduler between slices. Results land in one batch (real incremental streaming is on the backlog).
+- **Persistence** — snapshot the index to OPFS / IndexedDB and restore it. After `load()`, `engine.getStats().documents` is correct, `engine.search()` works against the restored corpus, and content-hash de-duplication survives the round-trip (snapshot v2). Older v1 snapshots still load — their docs come back with empty content hashes, so re-indexing the same files will create fresh slots until the next `save()` rewrites the snapshot as v2.
+- **Incremental updates** — `removeDocument`, `replaceDocument`, `compact`. Content-hash dedup is automatic.
+- **Resource aware** — pauses speculative work in background tabs, shrinks workers on low battery, defers PDF download on slow networks.
+- **Off-main-thread** — `AlbexEngineWorker` mirror or `AlbexPool` shard across N workers (map-reduce search).
+- **WebGPU pre-filter** — experimental, opt-in (`gpu: 'auto'`). Implemented for corpora over 20 k chunks; no reproducible speedup number yet — the bench in this repo runs on a 200-document synthetic corpus only.
+- **SIMD opportunistic** — picks a SIMD-accelerated variant when the host supports v128.
+- **Tiered storage** — `TieredStore` keeps recent docs hot, evicts cold ones to OPFS, promotes on demand.
+- **Capacity-safe** — when a pool fills (`docs`/`chunks`/`text`/`names`), `indexFile` throws `AlbexCapacityError` with a `limit` field instead of silently truncating the corpus.
+- **Re-entrancy-safe** — async operations on one engine serialize; sync `search`/`compact`/`reset` refuse to run mid-operation (`AlbexError` kind `busy`) rather than corrupting the shared WASM state. Use `searchCooperative` for overlapping search-as-you-type.
+- **Typed errors** — `AlbexParseError`, `AlbexUnsupportedFormatError`, `AlbexCapacityError`, `AlbexInitError`. All extend `AlbexError`.
+- **Tiny core** — main WASM 33 KB (37 KB SIMD). PDF module (~1.2 MB) loads on demand. The OCR companion (`@albex/ocr`) is a separate package and pulls Tesseract.js (~3.5 MB) only when you call `enableOcr()`.
+
 ---
 
 ## Supported formats
 
-| Extension | How text is extracted |
-|-----------|----------------------|
-| `.docx`   | Native Rust/WASM XML parser — reads `word/document.xml` directly |
-| `.xlsx`   | Native Rust/WASM XML parser — reads shared strings + inline strings |
-| `.pdf`    | Separate `albex_pdf.wasm` (pure Rust, loaded on demand) |
-| `.txt`    | Plain text split on double newlines |
-| `.xml`    | Tag-stripped, entity-decoded |
+| Extension          | How text is extracted |
+|--------------------|-----------------------|
+| `.docx`            | Native Rust/WASM XML parser — streams `word/document.xml` |
+| `.xlsx`            | Native Rust/WASM XML parser — shared strings + inline strings |
+| `.pdf`             | Separate `albex_pdf.wasm` (pure Rust, loaded on demand) |
+| `.md` / `.markdown`| TS parser — strips CommonMark marks |
+| `.html` / `.htm`   | TS parser — strips `<script>` / `<style>`, paragraphs at block boundaries |
+| `.json`            | TS parser — recursive walk over keys + string leaves |
+| `.csv`             | TS parser — RFC 4180 lite; one row per chunk |
+| `.eml`             | TS parser — MIME-lite: From/To/Subject + text/plain body |
+| `.rtf`             | TS parser — strips control words / groups |
+| `.txt`             | Plain text split on double newlines |
+| `.xml`             | Tag-stripped, entity-decoded |
 
 ---
 
 ## Query syntax
 
-| Input | Behaviour |
-|-------|-----------|
-| `contrato` | Fuzzy match, accent-insensitive |
-| `contrato marco` | Both words must appear in the same chunk |
-| `"contrato marco"` | Both words AND they must be adjacent (phrase) |
-| `contrato \| acuerdo` | OR: returns results matching either term |
+| Input                | Behaviour |
+|----------------------|-----------|
+| `contrato`           | Fuzzy match, accent-insensitive |
+| `contrato marco`     | Both words must appear in the same chunk |
+| `"contrato marco"`   | Both words AND they must be adjacent (phrase) |
+| `contrato \| acuerdo` | OR: union of results matching either branch |
 
 Up to 4 space-separated tokens per simple/phrase query. OR branches are unlimited.
 
 ---
 
-## API reference
-
-### `new AlbexEngine(opts)`
+## API at a glance
 
 ```ts
-interface AlbexOptions {
-  wasmUrl:     string;   // required
-  pdfWasmUrl?: string;   // required only for PDF indexing
+// Construct
+const engine = new AlbexEngine();
+await engine.init();
+
+// Indexing
+const doc = await engine.indexFile(file);
+
+// Search (synchronous fast path)
+const results = engine.search('contrato', { windowed: true });
+
+// Cooperative search (yields to the scheduler between slices)
+for await (const r of engine.searchCooperative('contrato', { frameBudgetMs: 8 })) {
+  /* … */
 }
+
+// Incremental updates
+engine.removeDocument('contract.pdf');
+await engine.replaceDocument('contract.pdf', newFile);
+engine.compact();
+
+// Persistence (OPFS or IndexedDB)
+await engine.save('my-corpus');
+await engine.loadOrInit('my-corpus');
+
+// Tuning
+engine.setMaxErrors(2);
+engine.setThreshold(400);
+engine.setMaxResults(50);
+engine.setLanguage('es');
+
+// Introspection
+const stats   = engine.getStats();
+const lastRun = engine.getLastSearchStats();
 ```
 
-### `engine.init(): Promise<void>`
+Full API reference and types: [bdovenbird.com/albex/docs](https://bdovenbird.com/albex/docs).
 
-Fetches and initialises the main WASM module. Must be called before anything else.
+---
 
-### `engine.indexFile(file: File): Promise<IndexedDocument>`
+## Off the main thread
 
-Detects the file format by extension, extracts text, and adds it to the search index. Throws for unsupported extensions or parse errors.
+For interactive search UIs, run the engine inside a Web Worker:
 
 ```ts
-interface IndexedDocument {
-  name:        string;
-  ext:         string;
-  chunks:      number;   // number of indexed text chunks
-  indexTimeMs: number;
-  textBytes:   number;   // raw UTF-8 text indexed
-}
+import { AlbexEngineWorker } from 'albex/worker';
+
+const engine = new AlbexEngineWorker({
+  workerUrl: new URL('albex/worker-runtime', import.meta.url),
+});
+await engine.init();
 ```
 
-### `engine.search(query: string): SearchResult[]`
+Same surface as `AlbexEngine`; everything returns a `Promise`.
 
-Returns results sorted by score (0–1000, descending).
+---
 
-```ts
-interface SearchResult {
-  documentName: string;
-  location:     number;   // paragraph (DOCX/TXT) or page (PDF, 1-based)
-  score:        number;   // 0–1000
-  snippet:      string;   // full chunk text (original, with accents)
-  matchStart:   number;   // byte offset of match in snippet
-  matchEnd:     number;   // exclusive
-}
-```
+## Sharding across cores
 
-### `engine.getStats(): EngineStats`
+For large corpora, an `AlbexPool` shards documents across N workers:
 
 ```ts
-interface EngineStats {
-  documents:       number;
-  chunks:          number;
-  textUsed:        number;   // bytes
-  textCapacity:    number;   // 16 MB hard cap
-  wasmMemoryBytes: number;
-}
+import { AlbexPool } from 'albex/pool';
+
+const pool = new AlbexPool({
+  workerUrl: new URL('albex/worker-runtime', import.meta.url),
+  workers:   'auto',   // = cores / 2, clamped [1, 8]
+});
+await pool.init();
+
+await pool.indexFile(fileA);    // sharded round-robin
+const results = await pool.search('contrato');  // map-reduce
 ```
 
-### `engine.getLastSearchStats(): SearchStats | null`
+---
+
+## Big corpora — tiered storage
 
-Bloom/Bitap pipeline counters from the most recent search — useful for debugging and UI dashboards.
+For workloads that exceed the tier's RAM capacity:
 
 ```ts
-interface SearchStats {
-  query:        string;
-  timeMs:       number;
-  results:      number;
-  bloomTested:  number;   // chunks tested
-  bloomPassed:  number;   // passed bloom pre-filter
-  bitapMatched: number;   // confirmed by Bitap
-}
+import { AlbexEngine, TieredStore } from 'albex';
+
+const engine = new AlbexEngine();
+await engine.init();
+
+const store = new TieredStore(engine, { evictThreshold: 0.85 });
+await store.init();
+
+await store.indexFile(file);              // persists original blob in OPFS
+await store.promote('older-doc.pdf');     // brings warm doc back
 ```
 
-### Tuning
+Hot tier = engine. Warm tier = original files in OPFS. LRU eviction is automatic.
+
+---
+
+## Advanced configuration
+
+`new AlbexEngine()` covers the default case. The options below address
+specific deployment needs:
+
+### Tier auto-selection (`mini` / `std` / `pro` based on `deviceMemory`)
+
+Albex ships **six** WASM variants of the main engine (3 tiers × baseline/SIMD).
+By default it loads the std-baseline binary that comes with the npm package.
+If you want runtime tier auto-selection, serve the variants yourself and
+pass `wasmBaseUrl`:
 
 ```ts
-engine.setMaxErrors(n);     // 0–3  (default 2, auto-scaled by query length)
-engine.setThreshold(n);     // 0–1000 minimum score (default 250)
-engine.setMaxResults(n);    // 1–200 (default 50)
+const engine = new AlbexEngine({
+  wasmBaseUrl: '/assets',          // directory containing the 6 .wasm files
+  tier: 'auto',                    // picks mini/std/pro by deviceMemory
+  simd: 'auto',                    // picks baseline/simd by WASM probe
+  gpu:  'auto',                    // engages WebGPU when corpus > 20k chunks
+});
 ```
 
-### `engine.reset()`
+Tier capacities:
 
-Clears all indexed documents. The engine is ready to index new files immediately after.
+| Tier  | Max docs | Max chunks | Max text | Working set |
+|-------|---------:|-----------:|---------:|------------:|
+| mini  | 32       | 25 000     | 4 MB     | ~5 MB       |
+| std   | 128      | 100 000    | 16 MB    | ~20 MB      |
+| pro   | 1 024    | 800 000    | 128 MB   | ~160 MB     |
+
+### Custom CDN
+
+```ts
+const engine = new AlbexEngine({
+  wasmUrl: 'https://my-cdn.example.com/albex_wasm.wasm',
+});
+```
 
 ---
 
-## Capacity
+## Errors
+
+All errors thrown by Albex extend `AlbexError`:
 
-| Resource | Limit |
-|----------|-------|
-| Documents | 128 |
-| Chunks | 100 000 |
-| Total text | 16 MB |
-| Query length | 64 characters (longer queries are truncated) |
-| Results | 200 (configurable, default 50) |
+```ts
+import {
+  AlbexError, AlbexInitError, AlbexParseError,
+  AlbexUnsupportedFormatError, AlbexCapacityError,
+} from 'albex';
+
+try {
+  await engine.indexFile(file);
+} catch (e) {
+  if (e instanceof AlbexUnsupportedFormatError) {
+    console.warn(`Skipped .${e.ext} (unsupported)`);
+  } else if (e instanceof AlbexParseError) {
+    console.warn(`Parse failed for ${e.format}:`, e.message);
+  } else throw e;
+}
+```
 
-These are hard-coded BSS limits in the WASM module. Exceeding them is silent — the engine stops indexing additional content without error.
+Each error carries a `kind` field that survives `structuredClone` across worker boundaries.
 
 ---
 
 ## Browser requirements
 
-- WebAssembly (all modern browsers since 2017)
+- WebAssembly (every browser since 2017)
 - `DecompressionStream` for DOCX/XLSX (Chrome 80+, Firefox 113+, Safari 16.4+)
-- `String.prototype.normalize` for phrase search (all modern browsers)
+- OPFS for fastest persistence (Chrome 102+, Safari 15.2+, Firefox 111+); IndexedDB fallback works everywhere
+- WebGPU is **optional**; without it the CPU path is the default
 
-PDF support additionally requires the `albex_pdf.wasm` module to be served with the correct MIME type (`application/wasm`).
+PDF support requires `albex_pdf.wasm` to be served with MIME type `application/wasm`.
 
 ---
 
 ## Building from source
 
 ```bash
-# Install Rust + wasm-pack
 rustup target add wasm32-unknown-unknown
 
-# Build main WASM
-cd wasm && cargo build --target wasm32-unknown-unknown --release
-cp ../target/wasm32-unknown-unknown/release/albex_wasm.wasm pkg/albex_wasm_bg.wasm
+npm install
+npm run build:all         # 6 main variants + PDF + TypeScript
+```
+
+Partial builds:
 
-# Build PDF WASM
-cd ../pdf-wasm && cargo build --target wasm32-unknown-unknown --release
-cp ../target/wasm32-unknown-unknown/release/albex_pdf.wasm ../wasm/pkg/albex_pdf.wasm
+```bash
+npm run build:wasm        # std baseline only
+npm run build:wasm:tiers  # all 6 variants
+npm run build:pdf-wasm    # PDF module
+npm run build             # TypeScript only
+```
+
+---
+
+## Tests
 
-# Build TypeScript
-cd .. && npm install && npm run build
+```bash
+# Rust unit tests
+cargo test --manifest-path core/Cargo.toml
+cargo test --manifest-path ingest/Cargo.toml
+
+# TypeScript + WASM integration tests
+npm test
+
+# Micro-benchmarks
+npm run bench
 ```
 
+**About the benchmark.** The included bench probes per-operation overhead
+on a 200-document synthetic corpus. It is **not** a corpus-level
+performance claim — there is no representative real-world dataset checked
+into the repo yet. Numbers from `npm run bench` should be read as
+"this implementation does not regress against itself", not as comparisons
+against other libraries.
+
+CI runs every check on every push to `main`.
+
 ---
 
 ## Privacy
 
-Albex does not transmit any document content. Text extraction, indexing, and search all happen inside the browser's WASM sandbox. The only network requests are the initial fetch of the `.wasm` binary files.
+Albex never transmits document content. Text extraction, indexing, search and
+persistence all happen inside the browser. The only network requests are the
+initial fetches for the `.wasm` binaries (and the lazy PDF module on first
+PDF). Persisted snapshots live in OPFS / IndexedDB, scoped to your origin.
 
 ---
 

package/dist/albex-worker.d.ts

@@ -0,0 +1,70 @@
+/**
+ * `AlbexEngineWorker` — a main-thread wrapper that runs the engine inside a
+ * Web Worker. Mirrors the surface of `AlbexEngine` so it can be swapped in
+ * without code changes.
+ *
+ * Usage:
+ *
+ *     const engine = new AlbexEngineWorker({
+ *       wasmUrl:    '/assets/albex_wasm_bg.wasm',
+ *       pdfWasmUrl: '/assets/albex_pdf.wasm',
+ *       // Provide the URL to the bundled worker runtime.
+ *       workerUrl:  new URL('./worker-runtime.js', import.meta.url),
+ *     });
+ *     await engine.init();
+ *
+ * Why: a `search()` over 100k chunks can take 10–50 ms. On main thread that
+ * is visible jank for every keystroke. Off-main-thread keeps the UI at 60 fps.
+ *
+ * The runtime is single-threaded WASM, so requests are serialised: only one
+ * call is in flight at a time. This matches the actual `static mut` model
+ * inside the .wasm and is fine for an interactive search UI (each keystroke
+ * replaces the previous query).
+ */
+import type { AlbexOptions, IndexedDocument, SearchOptions, SearchResult, EngineStats, SearchStats } from './albex.js';
+export interface AlbexWorkerOptions extends AlbexOptions {
+    /** URL to the bundled worker runtime script (worker-runtime.js). */
+    workerUrl: string | URL;
+}
+export declare class AlbexEngineWorker {
+    private readonly _opts;
+    private _worker;
+    private _nextId;
+    private _pending;
+    private _docsCache;
+    constructor(opts: AlbexWorkerOptions);
+    init(): Promise<void>;
+    private _send;
+    indexFile(file: File): Promise<IndexedDocument>;
+    search(query: string, opts?: SearchOptions): Promise<SearchResult[]>;
+    /**
+     * Cooperative variant of `search`. Today the wire still sends a single
+     * batch — the result array is fetched in one round-trip from the worker
+     * and then exposed as an async iterator so callers can `break` early.
+     * A future iteration may use a `MessagePort` to stream individual results
+     * from the worker side; the iterator shape is preserved across that
+     * transition.
+     */
+    searchCooperative(query: string, opts?: SearchOptions): AsyncIterable<SearchResult>;
+    /**
+     * @deprecated Renamed to `searchCooperative` in 0.3.0. Alias removed in 0.4.0.
+     */
+    searchStream(query: string, opts?: SearchOptions): AsyncIterable<SearchResult>;
+    removeDocument(id: string): Promise<boolean>;
+    compact(): Promise<void>;
+    reset(): Promise<void>;
+    getStats(): Promise<EngineStats>;
+    getLastSearchStats(): Promise<SearchStats | null>;
+    getDocuments(): Promise<readonly IndexedDocument[]>;
+    setMaxErrors(n: 0 | 1 | 2 | 3): Promise<void>;
+    setThreshold(n: number): Promise<void>;
+    setMaxResults(n: number): Promise<void>;
+    setLanguage(lang: 'off' | 'es'): Promise<void>;
+    save(name: string): Promise<void>;
+    load(name: string): Promise<boolean>;
+    loadOrInit(name: string): Promise<boolean>;
+    deleteSnapshot(name: string): Promise<void>;
+    listSnapshots(): Promise<string[]>;
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=albex-worker.d.ts.map

package/dist/albex-worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"albex-worker.d.ts","sourceRoot":"","sources":["../src/albex-worker.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EACV,YAAY,EACZ,eAAe,EACf,aAAa,EACb,YAAY,EACZ,WAAW,EACX,WAAW,EACZ,MAAM,YAAY,CAAC;AAcpB,MAAM,WAAW,kBAAmB,SAAQ,YAAY;IACtD,oEAAoE;IACpE,SAAS,EAAE,MAAM,GAAG,GAAG,CAAC;CACzB;AASD,qBAAa,iBAAiB;IAC5B,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAqB;IAC3C,OAAO,CAAC,OAAO,CAAU;IACzB,OAAO,CAAC,OAAO,CAAK;IACpB,OAAO,CAAC,QAAQ,CAA8B;IAC9C,OAAO,CAAC,UAAU,CAAyB;gBAE/B,IAAI,EAAE,kBAAkB;IAI9B,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAsB3B,OAAO,CAAC,KAAK;IASP,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,eAAe,CAAC;IAWrD,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,aAAkB,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC;IAIxE;;;;;;;OAOG;IACI,iBAAiB,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,aAAkB,GAAG,aAAa,CAAC,YAAY,CAAC;IAK9F;;OAEG;IACI,YAAY,CAAC,KAAK,EAAE,MAAM,EAAE,IAAI,GAAE,aAAkB,GAAG,aAAa,CAAC,YAAY,CAAC;IAQnF,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAM5C,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IACxB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAK5B,QAAQ,IAAa,OAAO,CAAC,WAAW,CAAC;IACzC,kBAAkB,IAAI,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IACjD,YAAY,IAAU,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;IAEnD,YAAY,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAC7C,YAAY,CAAC,CAAC,EAAE,MAAM,GAAS,OAAO,CAAC,IAAI,CAAC;IAC5C,aAAa,CAAC,CAAC,EAAE,MAAM,GAAQ,OAAO,CAAC,IAAI,CAAC;IAC5C,WAAW,CAAC,IAAI,EAAE,KAAK,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAG9C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAa,OAAO,CAAC,IAAI,CAAC;IAC3C,IAAI,CAAC,IAAI,EAAE,MAAM,GAAa,OAAO,CAAC,OAAO,CAAC;IAC9C,UAAU,CAAC,IAAI,EAAE,MAAM,GAAO,OAAO,CAAC,OAAO,CAAC;IAC9C,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAC3C,aAAa,IAAiB,OAAO,CAAC,MAAM,EAAE,CAAC;IAErD,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI;CAMzB"}