@sync-subscribe/client 0.3.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 fromkeith
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,430 @@
+# @sync-subscribe/client
+
+Framework-agnostic sync client for `sync-subscribe`. Manages subscriptions locally, maintains a local store, and runs pull/push cycles against any HTTP transport you provide.
+
+## Concepts
+
+| Term | Description |
+|---|---|
+| `SyncRecord` | Every synced record must have `recordId`, `createdAt`, `updatedAt`, `revisionCount` |
+| `SyncTransport` | Your HTTP adapter — implement `pull`, `push`, and optionally `stream` |
+| `SyncClient` | Orchestrates subscriptions, local state, pull/push, and reactive queries |
+| `ILocalStore` | Async interface for local storage — both built-in stores implement it |
+| `LocalStore` | In-memory store (default); fast but data is lost on page reload |
+| `IdbLocalStore` | IndexedDB-backed store; data persists across page reloads |
+| `ClientSubscription` | Tracks a subscription's `subscriptionId`, `filter`, and `syncToken` |
+| `SyncQuery<T>` | A reactive handle that follows the store contract: `{ data: T[], loading: boolean }` |
+
+## Installation
+
+```bash
+npm install @sync-subscribe/client @sync-subscribe/core
+```
+
+## Quick start
+
+### 1. Define your record type
+
+```ts
+import type { SyncRecord } from "@sync-subscribe/core";
+
+interface NoteRecord extends SyncRecord {
+  title: string;
+  contents: string;
+  isDeleted: boolean;
+}
+```
+
+### 2. Create a transport
+
+Use the built-in `createFetchTransport` for standard fetch-based HTTP:
+
+```ts
+import { createFetchTransport } from "@sync-subscribe/client";
+
+const transport = createFetchTransport({
+  baseUrl: "/api",
+  headers: () => ({ Authorization: `Bearer ${getToken()}` }),
+});
+```
+
+Or implement `SyncTransport` yourself for full control:
+
+```ts
+import type { SyncTransport } from "@sync-subscribe/client";
+
+const transport: SyncTransport = {
+  async pull(subscriptions) {
+    const res = await fetch("/api/sync/pull", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ subscriptions }), // [{ key, filter, syncToken }]
+    });
+    return res.json(); // { patches, syncTokens }
+  },
+
+  async push(records) {
+    const res = await fetch("/api/sync/push", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ records }),
+    });
+    return res.json(); // { ok: true } or { conflict: true, serverRecord }
+  },
+};
+```
+
+### 3. Create a client
+
+```ts
+import { SyncClient } from "@sync-subscribe/client";
+
+const client = new SyncClient<NoteRecord>(transport);
+```
+
+#### Persistent storage with IndexedDB
+
+Pass an `IdbLocalStore` as the second argument to survive page reloads:
+
+```ts
+import { SyncClient, IdbLocalStore } from "@sync-subscribe/client";
+
+const client = new SyncClient<NoteRecord>(
+  transport,
+  new IdbLocalStore("notes-db"),
+);
+```
+
+---
+
+## Three ways to use data
+
+There is a deliberate separation between **syncing** data (keeping the local store current) and **querying** data (reading from the local store into memory). This lets you sync more data than you display at any one time.
+
+### 1. Sync-only — keep data current in the store, nothing in memory
+
+Use this when you want data available locally (for fast queries, offline use) but don't need it loaded into JS memory right now.
+
+```ts
+// Keeps last 30 days synced. Automatically starts pull + SSE stream.
+const sub = await client.subscribe({
+  filter: { createdAt: { $gte: Date.now() - 30 * 24 * 60 * 60 * 1000 } },
+  name: "last-30-days",
+});
+
+// Later, remove it
+await client.unsubscribe(sub.subscriptionId);
+```
+
+`subscribe()` handles pull scheduling and SSE stream management automatically. Multiple rapid `subscribe()` calls are debounced into a single stream reconnect.
+
+### 2. Query — read from the local store reactively
+
+Use this when data is already being synced (by a separate `subscribe()`) but you want a filtered, reactive, in-memory view of it. No additional sync subscription is registered.
+
+```ts
+// client.query() returns a SyncQuery<T> — a store-contract object.
+// Nothing happens until you call .subscribe() on it.
+const todayQuery = client.query({
+  filter: { createdAt: { $gte: startOfToday } },
+});
+
+// Follow the store contract: subscribe(run) => unsubscribe
+const unsub = todayQuery.subscribe(({ data, loading }) => {
+  if (loading) return;
+  console.log("today's notes:", data);
+});
+
+unsub(); // stop listening
+```
+
+`query()` is a sub-filter of whatever is already synced. It reads from the local store and re-runs whenever the store changes (pull patches or mutations). Loading starts `true` and becomes `false` after the first local read.
+
+### 3. Live query — sync + query combined (common case)
+
+Use this when the sync filter and the query filter are the same, or when you want the query to manage its own subscription lifecycle.
+
+```ts
+// client.liveQuery() registers a sync subscription when the first
+// subscriber attaches, and removes it when the last subscriber detaches.
+const notesQuery = client.liveQuery({
+  filter: { isDeleted: false },
+  name: "active-notes",
+});
+
+const unsub = notesQuery.subscribe(({ data, loading }) => {
+  if (loading) return;
+  renderNotes(data);
+});
+
+unsub(); // stops listening AND removes the sync subscription (if last subscriber)
+```
+
+### Pattern: large sync window, narrow display window
+
+```ts
+// Sync 30 days in the background — data lives in local store, not in memory.
+// This runs once at app startup (or in a root component).
+await client.subscribe({
+  filter: { createdAt: { $gte: thirtyDaysAgo } },
+  name: "background-30d",
+});
+
+// In a component: query only today's slice — fast, no extra network request.
+// The data is already in the local store from the background subscription.
+const todayQuery = client.query({ filter: { createdAt: { $gte: startOfToday } } });
+
+todayQuery.subscribe(({ data, loading }) => {
+  renderNotes(data); // instant — no loading spinner needed
+});
+```
+
+---
+
+## The store contract
+
+`SyncQuery<T>` follows the [Svelte store contract](https://svelte.dev/docs/svelte/stores#Store-contract), making it usable directly in Svelte templates, with `useSyncExternalStore` in React, or with any store-aware utility.
+
+```ts
+interface SyncQuery<T extends SyncRecord> {
+  subscribe(
+    run: (value: { data: T[]; loading: boolean }) => void,
+    invalidate?: () => void,
+  ): () => void; // returns unsubscribe
+}
+```
+
+**In Svelte:**
+```svelte
+<script>
+  const notes = client.liveQuery({ filter: { isDeleted: false } });
+</script>
+
+{#if $notes.loading}
+  <p>Loading…</p>
+{:else}
+  {#each $notes.data as note}
+    <NoteCard {note} />
+  {/each}
+{/if}
+```
+
+**In React (proposed `useQuery` hook from `@sync-subscribe/client-react`):**
+```tsx
+const { data, loading } = useQuery(client.query({ filter: { isDeleted: false } }));
+// or the combined version:
+const { data, loading } = useQuery(client.liveQuery({ filter: { isDeleted: false } }));
+```
+
+---
+
+## Subscriptions
+
+`subscribe` registers a filter locally and returns a `ClientSubscription`. The filter is sent to the server on every pull cycle or SSE stream request. Multiple overlapping subscriptions are fine — records are stored only once in the local store.
+
+```ts
+const thirtyDaysAgo = Date.now() - 30 * 24 * 60 * 60 * 1000;
+
+const sub1 = await client.subscribe({ filter: { createdAt: { $gte: thirtyDaysAgo } } });
+const sub2 = await client.subscribe({ filter: { color: "blue" } });
+
+// Both subscriptions are batched into a single pull request.
+// The SSE stream (if transport supports it) is restarted once to include both.
+```
+
+Available filter operators: `$eq`, `$ne`, `$gt`, `$gte`, `$lt`, `$lte`, `$in`, `$nin`, `$exists`, `$or`, `$and`, `$nor`.
+
+### Named subscriptions
+
+Pass `name` to persist and restore subscription state across sessions (requires `IdbLocalStore`):
+
+```ts
+await client.subscribe({ filter: { isDeleted: false }, name: "active-notes" });
+```
+
+On the next session, `subscribe` with the same `name` and same filter reuses the stored `syncToken`, enabling incremental sync instead of a full re-fetch.
+
+### Updating a subscription
+
+```ts
+await client.updateSubscription(sub.subscriptionId, { color: "red" });
+```
+
+The client runs gap and eviction analysis locally: it detects whether any records matching the new filter are not yet cached (gap), fetches them, and evicts records that only the old filter needed.
+
+### Removing a subscription
+
+```ts
+await client.unsubscribe(sub.subscriptionId);
+```
+
+Removes the subscription from the local store and restarts the SSE stream without it. If no subscriptions remain, the stream is stopped.
+
+---
+
+## Mutating records
+
+`mutate` writes the record locally immediately (read-your-own-writes), then pushes to the server. `updatedAt` and `revisionCount` are stamped automatically — do not set them yourself.
+
+Returns `true` on success, `false` if the server detected a conflict (server record wins).
+
+```ts
+// Create — provide recordId and createdAt; mutate() handles the rest
+await client.mutate({
+  recordId: crypto.randomUUID(),
+  createdAt: Date.now(),
+  title: "Hello",
+  contents: "World",
+  isDeleted: false,
+} as NoteRecord);
+
+// Update — just spread and change fields; mutate() increments revisionCount
+await client.mutate({ ...note, contents: "Updated" });
+
+// Soft-delete
+await client.mutate({ ...note, isDeleted: true });
+```
+
+---
+
+## Listening for patches
+
+`onPatches` fires whenever the local store changes from an incoming pull, stream event, or conflict resolution. Returns an unsubscribe function.
+
+```ts
+const unsub = client.onPatches((patches) => {
+  for (const patch of patches) {
+    if (patch.op === "upsert") console.log("upserted", patch.record.recordId);
+    if (patch.op === "delete") console.log("deleted", patch.recordId);
+  }
+});
+
+unsub(); // stop listening
+```
+
+This is the low-level primitive that `query()` and `liveQuery()` build on. Prefer those for UI code.
+
+---
+
+## SSE streaming
+
+If your transport implements `stream`, the client opens a persistent SSE connection automatically when you call `subscribe()`. You do not manage the stream directly — it is started, restarted (when subscriptions change), and stopped (when all subscriptions are removed) internally.
+
+```ts
+// Transport with SSE support
+const transport: SyncTransport = {
+  // pull, push as before...
+
+  stream(subscriptions, onMessage, onError) {
+    const es = new EventSource("/api/sync/stream");
+    es.onmessage = (e) => onMessage(JSON.parse(e.data));
+    es.onerror = (e) => onError?.(new Error("SSE error"));
+    return () => es.close(); // cleanup
+  },
+};
+
+// SSE starts automatically when subscribe() is called.
+// It restarts whenever subscriptions change, debounced 20 ms.
+await client.subscribe({ filter: { isDeleted: false } });
+```
+
+---
+
+## Polling
+
+There is no built-in polling timer. Set one up yourself:
+
+```ts
+const timer = setInterval(async () => {
+  try { await client.pull(); } catch { /* retry next tick */ }
+}, 5000);
+
+clearInterval(timer); // on teardown
+```
+
+---
+
+## Resetting state
+
+Call `reset()` on logout or account switch — it stops the SSE stream, clears all subscriptions, and empties the local store.
+
+```ts
+await client.reset();
+```
+
+---
+
+## API reference
+
+### `SyncClient<T>`
+
+| Method | Returns | Description |
+|---|---|---|
+| `subscribe(options)` | `Promise<ClientSubscription>` | Sync a filter to local store; auto-starts pull + stream |
+| `unsubscribe(id)` | `Promise<void>` | Remove a subscription; restarts stream without it |
+| `updateSubscription(id, filter)` | `Promise<ClientSubscription>` | Replace a subscription's filter; handles gap/eviction |
+| `query(options)` | `SyncQuery<T>` | Reactive local-store query; no sync subscription |
+| `liveQuery(options)` | `SyncQuery<T>` | Reactive query that manages its own sync subscription |
+| `mutate(record)` | `Promise<boolean>` | Write locally + push to server; stamps `updatedAt`/`revisionCount` |
+| `pull()` | `Promise<void>` | Fetch pending patches for all active subscriptions |
+| `schedulePull(delayMs?)` | `Promise<void>` | Debounced pull — collapses rapid calls into one request |
+| `onPatches(listener)` | `() => void` | Low-level patch listener; returns unsubscribe |
+| `getSubscription(key)` | `ClientSubscription \| undefined` | Look up by `subscriptionId` or `name` |
+| `reset()` | `Promise<void>` | Stop stream, clear subscriptions and local store |
+| `store` | `ILocalStore<T>` | Direct access to the local store |
+
+### `SyncQuery<T>` — store contract
+
+```ts
+interface SyncQuery<T extends SyncRecord> {
+  subscribe(
+    run: (value: { data: T[]; loading: boolean }) => void,
+    invalidate?: () => void,
+  ): () => void;
+}
+```
+
+`liveQuery` vs `query`:
+
+| | `query()` | `liveQuery()` |
+|---|---|---|
+| Registers a sync subscription | No | Yes (on first subscriber) |
+| Removes sync subscription on cleanup | No | Yes (on last unsubscribe) |
+| Reads from local store | Yes | Yes |
+| Reacts to pull/stream patches | Yes | Yes |
+| Use when | Data already synced elsewhere | Query filter === sync filter |
+
+### `SyncTransport`
+
+```ts
+interface SyncTransport {
+  pull(subscriptions: { key: string; filter: SubscriptionFilter; syncToken: SyncToken }[]): Promise<{
+    patches: SyncPatch<SyncRecord>[];
+    syncTokens: Record<string, SyncToken>;
+  }>;
+
+  push(records: SyncRecord[]): Promise<
+    | { ok: true; serverUpdatedAt: number }
+    | { conflict: true; serverRecord: SyncRecord }
+  >;
+
+  stream?(
+    subscriptions: { key: string; filter: SubscriptionFilter; syncToken: SyncToken }[],
+    onMessage: (event: { patches: SyncPatch<SyncRecord>[]; syncTokens: Record<string, SyncToken> }) => void,
+    onError?: (err: Error) => void,
+  ): () => void;
+}
+```
+
+### `ILocalStore<T>` — implemented by `LocalStore` and `IdbLocalStore`
+
+| Method | Description |
+|---|---|
+| `getAll()` | Return all records |
+| `getById(recordId)` | Return a single record or `undefined` |
+| `query(filter)` | Return records matching a filter |
+| `applyPatches(patches)` | Apply server patches; returns only patches that changed local state |
+| `write(record)` | Write a record locally (used by `mutate`) |
+| `evict(filter)` | Remove records matching a filter without deleting them from the server |
+| `reconstructSyncToken(filter)` | Build a sync token from the latest locally-cached record matching `filter` |
+| `clear()` | Remove all records |

package/dist/fetchTransport.d.ts

@@ -0,0 +1,27 @@
+import type { SyncTransport } from "./types.js";
+export interface FetchTransportOptions {
+    /** Base URL of the sync server, e.g. "/api" or "https://api.example.com". */
+    baseUrl: string;
+    /**
+     * Called before every request to supply additional headers (e.g. Authorization).
+     * Return an empty object if no extra headers are needed.
+     */
+    headers?: () => Record<string, string>;
+}
+/**
+ * A fetch-based SyncTransport that works in any modern browser.
+ *
+ * Endpoints:
+ *   - pull   →  POST {baseUrl}/sync/pull
+ *   - push   →  POST {baseUrl}/sync/push
+ *   - stream →  POST {baseUrl}/sync/stream  (fetch-based SSE)
+ *
+ * @example
+ * const transport = createFetchTransport({
+ *   baseUrl: "/api",
+ *   headers: () => ({ Authorization: `Bearer ${getToken()}` }),
+ * });
+ * const client = new SyncClient(transport);
+ */
+export declare function createFetchTransport(options: FetchTransportOptions): SyncTransport;
+//# sourceMappingURL=fetchTransport.d.ts.map

package/dist/fetchTransport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetchTransport.d.ts","sourceRoot":"","sources":["../src/fetchTransport.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,aAAa,EAA2B,MAAM,YAAY,CAAC;AAEzE,MAAM,WAAW,qBAAqB;IACpC,6EAA6E;IAC7E,OAAO,EAAE,MAAM,CAAC;IAChB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACxC;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,qBAAqB,GAAG,aAAa,CAiFlF"}

package/dist/fetchTransport.js

@@ -0,0 +1,88 @@
+/**
+ * A fetch-based SyncTransport that works in any modern browser.
+ *
+ * Endpoints:
+ *   - pull   →  POST {baseUrl}/sync/pull
+ *   - push   →  POST {baseUrl}/sync/push
+ *   - stream →  POST {baseUrl}/sync/stream  (fetch-based SSE)
+ *
+ * @example
+ * const transport = createFetchTransport({
+ *   baseUrl: "/api",
+ *   headers: () => ({ Authorization: `Bearer ${getToken()}` }),
+ * });
+ * const client = new SyncClient(transport);
+ */
+export function createFetchTransport(options) {
+    const { baseUrl, headers = () => ({}) } = options;
+    function jsonHeaders() {
+        return { "Content-Type": "application/json", ...headers() };
+    }
+    return {
+        async pull(subscriptions) {
+            const res = await fetch(`${baseUrl}/sync/pull`, {
+                method: "POST",
+                headers: jsonHeaders(),
+                body: JSON.stringify({ subscriptions }),
+            });
+            if (!res.ok)
+                throw new Error(`Pull failed: ${res.status}`);
+            return res.json();
+        },
+        async push(records) {
+            const res = await fetch(`${baseUrl}/sync/push`, {
+                method: "POST",
+                headers: jsonHeaders(),
+                body: JSON.stringify({ records }),
+            });
+            if (!res.ok)
+                throw new Error(`Push failed: ${res.status}`);
+            return res.json();
+        },
+        stream(subscriptions, onMessage, onError) {
+            const controller = new AbortController();
+            fetch(`${baseUrl}/sync/stream`, {
+                method: "POST",
+                headers: jsonHeaders(),
+                body: JSON.stringify({ subscriptions }),
+                signal: controller.signal,
+            }).then(async (res) => {
+                if (!res.ok) {
+                    onError?.(new Error(`Stream failed: ${res.status}`));
+                    return;
+                }
+                if (!res.body) {
+                    onError?.(new Error("No response body"));
+                    return;
+                }
+                const reader = res.body.getReader();
+                const decoder = new TextDecoder();
+                let buffer = "";
+                while (true) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    buffer += decoder.decode(value, { stream: true });
+                    const lines = buffer.split("\n");
+                    buffer = lines.pop() ?? "";
+                    for (const line of lines) {
+                        if (line.startsWith("data: ")) {
+                            try {
+                                onMessage(JSON.parse(line.slice(6)));
+                            }
+                            catch (err) {
+                                onError?.(err instanceof Error ? err : new Error(String(err)));
+                            }
+                        }
+                    }
+                }
+            }).catch((err) => {
+                if (err?.name !== "AbortError") {
+                    onError?.(err instanceof Error ? err : new Error(String(err)));
+                }
+            });
+            return () => controller.abort();
+        },
+    };
+}
+//# sourceMappingURL=fetchTransport.js.map

package/dist/fetchTransport.js.map

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

package/dist/idbLocalStore.d.ts

@@ -0,0 +1,45 @@
+import type { SyncRecord, SyncPatch, SyncToken, SubscriptionFilter } from "@sync-subscribe/core";
+import type { ILocalStore, PersistedSubscription } from "./types.js";
+/**
+ * IndexedDB-backed local store. Records survive page reloads.
+ *
+ * Pass a unique `dbName` per logical collection (or per user if you need
+ * data isolation on the same origin).
+ *
+ * Usage:
+ *   const store = new IdbLocalStore<NoteRecord>("notes-db");
+ *   const client = new SyncClient(transport, store);
+ */
+export declare class IdbLocalStore<T extends SyncRecord> implements ILocalStore<T> {
+    private readonly dbName;
+    private readonly storeName;
+    private db;
+    constructor(dbName: string, storeName?: string);
+    private getDb;
+    /**
+     * Apply a batch of patches inside a single readwrite transaction.
+     * Copies `record.updatedAt` into `record.serverUpdatedAt` on upsert (server clock is authoritative).
+     * Conflict resolution mirrors InMemoryStore: server patch wins only when its
+     * revisionCount is higher (or equal with an older updatedAt).
+     */
+    applyPatches(patches: SyncPatch<T>[]): Promise<SyncPatch<T>[]>;
+    write(record: T): Promise<void>;
+    getAll(): Promise<T[]>;
+    query(filter: SubscriptionFilter): Promise<T[]>;
+    count(filter: SubscriptionFilter): Promise<number>;
+    getById(recordId: string): Promise<T | undefined>;
+    clear(): Promise<void>;
+    delete(filter: SubscriptionFilter): Promise<void>;
+    evict(evictFilter: SubscriptionFilter): Promise<void>;
+    reconstructSyncToken(filter: SubscriptionFilter<T>): Promise<SyncToken>;
+    setServerUpdatedAt(recordId: string, serverUpdatedAt: number): Promise<void>;
+    setSyncToken(subscriptionId: string, token: SyncToken): Promise<void>;
+    getSyncToken(subscriptionId: string): Promise<SyncToken | undefined>;
+    setSubscription(name: string, sub: PersistedSubscription): Promise<void>;
+    getSubscription(name: string): Promise<PersistedSubscription | undefined>;
+    getSubscriptionById(id: string): Promise<PersistedSubscription | undefined>;
+    listSubscriptions(): Promise<PersistedSubscription[]>;
+    removeSubscription(name: string): Promise<void>;
+    clearSubscriptions(): Promise<void>;
+}
+//# sourceMappingURL=idbLocalStore.d.ts.map

package/dist/idbLocalStore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"idbLocalStore.d.ts","sourceRoot":"","sources":["../src/idbLocalStore.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,UAAU,EACV,SAAS,EACT,SAAS,EACT,kBAAkB,EACnB,MAAM,sBAAsB,CAAC;AAO9B,OAAO,KAAK,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAErE;;;;;;;;;GASG;AACH,qBAAa,aAAa,CAAC,CAAC,SAAS,UAAU,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAItE,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,SAAS;IAJ5B,OAAO,CAAC,EAAE,CAA4B;gBAGnB,MAAM,EAAE,MAAM,EACd,SAAS,GAAE,MAAkB;IAGhD,OAAO,CAAC,KAAK;IAyBb;;;;;OAKG;IACG,YAAY,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,EAAE,CAAC;IAgD9D,KAAK,CAAC,MAAM,EAAE,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC;IAW/B,MAAM,IAAI,OAAO,CAAC,CAAC,EAAE,CAAC;IAWtB,KAAK,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAO/C,KAAK,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,MAAM,CAAC;IAIlD,OAAO,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,SAAS,CAAC;IAWjD,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAWtB,MAAM,CAAC,MAAM,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IA4BjD,KAAK,CAAC,WAAW,EAAE,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC;IAIrD,oBAAoB,CACxB,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAAC,GAC5B,OAAO,CAAC,SAAS,CAAC;IA8Bf,kBAAkB,CACtB,QAAQ,EAAE,MAAM,EAChB,eAAe,EAAE,MAAM,GACtB,OAAO,CAAC,IAAI,CAAC;IAOV,YAAY,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,GAAG,OAAO,CAAC,IAAI,CAAC;IAUrE,YAAY,CAAC,cAAc,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,SAAS,CAAC;IAUpE,eAAe,CACnB,IAAI,EAAE,MAAM,EACZ,GAAG,EAAE,qBAAqB,GACzB,OAAO,CAAC,IAAI,CAAC;IAgBV,eAAe,CACnB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC;IAWvC,mBAAmB,CACvB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC,qBAAqB,GAAG,SAAS,CAAC;IAKvC,iBAAiB,IAAI,OAAO,CAAC,qBAAqB,EAAE,CAAC;IAuBrD,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAU/C,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;CAS1C"}