@thomasfosterau/legation 0.0.0 → 0.1.0

package/dist/internal.d.ts

@@ -0,0 +1,3 @@
+import { Ct as Subset_d_exports, E as Coverage_d_exports, Et as CollectionIndex_d_exports, K as RowChange_d_exports, N as ClientEngine_d_exports, Y as MutationState_d_exports, _ as MirrorChannel_d_exports, ft as Protocol_d_exports, i as SyncServer_d_exports, j as Related_d_exports, l as Cvr_d_exports, s as InvalidationBus_d_exports, w as ClientView_d_exports } from "./MemoryBackend-BziXwfcs.js";
+import { A as AtomicKeyValue_d_exports, C as Subscriptions_d_exports, D as Introspection_d_exports, E as OrderedTree_d_exports, M as RpcTransport_d_exports, N as UnknownMutator_d_exports, O as Paced_d_exports, P as Hash_d_exports, S as Derive_d_exports, T as LiveView_d_exports, _ as MirrorProtocol_d_exports, a as BusBrokers_d_exports, b as LiveQuery_d_exports, c as FanoutTopics_d_exports, d as HttpCache_d_exports, f as FilterCorpus_d_exports, g as EngineHost_d_exports, h as Mirror_d_exports, i as HintSource_d_exports, j as SpecExport_d_exports, k as Undo_d_exports, l as PushPoke_d_exports, m as BackendContract_d_exports, n as SyncRoom_d_exports, o as FanoutBus_d_exports, p as RejectionMemory_d_exports, s as FanoutBroker_d_exports, t as Telemetry_d_exports, u as InvalidationSink_d_exports, v as PromiseFacade_d_exports, w as Incremental_d_exports, x as FractionalIndex_d_exports, y as EngineAtoms_d_exports } from "./internal-CxXRlFK9.js";
+export { AtomicKeyValue_d_exports as AtomicKeyValue, BackendContract_d_exports as BackendContract, BusBrokers_d_exports as BusBrokers, ClientEngine_d_exports as ClientEngine, ClientView_d_exports as ClientView, CollectionIndex_d_exports as CollectionIndex, Coverage_d_exports as Coverage, Cvr_d_exports as Cvr, Derive_d_exports as Derive, EngineAtoms_d_exports as EngineAtoms, EngineHost_d_exports as EngineHost, FanoutBroker_d_exports as FanoutBroker, FanoutBus_d_exports as FanoutBus, FanoutTopics_d_exports as FanoutTopics, FilterCorpus_d_exports as FilterCorpus, FractionalIndex_d_exports as FractionalIndex, Hash_d_exports as Hash, HintSource_d_exports as HintSource, HttpCache_d_exports as HttpCache, Incremental_d_exports as Incremental, Introspection_d_exports as Introspection, InvalidationBus_d_exports as InvalidationBus, InvalidationSink_d_exports as InvalidationSink, LiveQuery_d_exports as LiveQuery, LiveView_d_exports as LiveView, Mirror_d_exports as Mirror, MirrorChannel_d_exports as MirrorChannel, MirrorProtocol_d_exports as MirrorProtocol, MutationState_d_exports as MutationState, OrderedTree_d_exports as OrderedTree, Paced_d_exports as Paced, PromiseFacade_d_exports as PromiseFacade, Protocol_d_exports as Protocol, PushPoke_d_exports as PushPoke, RejectionMemory_d_exports as RejectionMemory, Related_d_exports as Related, RowChange_d_exports as RowChange, RpcTransport_d_exports as RpcTransport, SpecExport_d_exports as SpecExport, Subscriptions_d_exports as Subscriptions, Subset_d_exports as Subset, SyncRoom_d_exports as SyncRoom, SyncServer_d_exports as SyncServer, Telemetry_d_exports as Telemetry, Undo_d_exports as Undo, UnknownMutator_d_exports as UnknownMutator };

package/dist/internal.js

@@ -0,0 +1,3 @@
+import { A as Subscriptions_exports, E as Mirror_exports, H as MirrorProtocol_exports, Jt as Related_exports, N as Coverage_exports, O as ClientView_exports, Ot as Protocol_exports, Pt as AtomicKeyValue_exports, Q as ClientEngine_exports, Qt as Subset_exports, Y as RpcTransport_exports, c as InvalidationBus_exports, ct as MutationState_exports, f as Cvr_exports, gt as Hash_exports, ht as FractionalIndex_exports, i as SyncServer_exports, lt as LiveView_exports, mt as OrderedTree_exports, ot as Telemetry_exports, rn as CollectionIndex_exports, st as RowChange_exports, v as UnknownMutator_exports, x as RejectionMemory_exports } from "./MemoryBackend-DxP8t4ge.js";
+import { S as SpecExport_exports, _ as Derive_exports, a as FanoutBus_exports, b as Paced_exports, c as PushPoke_exports, d as FilterCorpus_exports, f as EngineHost_exports, g as LiveQuery_exports, h as EngineAtoms_exports, i as BusBrokers_exports, l as InvalidationSink_exports, m as PromiseFacade_exports, n as SyncRoom_exports, o as FanoutBroker_exports, p as MirrorChannel_exports, r as HintSource_exports, s as FanoutTopics_exports, t as HttpCache_exports, u as BackendContract_exports, v as Incremental_exports, x as Undo_exports, y as Introspection_exports } from "./internal-JyoQMlfK.js";
+export { AtomicKeyValue_exports as AtomicKeyValue, BackendContract_exports as BackendContract, BusBrokers_exports as BusBrokers, ClientEngine_exports as ClientEngine, ClientView_exports as ClientView, CollectionIndex_exports as CollectionIndex, Coverage_exports as Coverage, Cvr_exports as Cvr, Derive_exports as Derive, EngineAtoms_exports as EngineAtoms, EngineHost_exports as EngineHost, FanoutBroker_exports as FanoutBroker, FanoutBus_exports as FanoutBus, FanoutTopics_exports as FanoutTopics, FilterCorpus_exports as FilterCorpus, FractionalIndex_exports as FractionalIndex, Hash_exports as Hash, HintSource_exports as HintSource, HttpCache_exports as HttpCache, Incremental_exports as Incremental, Introspection_exports as Introspection, InvalidationBus_exports as InvalidationBus, InvalidationSink_exports as InvalidationSink, LiveQuery_exports as LiveQuery, LiveView_exports as LiveView, Mirror_exports as Mirror, MirrorChannel_exports as MirrorChannel, MirrorProtocol_exports as MirrorProtocol, MutationState_exports as MutationState, OrderedTree_exports as OrderedTree, Paced_exports as Paced, PromiseFacade_exports as PromiseFacade, Protocol_exports as Protocol, PushPoke_exports as PushPoke, RejectionMemory_exports as RejectionMemory, Related_exports as Related, RowChange_exports as RowChange, RpcTransport_exports as RpcTransport, SpecExport_exports as SpecExport, Subscriptions_exports as Subscriptions, Subset_exports as Subset, SyncRoom_exports as SyncRoom, SyncServer_exports as SyncServer, Telemetry_exports as Telemetry, Undo_exports as Undo, UnknownMutator_exports as UnknownMutator };

package/dist/rolldown-runtime-D8jQpDG7.js

@@ -0,0 +1,12 @@
+// \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+export { __exportAll as t };

package/dist/sql/index.d.ts

@@ -0,0 +1,294 @@
+import { It as MutationRejected, Mt as BackendError, Ot as LiteralKind, X as AnyMutator, gt as AnyCollection, kt as Predicate, lt as ChangeHint, st as Backend, ut as SyncContext } from "../MemoryBackend-BziXwfcs.js";
+import "../index-CPPfp0F4.js";
+import { r as HintSource } from "../internal-CxXRlFK9.js";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+import * as Duration from "effect/Duration";
+import { SqlClient } from "effect/sql/SqlClient";
+declare namespace Sql_d_exports {
+  export { CompileOptions, Dialect, Kinds, SqlFragment, UnionRows, compileSelect, compileWhere, postgres, sqlite };
+}
+/** A SQL fragment plus its ordered bind parameters. */
+interface SqlFragment {
+  readonly text: string;
+  readonly params: ReadonlyArray<unknown>;
+}
+/** Placeholder, identifier-quoting, collation and boolean rules for a SQL dialect. */
+interface Dialect {
+  /** Bind placeholder for the 1-based parameter index. */
+  readonly placeholder: (index: number) => string;
+  /** Quote a column/table identifier. */
+  readonly quote: (identifier: string) => string;
+  /** The code-point collation name, emitted as `COLLATE <name>` after a declared-text operand. */
+  readonly textCollation: string;
+  /** How a boolean literal binds (Postgres has booleans; SQLite stores `0`/`1`). */
+  readonly boolean: (value: boolean) => unknown;
+  /** The larger of two SQL expressions: `MAX` on SQLite, `GREATEST` on PostgreSQL. */
+  readonly greatest: (left: string, right: string) => string;
+  /**
+   * The statement that makes the transaction it runs in SERIALIZABLE, run first
+   * in each `applyMutations` transaction (#353). It must be the transaction's first
+   * statement in a top-level transaction: a nested one refuses it, and the batch
+   * then fails. Absent on a dialect whose writers already serialise (SQLite takes
+   * its write lock with `BEGIN IMMEDIATE`); a hand-written dialect without it gets
+   * no isolation statement, so its executor must provide the isolation itself.
+   */
+  readonly serializable?: string | undefined;
+  /**
+   * How each arm of `SqlBackend.evaluateMany`'s one `UNION ALL` statement
+   * carries its row (#505), since mappings' columns differ per collection.
+   * Absent on a hand-written dialect, `evaluateMany` is too, and a pull
+   * evaluates its subsets one statement each. See {@link UnionRows}.
+   */
+  readonly unionRows?: UnionRows | undefined;
+}
+/**
+ * How a `UNION ALL` arm carries a row whose columns differ from the other
+ * arms' (`Dialect.unionRows`, #505):
+ *
+ * - `Columns`: the relation's own columns by position, padded with `NULL` to
+ *   the widest arm. Only for a database whose `UNION ALL` columns take any
+ *   type per row (SQLite): each value then reaches the driver as `SELECT *`
+ *   would give it. `columnsOf` lists a relation's columns, one row per column
+ *   with its name in a `name` column.
+ * - `Json`: one column of JSON text, `rowJson(alias)` for the row aliased
+ *   `alias` (PostgreSQL's `row_to_json`). JSON carries text, booleans, `NULL`
+ *   and numbers that fit a double as the driver does; other column types reach
+ *   the backend as JSON gives them.
+ */
+type UnionRows = {
+  readonly _tag: "Columns";
+  readonly columnsOf: (relation: string) => SqlFragment;
+} | {
+  readonly _tag: "Json";
+  readonly rowJson: (alias: string) => string;
+};
+/** Field → literal kind, for the collation clause and typed binds. */
+type Kinds = Readonly<Record<string, LiteralKind>>;
+/** Options shared by {@link compileWhere} and {@link compileSelect}. */
+interface CompileOptions {
+  /** Declared literal kinds of the predicate's own fields (see the module doc). */
+  readonly kinds?: Kinds | undefined;
+  /** Declared kinds of other collections' fields, keyed by collection, for the inner `where` of an `Exists`. */
+  readonly foreignKinds?: Readonly<Record<string, Kinds>> | undefined;
+}
+/**
+ * SQLite: `?` placeholders, `COLLATE BINARY`, booleans as `0`/`1`, a `UNION
+ * ALL` arm's row as its own columns by position (`pragma_table_info`).
+ */
+declare const sqlite: Dialect;
+/**
+ * PostgreSQL: `$1`, `$2`, … placeholders, `COLLATE "C"`, native booleans,
+ * SERIALIZABLE transactions, a `UNION ALL` arm's row as JSON (`row_to_json`).
+ */
+declare const postgres: Dialect;
+/**
+ * Compile a predicate into a `WHERE`-ready fragment for a dialect. Pass
+ * `options.kinds` (field → literal kind) so declared-text fields get their
+ * collation clause and literals bind by the declared kind; without a
+ * declaration nothing collates and a literal binds as its JS type (see the
+ * module doc).
+ */
+declare const compileWhere: (predicate: Predicate, dialect?: Dialect, options?: CompileOptions) => SqlFragment;
+/**
+ * Compile a `SELECT * FROM <table> WHERE <predicate>` for a subset. The
+ * `WHERE` is exact (see the module doc). Order, limit and cursor are not
+ * pushed down: this statement may later grow an `ORDER BY … LIMIT` for
+ * backends that want it, but today the backend's `Subset.apply` finalises
+ * them locally, so this stays a single, safe statement.
+ */
+declare const compileSelect: (options: {
+  readonly table: string;
+  readonly where: Predicate;
+  readonly dialect?: Dialect;
+} & CompileOptions) => SqlFragment;
+declare namespace SqlBackend_d_exports {
+  export { InexactJsonNumber, SqlBackendConfig, SqlExecutor, SqlHandler, SqlRow, TableMapping, fromCollection, make$2 as make, versionOf };
+}
+/** A row as returned by the driver: a column → value record. */
+type SqlRow = Record<string, unknown>;
+/**
+ * The minimal database surface the backend needs.
+ *
+ * **Isolation (guarantee 1, #353):** `transaction` must run its effect as one
+ * database transaction whose reads a concurrent transaction cannot change under
+ * them before it commits, so a handler never writes from a stale read. That is
+ * SERIALIZABLE isolation, or an equivalent check, and the reference executors
+ * meet it: SQLite serialises writers (`BEGIN IMMEDIATE`), and the PostgreSQL
+ * dialect's `serializable` statement sets SERIALIZABLE on each transaction. On
+ * PostgreSQL that transaction must be top-level, not a nested one run as a
+ * savepoint: the statement is refused there, and `applyMutations` fails with a
+ * `BackendError`. An executor whose database cannot do this does not conform. A
+ * serialization failure (PostgreSQL SQLSTATE 40001 or 40P01) must surface as a
+ * `BackendError`, so the client retries the batch; the D1 executor does not meet
+ * the requirement (`transactional: false`, #342).
+ */
+interface SqlExecutor {
+  /** Run a query and return its rows. */
+  readonly query: (fragment: SqlFragment) => Effect.Effect<ReadonlyArray<SqlRow>, BackendError>;
+  /** Run a statement for its effect (insert/update/delete). */
+  readonly run: (fragment: SqlFragment) => Effect.Effect<void, BackendError>;
+  /**
+   * Run an effect inside a transaction (atomic commit / rollback on error). On
+   * PostgreSQL it must open a top-level transaction, not a savepoint nested in
+   * another one, so SERIALIZABLE can be set first (see the `dialect` option of
+   * `SqlBackendConfig`).
+   */
+  readonly transaction: <A, R>(effect: Effect.Effect<A, BackendError, R>) => Effect.Effect<A, BackendError, R>;
+  /**
+   * Whether `transaction` commits and rolls back atomically; defaults to `true`.
+   *
+   * Set `false` on an executor without transactions (D1). `applyMutations` then
+   * bumps each id after its handler instead of claiming it first, because a
+   * claim committed on its own would be skipped by a retry after a crash.
+   */
+  readonly transactional?: boolean | undefined;
+}
+/** How a collection maps onto a table. */
+interface TableMapping {
+  /** The write target: what mutator handlers address. Also the read default. */
+  readonly table: string;
+  /**
+   * The relation reads evaluate against, when it differs from `table`
+   * (issue #204) — typically a view joining a root version table to a leaf
+   * at its current version. Read-only: `SqlBackend` never writes rows
+   * itself, only the mutation-id ledger, so nothing here needs `table` to be
+   * writable. Defaults to `table`.
+   */
+  readonly readRelation?: string;
+  /** Primary-key column. Defaults to `"id"`. */
+  readonly idColumn?: string;
+  /** Column holding the row version; if absent, a content hash is used. */
+  readonly versionColumn?: string;
+  /**
+   * Declared literal kinds of the filterable columns (field → kind), passed
+   * to the `Sql` compiler: a column declared `text` gets the code-point
+   * collation clause (the clause needs the declaration; a string literal
+   * alone never collates), `instant` columns do not, literals bind by the
+   * declared kind, and `boolean` columns bind and decode as the dialect
+   * stores them (`0`/`1` on SQLite). A column without a kind compiles to a
+   * plain comparison with the literal bound as its JS type (see `Sql`). See
+   * {@link fromCollection} to derive this instead of writing it by hand.
+   */
+  readonly kinds?: Kinds;
+  /**
+   * A row matching this predicate is a tombstone, not a live row (issue
+   * #204): `evaluate` drops it from the entries it returns, so it is simply
+   * absent from the next CVR view and diffs as a delete, the same as a row
+   * that vanished from the relation outright. Expressed in the engine's own
+   * `Predicate` vocabulary (evaluated with `Predicate.test`) rather than a
+   * bespoke shape, so it composes with everything else that already
+   * understands a `Predicate` (the `Sql` compiler, the differential
+   * harness). Typically an `IsNull`/`eq` test on a soft-delete column
+   * (`Predicate.isNotNull("deletedAt")`'s negation, an `action` enum check).
+   */
+  readonly tombstone?: Predicate;
+}
+/**
+ * Derive a `TableMapping` from a `Collection`: column kinds come from its
+ * declared filterable set (`Collection.filterDeclarationOf`, #154) instead of
+ * being restated by hand — the common case. `table`, and optionally
+ * `readRelation` / `idColumn` / `versionColumn` / `tombstone`, are still
+ * given explicitly; the hand-written record shape (this function's return
+ * type) remains the override path for a mapping derivation can't cover.
+ */
+declare const fromCollection: (collection: AnyCollection, options: {
+  readonly table: string;
+  readonly readRelation?: string;
+  readonly idColumn?: string;
+  readonly versionColumn?: string;
+  readonly tombstone?: Predicate;
+}) => TableMapping;
+/**
+ * An app-authored write, running its own SQL inside the push transaction. Fail
+ * with `BackendError` for a transient error (aborts the whole push) or
+ * `MutationRejected` for a permanent one (this mutation's writes are rolled back
+ * to a savepoint, its id still bumped, the batch continues).
+ */
+type SqlHandler = (args: unknown, tx: SqlExecutor, context: SyncContext) => Effect.Effect<ReadonlyArray<ChangeHint>, BackendError | MutationRejected>;
+/** Configuration for {@link make}. */
+interface SqlBackendConfig {
+  readonly executor: SqlExecutor;
+  readonly tables: Readonly<Record<string, TableMapping>>;
+  /** Mutator definitions, for decoding/validating pushed args. */
+  readonly mutators: ReadonlyMap<string, AnyMutator>;
+  readonly handlers: Readonly<Record<string, SqlHandler>>;
+  /**
+   * The SQL dialect. Defaults to SQLite (`Sql.sqlite`). A PostgreSQL app must pass
+   * `Sql.postgres`: that sets SERIALIZABLE on each transaction, and omitting it runs
+   * the batches at READ COMMITTED with no error. A hand-written dialect without a
+   * `serializable` statement gets no isolation statement, so its executor must
+   * provide the isolation itself (see {@link SqlExecutor}).
+   */
+  readonly dialect?: Dialect | undefined;
+  /**
+   * Per-client mutation-id ledger table. Defaults to `"sync_mutations"`. It must
+   * have the `rejections` column that #366 added: an older table fails the push
+   * with a `BackendError` naming the migration (see the sql README).
+   */
+  readonly mutationsTable?: string;
+}
+declare const InexactJsonNumber_base: Schema.Class<InexactJsonNumber, Schema.TaggedStruct<"InexactJsonNumber", {
+  readonly message: Schema.String;
+  /** The collection whose read relation holds the column. */
+  readonly collection: Schema.String;
+  /** The read relation's column the number sits in (top-level key of the row's JSON). */
+  readonly column: Schema.String;
+}>, import("effect/Cause").YieldableError & {
+  readonly brand: unique symbol;
+}>;
+/**
+ * Why a pull fell back from its batched statement to one `evaluate` per
+ * subset: a number in a JSON row (PostgreSQL's `row_to_json`) that JSON
+ * cannot carry exactly (#505). `JSON.parse` reads every JSON number as a
+ * double, so one with more significant digits than a double holds (a `bigint`
+ * past ±(2^53 − 1), a `numeric` of high precision, such a number inside a
+ * `json` / `jsonb` column) would read back as a different value than the
+ * database holds, and an integer past ±(2^53 − 1) is read by the driver as
+ * text, not a number. `evaluateMany` then answers the pull with `evaluate`
+ * per subset, whose values are the driver's, and logs this once per
+ * collection and column at `Warning` level, as the log's cause: declare the
+ * column `integer`, `double precision` or `text` in the read relation (a view
+ * can cast it) so the pull stays one statement.
+ *
+ * Logged, never raised: the pull still succeeds.
+ */
+declare class InexactJsonNumber extends InexactJsonNumber_base {}
+/** Content-hash fallback version when no version column is mapped. */
+declare const versionOf: (value: unknown) => string;
+/**
+ * A {@link Backend.Backend} over a {@link SqlExecutor}: subset evaluation, row fetch and the
+ * transactional, idempotent mutation-id ledger.
+ */
+declare const make$2: (config: SqlBackendConfig) => Backend;
+declare namespace PollingHintSource_d_exports {
+  export { PollingHintSourceConfig, make$1 as make };
+}
+/** Configuration for {@link make}. */
+interface PollingHintSourceConfig {
+  readonly executor: SqlExecutor;
+  /** Collection → table mapping (the `SqlBackend` mapping, reused). */
+  readonly tables: Readonly<Record<string, TableMapping>>;
+  /** Poll cadence — the bounded staleness of an out-of-band write. */
+  readonly interval: Duration.Input;
+  /** Collections to poll. Defaults to every key of `tables`. */
+  readonly collections?: ReadonlyArray<string>;
+}
+/**
+ * A `HintSource` that polls each mapped table for a cheap change detector and publishes a hint
+ * when a collection changes out of band.
+ */
+declare const make$1: (config: PollingHintSourceConfig) => HintSource;
+declare namespace PgExecutor_d_exports {
+  export { make };
+}
+/**
+ * The executor over `sql`: unprepared statements, and a real transaction per `transaction` call.
+ *
+ * A failed statement or transaction fails as a `BackendError` that carries the driver's `SqlError`
+ * as its `cause` (a serialization refusal included), with the statement text, never its parameters,
+ * in the message.
+ */
+declare const make: (sql: SqlClient) => SqlExecutor;
+export { PgExecutor_d_exports as PgExecutor, PollingHintSource_d_exports as PollingHintSource, Sql_d_exports as Sql, SqlBackend_d_exports as SqlBackend };
+//# sourceMappingURL=index.d.ts.map

package/dist/sql/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["Predicate.LiteralKind","Predicate.Predicate","Sql.SqlFragment","Sql.Kinds","Predicate.Predicate","Collection.AnyCollection","Backend.SyncContext","Backend.ChangeHint","Mutator.AnyMutator","Sql.Dialect","make","Backend.Backend","SqlBackend.SqlExecutor","SqlBackend.TableMapping","make","HintSource.HintSource","SqlBackend.SqlExecutor"],"sources":["../../src/sql/Sql.ts","../../src/sql/SqlBackend.ts","../../src/sql/PollingHintSource.ts","../../src/sql/PgExecutor.ts"],"mappings":";;;;;;;;;;;UAuEiB;WACN;WACA,QAAQ;;;UAIF;;WAEN,cAAc;;WAEd,QAAQ;;WAER;;WAEA,UAAU;;WAEV,WAAW,cAAc;;;;;;;;;WASzB;;;;;;;WAOA,YAAY;;;;;;;;;;;;;;;;KAiBX;WAEG;WACA,YAAY,qBAAqB;;WAGjC;WACA,UAAU;;;KAIb,QAAQ,SAAS,eAAeA;;UAG3B;;WAEN,QAAQ;;WAER,eAAe,SAAS,eAAe;;;;;;cASrC,QAAQ;;;;;cAmBR,UAAU;;;;;;;;cAqJV,eACX,WAAWC,WACX,UAAS,SACT,UAAS,mBACR;;;;;;;;cAkBU,gBACX;WACW;WACA,OAAOA;WACP,UAAU;IACjB,mBACH;;;;;KCzJS,SAAS;;;;;;;;;;;;;;;;;UAkBJ;;WAEN,QAAQ,UAAUC,gBAAoB,OAAO,OAAO,cAAc,SAAS;;WAE3E,MAAM,UAAUA,gBAAoB,OAAO,aAAa;;;;;;;WAOxD,cAAc,GAAG,GACxB,QAAQ,OAAO,OAAO,GAAG,cAAc,OACpC,OAAO,OAAO,GAAG,cAAc;;;;;;;;WAQ3B;;;UAIM;;WAEN;;;;;;;;WAQA;;WAEA;;WAEA;;;;;;;;;;;WAWA,QAAQC;;;;;;;;;;;;WAYR,YAAYC;;;;;;;;;;cAWV,iBACX,YAAYC,eACZ;WACW;WACA;WACA;WACA;WACA,YAAYD;MAEtB;;;;;;;KAcS,cACV,eACA,IAAI,aACJ,SAASE,gBACN,OAAO,OAAO,cAAcC,aAAqB,eAAe;;UAGpD;WACN,UAAU;WACV,QAAQ,SAAS,eAAe;;WAEhC,UAAU,oBAAoBC;WAC9B,UAAU,SAAS,eAAe;;;;;;;;WAQlC,UAAUC;;;;;;WAMV;;;;;;;;;WA8CS;;;;;;;;;;;;;;;;;;cAFP,0BAA0B;;cAgF1B,YAAS;;;;;cAYTC,SAAQ,QAAQ,qBAAmBC;;;;;UC5a/B;WACN,UAAUC;;WAEV,QAAQ,SAAS,eAAeC;;WAEhC,UAAU,SAAS;;WAEnB,cAAc;;;;;;cAgCZC,SAAQ,QAAQ,4BAA0BC;;;;;;;;;;;cCtB1C,OAAQ,KAAK,cAAYC"}