@dialecte/core 0.7.0 → 0.8.0

package/dist/store/sqlite/adapter/sqlite-worker-connector.types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-worker-connector.types.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/adapter/sqlite-worker-connector.types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,0BAA0B,CAAA;AACpE,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAE/E,gHAAgH;AAChH,MAAM,MAAM,2BAA2B,GAAG,IAAI,CAC7C,qBAAqB,CAAC,oBAAoB,CAAC,EAC3C,UAAU,CACV,GACA,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC,CAAA"}

package/dist/store/sqlite/engine/blobs.d.ts

@@ -0,0 +1,55 @@
+import { BlobRecord } from '../../../types';
+import { Database } from '@sqlite.org/sqlite-wasm';
+/**
+ * The blobs of a project on the file: each entry in the blob registry (by id, with its owner document,
+ * the entry as JSON), its bytes and their type apart, so a list never reads bytes. Writes run in the
+ * caller's transaction.
+ */
+/** A blob written whole: its entry (already checked as JSON values) and its bytes, over any of that id. */
+export declare function writeBlob(params: {
+    db: Database;
+    entry: BlobRecord;
+    type: string;
+    bytes: Uint8Array;
+}): void;
+/** A blob's entry and its bytes with their type; none for an unknown id. */
+export declare function readBlob(params: {
+    db: Database;
+    blobId: string;
+}): {
+    entry: BlobRecord;
+    type: string;
+    bytes: Uint8Array;
+} | undefined;
+/** A blob's entry alone; none for an unknown id. */
+export declare function readBlobEntry(params: {
+    db: Database;
+    blobId: string;
+}): BlobRecord | undefined;
+/** A blob's entry written over, its bytes kept. */
+export declare function writeBlobEntry(params: {
+    db: Database;
+    entry: BlobRecord;
+}): void;
+/**
+ * The entries a filter of their references keeps, in id order: attached to the document (`documentId`),
+ * to the record of it (`recordRef` too), or to nothing (`standalone`).
+ */
+export declare function readBlobEntries(params: {
+    db: Database;
+    filter: {
+        documentId: string;
+        recordRef?: string;
+    } | 'standalone';
+}): BlobRecord[];
+/** A blob gone, entry and bytes; an unknown id is ignored. */
+export declare function deleteBlob(params: {
+    db: Database;
+    blobId: string;
+}): void;
+/** The blobs a document owns gone, entries and bytes; the blobs only attached to it stay. */
+export declare function deleteBlobsOf(params: {
+    db: Database;
+    documentId: string;
+}): void;
+//# sourceMappingURL=blobs.d.ts.map

package/dist/store/sqlite/engine/blobs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobs.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/blobs.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAA;AACzC,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD;;;;GAIG;AAEH,2GAA2G;AAC3G,wBAAgB,SAAS,CAAC,MAAM,EAAE;IACjC,EAAE,EAAE,QAAQ,CAAA;IACZ,KAAK,EAAE,UAAU,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,UAAU,CAAA;CACjB,GAAG,IAAI,CAUP;AAED,4EAA4E;AAC5E,wBAAgB,QAAQ,CAAC,MAAM,EAAE;IAChC,EAAE,EAAE,QAAQ,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;CACd,GAAG;IAAE,KAAK,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAAG,SAAS,CAarE;AAED,oDAAoD;AACpD,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,UAAU,GAAG,SAAS,CAI9F;AAED,mDAAmD;AACnD,wBAAgB,cAAc,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,KAAK,EAAE,UAAU,CAAA;CAAE,GAAG,IAAI,CAMhF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE;IACvC,EAAE,EAAE,QAAQ,CAAA;IACZ,MAAM,EAAE;QAAE,UAAU,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAA;KAAE,GAAG,YAAY,CAAA;CACjE,GAAG,UAAU,EAAE,CAaf;AAED,8DAA8D;AAC9D,wBAAgB,UAAU,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAIzE;AAED,6FAA6F;AAC7F,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,EAAE,EAAE,QAAQ,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAOhF"}

package/dist/store/sqlite/engine/bulk-insert.d.ts

@@ -0,0 +1,31 @@
+import { EncodedRows, LeadColumns, RecordSinkParams } from './engine.types';
+import { AnyRawRecord } from '../../../types';
+import { Database } from '@sqlite.org/sqlite-wasm';
+/**
+ * Records a caller hands a write (its creates, a commit's updates) encoded: a value that is not JSON
+ * refuses the whole write with `STORE_VALUE_NOT_JSON` (whole records, as every store checks them).
+ */
+export declare function encodeCheckedRecords(params: {
+    records: AnyRawRecord[];
+}): EncodedRows;
+/** The records as rows, in batches of one bind each: records already checked as JSON. */
+export declare function encodeRecords(params: {
+    records: AnyRawRecord[];
+}): EncodedRows;
+/**
+ * The encoded rows into a table of record rows: one JSON1 `INSERT ... SELECT` per batch. `lead` gives
+ * columns of the same value on every row, written before the record's (a history row's entry and
+ * part); such rows are written in the order given.
+ */
+export declare function insertEncodedRows(params: {
+    db: Database;
+    table: string;
+    rows: EncodedRows;
+    lead?: LeadColumns;
+}): void;
+/**
+ * The row sink: one bind of records into a document table, in the caller's transaction - encoded
+ * (timed as `import::encode`), inserted. The caller has checked them (values, ids) first.
+ */
+export declare function insertRecords(params: RecordSinkParams): void;
+//# sourceMappingURL=bulk-insert.d.ts.map

package/dist/store/sqlite/engine/bulk-insert.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bulk-insert.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/bulk-insert.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAA;AAChF,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAA;AAC3C,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AAEvD;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,YAAY,EAAE,CAAA;CAAE,GAAG,WAAW,CAGrF;AAED,yFAAyF;AACzF,wBAAgB,aAAa,CAAC,MAAM,EAAE;IAAE,OAAO,EAAE,YAAY,EAAE,CAAA;CAAE,GAAG,WAAW,CAQ9E;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IACzC,EAAE,EAAE,QAAQ,CAAA;IACZ,KAAK,EAAE,MAAM,CAAA;IACb,IAAI,EAAE,WAAW,CAAA;IACjB,IAAI,CAAC,EAAE,WAAW,CAAA;CAClB,GAAG,IAAI,CAeP;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,gBAAgB,GAAG,IAAI,CAM5D"}

package/dist/store/sqlite/engine/commit.d.ts

@@ -0,0 +1,20 @@
+import { CommitRecordsParams, HistoryStepParams } from './engine.types';
+/**
+ * A commit on the file: refused whole before anything is written, in the order every store answers
+ * in - a document not registered (or still importing), a write id that is not well-formed text, an
+ * update of a record it does not hold, a create that is not JSON, a taken or repeated id, an update
+ * that is not JSON. Then, once the import that runs is settled, one durable transaction: the redo
+ * future discarded, the entry recorded with the records it touches whole - the updated ones as they
+ * are, the created and updated ones as given - the creates and the updates written, then the records
+ * the deletes find kept as they are at that step and deleted. Answers how many records the document
+ * gained (negative when it lost some).
+ */
+export declare function commitRecords(params: CommitRecordsParams): number;
+/**
+ * An undo (`back`) or a redo (`forward`) of the document's history: its last applied entry reverted,
+ * or its first undone one applied again, in one durable transaction once the import that runs is
+ * settled. Answers how many records the document gained, or `undefined` when there was nothing to do
+ * (a document not registered, the start or the end of its history): nothing written then.
+ */
+export declare function stepHistory(params: HistoryStepParams): number | undefined;
+//# sourceMappingURL=commit.d.ts.map

package/dist/store/sqlite/engine/commit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commit.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/commit.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAG5E;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAiDjE;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,GAAG,SAAS,CAoCzE"}

package/dist/store/sqlite/engine/device-cache.d.ts

@@ -0,0 +1,13 @@
+import { DeviceCacheRule } from './engine.types';
+/**
+ * The page cache, in MiB, for a device of that much memory (in GiB, as `navigator.deviceMemory`
+ * reports it): the rule's MiB per GiB, held between its floor and its ceiling. A device that does
+ * not report its memory is sized as a 4 GiB one.
+ */
+export declare function deviceCacheMiB(params: {
+    deviceMemoryGiB: number | undefined;
+    rule?: DeviceCacheRule;
+}): number;
+/** The device's memory as the realm reports it: Chromium does, in a page and in a worker; none elsewhere. */
+export declare function reportedDeviceMemoryGiB(): number | undefined;
+//# sourceMappingURL=device-cache.d.ts.map

package/dist/store/sqlite/engine/device-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"device-cache.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/device-cache.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACtC,eAAe,EAAE,MAAM,GAAG,SAAS,CAAA;IACnC,IAAI,CAAC,EAAE,eAAe,CAAA;CACtB,GAAG,MAAM,CAKT;AAED,6GAA6G;AAC7G,wBAAgB,uBAAuB,IAAI,MAAM,GAAG,SAAS,CAE5D"}

package/dist/store/sqlite/engine/engine-errors.d.ts

@@ -0,0 +1,26 @@
+import { StoreFailureKey } from './engine.types';
+/**
+ * Run `work`; a failure of SQLite (or of anything but a refusal) is thrown as the operation's store
+ * error, the failure as its `cause`. A refusal - a structured error - passes as it is.
+ */
+export declare function asStoreFailure<GenericResult>(params: {
+    key: StoreFailureKey;
+    detail: string;
+    work: () => GenericResult;
+}): GenericResult;
+/** A failure of SQLite as the operation's store error, the failure as its cause; a refusal stays as it is. */
+export declare function toStoreFailure(params: {
+    key: StoreFailureKey;
+    detail: string;
+    thrown: unknown;
+}): Error;
+/** A read: a failure of SQLite is thrown as `STORE_READ_FAILED`, `detail` naming what was read. */
+export declare function asReadFailure<GenericResult>(params: {
+    detail: string;
+    work: () => GenericResult;
+}): GenericResult;
+/** The primary SQLite result code a failure carries, its causes walked; none when SQLite raised none of it. */
+export declare function sqliteCodeOf(params: {
+    thrown: unknown;
+}): number | undefined;
+//# sourceMappingURL=engine-errors.d.ts.map

package/dist/store/sqlite/engine/engine-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine-errors.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/engine-errors.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAErD;;;GAGG;AACH,wBAAgB,cAAc,CAAC,aAAa,EAAE,MAAM,EAAE;IACrD,GAAG,EAAE,eAAe,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,aAAa,CAAA;CACzB,GAAG,aAAa,CAOhB;AAED,8GAA8G;AAC9G,wBAAgB,cAAc,CAAC,MAAM,EAAE;IACtC,GAAG,EAAE,eAAe,CAAA;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,MAAM,EAAE,OAAO,CAAA;CACf,GAAG,KAAK,CAMR;AAED,mGAAmG;AACnG,wBAAgB,aAAa,CAAC,aAAa,EAAE,MAAM,EAAE;IACpD,MAAM,EAAE,MAAM,CAAA;IACd,IAAI,EAAE,MAAM,aAAa,CAAA;CACzB,GAAG,aAAa,CAGhB;AAED,+GAA+G;AAC/G,wBAAgB,YAAY,CAAC,MAAM,EAAE;IAAE,MAAM,EAAE,OAAO,CAAA;CAAE,GAAG,MAAM,GAAG,SAAS,CAa5E"}

package/dist/store/sqlite/engine/engine.constants.d.ts

@@ -0,0 +1,144 @@
+import { SqliteEngineOptions } from './engine.types';
+/** The layout of the project file this engine reads and writes, kept in the file's header (`user_version`). */
+export declare const LAYOUT_VERSION = 4;
+export declare const DEFAULT_ENGINE_OPTIONS: SqliteEngineOptions;
+/** The device's memory when the realm does not report it (Firefox, node): a 4 GiB device. */
+export declare const DEFAULT_DEVICE_MEMORY_GIB = 4;
+/**
+ * The keys of the `_meta` table: what the file says of itself - its dialecte, its layout, and the id it was
+ * created with (a project destroyed and made again under its name has another).
+ */
+export declare const META_KEY: {
+    readonly dialecteId: "dialecteId";
+    readonly layoutVersion: "layoutVersion";
+    readonly creationId: "creationId";
+};
+/** FNV-1a, 32-bit: the offset basis and the prime the dialecte's `application_id` is digested with. */
+export declare const APPLICATION_ID_DIGEST: {
+    readonly offsetBasis: 2166136261;
+    readonly prime: 16777619;
+};
+/** A document's registry row: each column with its SQL type, in binding order (after its `seq`). */
+export declare const DOCUMENT_COLUMNS: {
+    readonly id: "TEXT NOT NULL UNIQUE";
+    readonly name: "TEXT NOT NULL";
+    readonly extension: "TEXT NOT NULL";
+    readonly configKey: "TEXT NOT NULL";
+    readonly createdAt: "INTEGER NOT NULL";
+    readonly metadata: "TEXT";
+    readonly status: "TEXT NOT NULL";
+    readonly writeId: "TEXT";
+    /** One document per path: SQLite lets any number of documents without one through. */
+    readonly path: "TEXT UNIQUE";
+};
+/**
+ * A history entry: one row per commit of a document, in a `HISTORY_ENTRY_STATE`. An id is never given
+ * twice, a removed document's entries included.
+ */
+export declare const CHANGELOG_COLUMNS: {
+    readonly id: "INTEGER PRIMARY KEY AUTOINCREMENT";
+    readonly documentId: "TEXT NOT NULL";
+    /** Its place in the document's history; none once discarded. */
+    readonly sequenceNumber: "INTEGER";
+    readonly timestamp: "INTEGER NOT NULL";
+    readonly writeId: "TEXT NOT NULL";
+    readonly state: "INTEGER NOT NULL";
+};
+/**
+ * Where a history entry stands: applied (the document's first entries, in sequence), undone (the
+ * ones after, a redo applies the first of them again), or discarded (undone, then a commit came: no
+ * place and no records any more, only its write id, so the commit's outcome stays known).
+ */
+export declare const HISTORY_ENTRY_STATE: {
+    readonly applied: 1;
+    readonly undone: 0;
+    readonly discarded: -1;
+};
+/** A blob's entry, by its id and its owner document; its bytes are kept apart. */
+export declare const BLOB_COLUMNS: {
+    readonly id: "TEXT PRIMARY KEY";
+    readonly documentId: "TEXT NOT NULL";
+    readonly entry: "TEXT NOT NULL";
+};
+/** A blob's bytes and their type. */
+export declare const BLOB_DATA_COLUMNS: {
+    readonly id: "TEXT PRIMARY KEY";
+    readonly type: "TEXT NOT NULL";
+    readonly bytes: "BLOB NOT NULL";
+};
+/** A record row: each column with its SQL type, in binding order; a record's children listed on it. */
+export declare const RECORD_COLUMNS: {
+    readonly id: "TEXT NOT NULL";
+    readonly tagName: "TEXT NOT NULL";
+    readonly nsPrefix: "TEXT";
+    readonly nsUri: "TEXT";
+    readonly value: "TEXT";
+    readonly parentId: "TEXT";
+    readonly parentTagName: "TEXT";
+    readonly attributes: "TEXT";
+    readonly children: "TEXT";
+};
+/**
+ * The indexes of a record table, in the order an import builds them: the id (unique: a taken id is
+ * refused) and the tag name - the read paths of the port. A registered document has them from the
+ * start; an imported one gets them as its import goes (the id index at its first update or delete).
+ */
+export declare const RECORD_INDEXES: {
+    readonly id: {
+        readonly column: "id";
+        readonly unique: true;
+    };
+    readonly tag: {
+        readonly column: "tagName";
+        readonly unique: false;
+    };
+};
+/**
+ * Each part of a history entry, as kept on its rows: the records a commit created, each updated one
+ * before and after it, the records it deleted.
+ */
+export declare const HISTORY_PART: {
+    readonly create: 0;
+    readonly before: 1;
+    readonly after: 2;
+    readonly delete: 3;
+};
+/** Prefix of a document's history-rows table, numbered as its record table (`xch_<seq>`). */
+export declare const TABLE_HISTORY_ROWS_PREFIX = "xch_";
+/** The bytes of every blob, by blob id; their entries are in the shared blob registry. */
+export declare const TABLE_BLOB_DATA = "_blobData";
+/** The repeated ids a refused index build names at most: enough to find them, bounded for a file of many. */
+export declare const DUPLICATE_IDS_REPORTED = 100;
+/** Records per JSON1 bind of an insert or an update: bounds one statement's JSON payload. */
+export declare const ROWS_PER_BIND = 1000;
+/** The record columns that hold JSON (kept as JSON text by an insert or an update). */
+export declare const RECORD_JSON_COLUMNS: readonly string[];
+/** The record columns' names, in binding order. */
+export declare const RECORD_COLUMN_NAMES: string[];
+export declare const RECORD_COLUMN_LIST: string;
+export declare const DOCUMENT_COLUMN_LIST: string;
+/** A JSON1 row's columns as the select list of an insert: `e.value->>n`, JSON columns as `e.value->n`. */
+export declare const ROW_SELECT_EXPRESSIONS: string[];
+/** `UPDATE ... FROM` a JSON1 batch: each column but the id set from the batch row of its id. */
+export declare const RECORD_UPDATE_ASSIGNMENTS: string;
+export declare const ROW_SELECT_ALIASES: string;
+/**
+ * An import needs this many times its file's size free. Measured database / file: composed compact 50 MB
+ * and 500 MB 6.5x / 6.6x, structural 50 MB 7.5x (the layout and port benches), indented files 2.8-3.1x; the worst
+ * case and room for the journal and the index sort's temporary file. A file that outgrows it anyway is
+ * refused `STORE_QUOTA_EXCEEDED` when the file system says so.
+ */
+export declare const IMPORT_SPACE_FACTOR = 8;
+/**
+ * The least an import asks for, whatever its file's size: a new document's tables, indexes, history rows
+ * and registry row take a few pages each, and the journal its own room.
+ */
+export declare const IMPORT_SPACE_FLOOR_BYTES: number;
+/** How many causes deep a failure is searched for the SQLite code that started it. */
+export declare const CAUSE_DEPTH = 8;
+/**
+ * The engine's members that write to the file: a failure of one for want of space (SQLite's
+ * `SQLITE_FULL`, or an I/O error the file system explains so) answers `STORE_QUOTA_EXCEEDED`.
+ */
+export declare const ENGINE_WRITE_MEMBERS: readonly ["registerDocument", "updateDocument", "removeDocument", "bulkWrite", "commit", "undo", "redo", "addBlob", "attachBlob", "detachBlob", "removeBlob"];
+//# sourceMappingURL=engine.constants.d.ts.map

package/dist/store/sqlite/engine/engine.constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"engine.constants.d.ts","sourceRoot":"","sources":["../../../../src/store/sqlite/engine/engine.constants.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,gBAAgB,CAAA;AAEzD,+GAA+G;AAC/G,eAAO,MAAM,cAAc,IAAI,CAAA;AAE/B,eAAO,MAAM,sBAAsB,EAAE,mBAqBpC,CAAA;AAED,6FAA6F;AAC7F,eAAO,MAAM,yBAAyB,IAAI,CAAA;AAE1C;;;GAGG;AACH,eAAO,MAAM,QAAQ;;;;CAIX,CAAA;AAEV,uGAAuG;AACvG,eAAO,MAAM,qBAAqB;;;CAA0D,CAAA;AAE5F,oGAAoG;AACpG,eAAO,MAAM,gBAAgB;;;;;;;;;IAS5B,sFAAsF;;CAE7E,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,iBAAiB;;;IAG7B,gEAAgE;;;;;CAKvD,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,mBAAmB;;;;CAItB,CAAA;AAEV,kFAAkF;AAClF,eAAO,MAAM,YAAY;;;;CAIf,CAAA;AAEV,qCAAqC;AACrC,eAAO,MAAM,iBAAiB;;;;CAIpB,CAAA;AAEV,uGAAuG;AACvG,eAAO,MAAM,cAAc;;;;;;;;;;CAUjB,CAAA;AAEV;;;;GAIG;AACH,eAAO,MAAM,cAAc;;;;;;;;;CAGjB,CAAA;AAEV;;;GAGG;AACH,eAAO,MAAM,YAAY;;;;;CAKf,CAAA;AAEV,6FAA6F;AAC7F,eAAO,MAAM,yBAAyB,SAAS,CAAA;AAE/C,0FAA0F;AAC1F,eAAO,MAAM,eAAe,cAAc,CAAA;AAE1C,6GAA6G;AAC7G,eAAO,MAAM,sBAAsB,MAAM,CAAA;AAEzC,6FAA6F;AAC7F,eAAO,MAAM,aAAa,OAAO,CAAA;AAEjC,uFAAuF;AACvF,eAAO,MAAM,mBAAmB,EAAE,SAAS,MAAM,EAA+B,CAAA;AAEhF,mDAAmD;AACnD,eAAO,MAAM,mBAAmB,UAA8B,CAAA;AAE9D,eAAO,MAAM,kBAAkB,QAAiC,CAAA;AAEhE,eAAO,MAAM,oBAAoB,QAA2C,CAAA;AAE5E,0GAA0G;AAC1G,eAAO,MAAM,sBAAsB,UAElC,CAAA;AAED,gGAAgG;AAChG,eAAO,MAAM,yBAAyB,QAG1B,CAAA;AAEZ,eAAO,MAAM,kBAAkB,QAEnB,CAAA;AAEZ;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,IAAI,CAAA;AAEpC;;;GAGG;AACH,eAAO,MAAM,wBAAwB,QAAc,CAAA;AAEnD,sFAAsF;AACtF,eAAO,MAAM,WAAW,IAAI,CAAA;AAE5B;;;GAGG;AACH,eAAO,MAAM,oBAAoB,+JAYoB,CAAA"}