@rocicorp/zero 0.25.0 → 0.26.0-canary.0

package/out/replicache/src/db/write.js

@@ -0,0 +1,296 @@
+import { assert } from "../../../shared/src/asserts.js";
+import { diff } from "../btree/diff.js";
+import { BTreeRead, allEntriesAsDiff } from "../btree/read.js";
+import { BTreeWrite } from "../btree/write.js";
+import { DD31 } from "../format-version-enum.js";
+import { emptyHash } from "../hash.js";
+import { lazy } from "../lazy.js";
+import { DiffsMap } from "../sync/diff.js";
+import { commitFromHash, getMutationID, newSnapshotDD31, newLocalDD31, baseSnapshotHashFromHash } from "./commit.js";
+import { Add, Remove } from "./index-operation-enum.js";
+import { indexValue, IndexWrite } from "./index.js";
+import { SnapshotDD31, LocalDD31 } from "./meta-type-enum.js";
+import { Read, readIndexesForRead } from "./read.js";
+class Write extends Read {
+  #dagWrite;
+  #basis;
+  #meta;
+  #clientID;
+  #formatVersion;
+  constructor(dagWrite, map, basis, meta, indexes, clientID, formatVersion) {
+    super(dagWrite, map, indexes);
+    this.#dagWrite = dagWrite;
+    this.#basis = basis;
+    this.#meta = meta;
+    this.#clientID = clientID;
+    this.#formatVersion = formatVersion;
+    if (basis === void 0) {
+      assert(meta.basisHash === emptyHash);
+    } else {
+      assert(meta.basisHash === basis.chunk.hash);
+    }
+  }
+  /**
+   * The value needs to be frozen since it is kept in memory and used later for
+   * comparison as well as returned in `get`.
+   */
+  async put(lc, key, value) {
+    const oldVal = lazy(() => this.map.get(key));
+    await updateIndexes(lc, this.indexes, key, oldVal, value);
+    await this.map.put(key, value);
+  }
+  getMutationID() {
+    return getMutationID(this.#clientID, this.#dagWrite, this.#meta);
+  }
+  async del(lc, key) {
+    const oldVal = lazy(() => this.map.get(key));
+    if (oldVal !== void 0) {
+      await updateIndexes(lc, this.indexes, key, oldVal, void 0);
+    }
+    return this.map.del(key);
+  }
+  async clear() {
+    await this.map.clear();
+    const ps = [];
+    for (const idx of this.indexes.values()) {
+      ps.push(idx.clear());
+    }
+    await Promise.all(ps);
+  }
+  async putCommit() {
+    const valueHash = await this.map.flush();
+    const indexRecords = [];
+    for (const index of this.indexes.values()) {
+      const valueHash2 = await index.flush();
+      const indexRecord = {
+        definition: index.meta.definition,
+        valueHash: valueHash2
+      };
+      indexRecords.push(indexRecord);
+    }
+    let commit;
+    const meta = this.#meta;
+    switch (meta.type) {
+      case LocalDD31: {
+        assert(this.#formatVersion >= DD31);
+        const {
+          basisHash,
+          mutationID,
+          mutatorName,
+          mutatorArgsJSON,
+          originalHash,
+          timestamp
+        } = meta;
+        commit = newLocalDD31(
+          this.#dagWrite.createChunk,
+          basisHash,
+          await baseSnapshotHashFromHash(basisHash, this.#dagWrite),
+          mutationID,
+          mutatorName,
+          mutatorArgsJSON,
+          originalHash,
+          valueHash,
+          indexRecords,
+          timestamp,
+          this.#clientID
+        );
+        break;
+      }
+      case SnapshotDD31: {
+        assert(this.#formatVersion > DD31);
+        const { basisHash, lastMutationIDs, cookieJSON } = meta;
+        commit = newSnapshotDD31(
+          this.#dagWrite.createChunk,
+          basisHash,
+          lastMutationIDs,
+          cookieJSON,
+          valueHash,
+          indexRecords
+        );
+        break;
+      }
+    }
+    await this.#dagWrite.putChunk(commit.chunk);
+    return commit;
+  }
+  // Return value is the hash of the new commit.
+  async commit(headName) {
+    const commit = await this.putCommit();
+    const commitHash = commit.chunk.hash;
+    await this.#dagWrite.setHead(headName, commitHash);
+    await this.#dagWrite.commit();
+    return commitHash;
+  }
+  async commitWithDiffs(headName, diffConfig) {
+    const commit = this.putCommit();
+    const diffMap = await this.#generateDiffs(diffConfig);
+    const commitHash = (await commit).chunk.hash;
+    await this.#dagWrite.setHead(headName, commitHash);
+    await this.#dagWrite.commit();
+    return [commitHash, diffMap];
+  }
+  async #generateDiffs(diffConfig) {
+    const diffsMap = new DiffsMap();
+    if (!diffConfig.shouldComputeDiffs()) {
+      return diffsMap;
+    }
+    let valueDiff = [];
+    if (this.#basis) {
+      const basisMap = new BTreeRead(
+        this.#dagWrite,
+        this.#formatVersion,
+        this.#basis.valueHash
+      );
+      valueDiff = await diff(basisMap, this.map);
+    }
+    diffsMap.set("", valueDiff);
+    let basisIndexes;
+    if (this.#basis) {
+      basisIndexes = readIndexesForRead(
+        this.#basis,
+        this.#dagWrite,
+        this.#formatVersion
+      );
+    } else {
+      basisIndexes = /* @__PURE__ */ new Map();
+    }
+    for (const [name, index] of this.indexes) {
+      if (!diffConfig.shouldComputeDiffsForIndex(name)) {
+        continue;
+      }
+      const basisIndex = basisIndexes.get(name);
+      assert(index !== basisIndex);
+      const indexDiffResult = await (basisIndex ? diff(basisIndex.map, index.map) : (
+        // No basis. All keys are new.
+        allEntriesAsDiff(index.map, "add")
+      ));
+      diffsMap.set(name, indexDiffResult);
+    }
+    for (const [name, basisIndex] of basisIndexes) {
+      if (!this.indexes.has(name) && diffConfig.shouldComputeDiffsForIndex(name)) {
+        const indexDiffResult = await allEntriesAsDiff(basisIndex.map, "del");
+        diffsMap.set(name, indexDiffResult);
+      }
+    }
+    return diffsMap;
+  }
+  close() {
+    this.#dagWrite.release();
+  }
+}
+async function newWriteLocal(basisHash, mutatorName, mutatorArgsJSON, originalHash, dagWrite, timestamp, clientID, formatVersion) {
+  const basis = await commitFromHash(basisHash, dagWrite);
+  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);
+  const mutationID = await basis.getNextMutationID(clientID, dagWrite);
+  const indexes = readIndexesForWrite(basis, dagWrite, formatVersion);
+  assert(formatVersion >= DD31);
+  return new Write(
+    dagWrite,
+    bTreeWrite,
+    basis,
+    {
+      type: LocalDD31,
+      basisHash,
+      baseSnapshotHash: await baseSnapshotHashFromHash(basisHash, dagWrite),
+      mutatorName,
+      mutatorArgsJSON,
+      mutationID,
+      originalHash,
+      timestamp,
+      clientID
+    },
+    indexes,
+    clientID,
+    formatVersion
+  );
+}
+async function newWriteSnapshotDD31(basisHash, lastMutationIDs, cookieJSON, dagWrite, clientID, formatVersion) {
+  const basis = await commitFromHash(basisHash, dagWrite);
+  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);
+  return new Write(
+    dagWrite,
+    bTreeWrite,
+    basis,
+    { basisHash, type: SnapshotDD31, lastMutationIDs, cookieJSON },
+    readIndexesForWrite(basis, dagWrite, formatVersion),
+    clientID,
+    formatVersion
+  );
+}
+async function updateIndexes(lc, indexes, key, oldValGetter, newVal) {
+  const ps = [];
+  for (const idx of indexes.values()) {
+    const { keyPrefix } = idx.meta.definition;
+    if (!keyPrefix || key.startsWith(keyPrefix)) {
+      const oldVal = await oldValGetter();
+      if (oldVal !== void 0) {
+        ps.push(
+          indexValue(
+            lc,
+            idx.map,
+            Remove,
+            key,
+            oldVal,
+            idx.meta.definition.jsonPointer,
+            idx.meta.definition.allowEmpty ?? false
+          )
+        );
+      }
+      if (newVal !== void 0) {
+        ps.push(
+          indexValue(
+            lc,
+            idx.map,
+            Add,
+            key,
+            newVal,
+            idx.meta.definition.jsonPointer,
+            idx.meta.definition.allowEmpty ?? false
+          )
+        );
+      }
+    }
+  }
+  await Promise.all(ps);
+}
+function readIndexesForWrite(commit, dagWrite, formatVersion) {
+  const m = /* @__PURE__ */ new Map();
+  for (const index of commit.indexes) {
+    m.set(
+      index.definition.name,
+      new IndexWrite(
+        index,
+        new BTreeWrite(dagWrite, formatVersion, index.valueHash)
+      )
+    );
+  }
+  return m;
+}
+async function createIndexBTree(lc, dagWrite, valueMap, prefix, jsonPointer, allowEmpty, formatVersion) {
+  const indexMap = new BTreeWrite(dagWrite, formatVersion);
+  for await (const entry of valueMap.scan(prefix)) {
+    const key = entry[0];
+    if (!key.startsWith(prefix)) {
+      break;
+    }
+    await indexValue(
+      lc,
+      indexMap,
+      Add,
+      key,
+      entry[1],
+      jsonPointer,
+      allowEmpty
+    );
+  }
+  return indexMap;
+}
+export {
+  Write,
+  createIndexBTree,
+  newWriteLocal,
+  newWriteSnapshotDD31,
+  readIndexesForWrite,
+  updateIndexes
+};
+//# sourceMappingURL=write.js.map

package/out/replicache/src/db/write.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"write.js","sources":["../../../../../replicache/src/db/write.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {assert} from '../../../shared/src/asserts.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {diff} from '../btree/diff.ts';\nimport type {InternalDiff} from '../btree/node.ts';\nimport {BTreeRead, allEntriesAsDiff} from '../btree/read.ts';\nimport {BTreeWrite} from '../btree/write.ts';\nimport type {FrozenCookie} from '../cookies.ts';\nimport type {Write as DagWrite} from '../dag/store.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport {lazy} from '../lazy.ts';\nimport type {DiffComputationConfig} from '../sync/diff.ts';\nimport {DiffsMap} from '../sync/diff.ts';\nimport type {ClientID} from '../sync/ids.ts';\nimport type {Commit} from './commit.ts';\nimport {\n  type Meta as CommitMeta,\n  type IndexRecord,\n  type Meta,\n  baseSnapshotHashFromHash,\n  commitFromHash,\n  newLocalDD31 as commitNewLocalDD31,\n  newSnapshotDD31 as commitNewSnapshotDD31,\n  getMutationID,\n} from './commit.ts';\nimport * as IndexOperation from './index-operation-enum.ts';\nimport type {IndexRead} from './index.ts';\nimport {IndexWrite, indexValue} from './index.ts';\nimport * as MetaType from './meta-type-enum.ts';\nimport {Read, readIndexesForRead} from './read.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport class Write extends Read {\n  readonly #dagWrite: DagWrite;\n  readonly #basis: Commit<CommitMeta> | undefined;\n  readonly #meta: CommitMeta;\n\n  declare map: BTreeWrite;\n\n  declare readonly indexes: Map<string, IndexWrite>;\n  readonly #clientID: ClientID;\n  readonly #formatVersion: FormatVersion;\n\n  constructor(\n    dagWrite: DagWrite,\n    map: BTreeWrite,\n    basis: Commit<CommitMeta> | undefined,\n    meta: CommitMeta,\n    indexes: Map<string, IndexWrite>,\n    clientID: ClientID,\n    formatVersion: FormatVersion,\n  ) {\n    // TypeScript has trouble\n    super(dagWrite, map, indexes);\n    this.#dagWrite = dagWrite;\n    this.#basis = basis;\n    this.#meta = meta;\n    this.#clientID = clientID;\n    this.#formatVersion = formatVersion;\n\n    // TODO(arv): if (DEBUG) { ...\n    if (basis === undefined) {\n      assert(meta.basisHash === emptyHash);\n    } else {\n      assert(meta.basisHash === basis.chunk.hash);\n    }\n  }\n\n  /**\n   * The value needs to be frozen since it is kept in memory and used later for\n   * comparison as well as returned in `get`.\n   */\n  async put(\n    lc: LogContext,\n    key: string,\n    value: FrozenJSONValue,\n  ): Promise<void> {\n    const oldVal = lazy(() => this.map.get(key));\n    await updateIndexes(lc, this.indexes, key, oldVal, value);\n\n    await this.map.put(key, value);\n  }\n\n  getMutationID(): Promise<number> {\n    return getMutationID(this.#clientID, this.#dagWrite, this.#meta);\n  }\n\n  async del(lc: LogContext, key: string): Promise<boolean> {\n    // TODO(arv): This does the binary search twice. We can do better.\n    const oldVal = lazy(() => this.map.get(key));\n    if (oldVal !== undefined) {\n      await updateIndexes(lc, this.indexes, key, oldVal, undefined);\n    }\n    return this.map.del(key);\n  }\n\n  async clear(): Promise<void> {\n    await this.map.clear();\n    const ps = [];\n    for (const idx of this.indexes.values()) {\n      ps.push(idx.clear());\n    }\n    await Promise.all(ps);\n  }\n\n  async putCommit(): Promise<Commit<CommitMeta>> {\n    const valueHash = await this.map.flush();\n    const indexRecords: IndexRecord[] = [];\n\n    for (const index of this.indexes.values()) {\n      const valueHash = await index.flush();\n      const indexRecord: IndexRecord = {\n        definition: index.meta.definition,\n        valueHash,\n      };\n      indexRecords.push(indexRecord);\n    }\n\n    let commit: Commit<Meta>;\n    const meta = this.#meta;\n    switch (meta.type) {\n      case MetaType.LocalDD31: {\n        assert(this.#formatVersion >= FormatVersion.DD31);\n        const {\n          basisHash,\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          timestamp,\n        } = meta;\n        commit = commitNewLocalDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          await baseSnapshotHashFromHash(basisHash, this.#dagWrite),\n          mutationID,\n          mutatorName,\n          mutatorArgsJSON,\n          originalHash,\n          valueHash,\n          indexRecords,\n          timestamp,\n          this.#clientID,\n        );\n        break;\n      }\n\n      case MetaType.SnapshotDD31: {\n        assert(this.#formatVersion > FormatVersion.DD31);\n        const {basisHash, lastMutationIDs, cookieJSON} = meta;\n        commit = commitNewSnapshotDD31(\n          this.#dagWrite.createChunk,\n          basisHash,\n          lastMutationIDs,\n          cookieJSON,\n          valueHash,\n          indexRecords,\n        );\n        break;\n      }\n    }\n    await this.#dagWrite.putChunk(commit.chunk);\n    return commit;\n  }\n\n  // Return value is the hash of the new commit.\n  async commit(headName: string): Promise<Hash> {\n    const commit = await this.putCommit();\n    const commitHash = commit.chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return commitHash;\n  }\n\n  async commitWithDiffs(\n    headName: string,\n    diffConfig: DiffComputationConfig,\n  ): Promise<[Hash, DiffsMap]> {\n    const commit = this.putCommit();\n    const diffMap = await this.#generateDiffs(diffConfig);\n    const commitHash = (await commit).chunk.hash;\n    await this.#dagWrite.setHead(headName, commitHash);\n    await this.#dagWrite.commit();\n    return [commitHash, diffMap];\n  }\n\n  async #generateDiffs(diffConfig: DiffComputationConfig): Promise<DiffsMap> {\n    const diffsMap = new DiffsMap();\n    if (!diffConfig.shouldComputeDiffs()) {\n      return diffsMap;\n    }\n\n    let valueDiff: InternalDiff = [];\n    if (this.#basis) {\n      const basisMap = new BTreeRead(\n        this.#dagWrite,\n        this.#formatVersion,\n        this.#basis.valueHash,\n      );\n      valueDiff = await diff(basisMap, this.map);\n    }\n    diffsMap.set('', valueDiff);\n    let basisIndexes: Map<string, IndexRead>;\n    if (this.#basis) {\n      basisIndexes = readIndexesForRead(\n        this.#basis,\n        this.#dagWrite,\n        this.#formatVersion,\n      );\n    } else {\n      basisIndexes = new Map();\n    }\n\n    for (const [name, index] of this.indexes) {\n      if (!diffConfig.shouldComputeDiffsForIndex(name)) {\n        continue;\n      }\n      const basisIndex = basisIndexes.get(name);\n      assert(index !== basisIndex);\n\n      const indexDiffResult = await (basisIndex\n        ? diff(basisIndex.map, index.map)\n        : // No basis. All keys are new.\n          allEntriesAsDiff(index.map, 'add'));\n      diffsMap.set(name, indexDiffResult);\n    }\n\n    // Handle indexes in basisIndex but not in this.indexes. All keys are\n    // deleted.\n    for (const [name, basisIndex] of basisIndexes) {\n      if (\n        !this.indexes.has(name) &&\n        diffConfig.shouldComputeDiffsForIndex(name)\n      ) {\n        const indexDiffResult = await allEntriesAsDiff(basisIndex.map, 'del');\n        diffsMap.set(name, indexDiffResult);\n      }\n    }\n    return diffsMap;\n  }\n\n  close(): void {\n    this.#dagWrite.release();\n  }\n}\n\nexport async function newWriteLocal(\n  basisHash: Hash,\n  mutatorName: string,\n  mutatorArgsJSON: FrozenJSONValue,\n  originalHash: Hash | null,\n  dagWrite: DagWrite,\n  timestamp: number,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  const mutationID = await basis.getNextMutationID(clientID, dagWrite);\n  const indexes = readIndexesForWrite(basis, dagWrite, formatVersion);\n  assert(formatVersion >= FormatVersion.DD31);\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n\n    {\n      type: MetaType.LocalDD31,\n      basisHash,\n      baseSnapshotHash: await baseSnapshotHashFromHash(basisHash, dagWrite),\n      mutatorName,\n      mutatorArgsJSON,\n      mutationID,\n      originalHash,\n      timestamp,\n      clientID,\n    },\n    indexes,\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function newWriteSnapshotDD31(\n  basisHash: Hash,\n  lastMutationIDs: Record<ClientID, number>,\n  cookieJSON: FrozenCookie,\n  dagWrite: DagWrite,\n  clientID: ClientID,\n  formatVersion: FormatVersion,\n): Promise<Write> {\n  const basis = await commitFromHash(basisHash, dagWrite);\n  const bTreeWrite = new BTreeWrite(dagWrite, formatVersion, basis.valueHash);\n  return new Write(\n    dagWrite,\n    bTreeWrite,\n    basis,\n    {basisHash, type: MetaType.SnapshotDD31, lastMutationIDs, cookieJSON},\n    readIndexesForWrite(basis, dagWrite, formatVersion),\n    clientID,\n    formatVersion,\n  );\n}\n\nexport async function updateIndexes(\n  lc: LogContext,\n  indexes: Map<string, IndexWrite>,\n  key: string,\n  oldValGetter: () => Promise<FrozenJSONValue | undefined>,\n  newVal: FrozenJSONValue | undefined,\n): Promise<void> {\n  const ps: Promise<void>[] = [];\n  for (const idx of indexes.values()) {\n    const {keyPrefix} = idx.meta.definition;\n    if (!keyPrefix || key.startsWith(keyPrefix)) {\n      const oldVal = await oldValGetter();\n      if (oldVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Remove,\n            key,\n            oldVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n      if (newVal !== undefined) {\n        ps.push(\n          indexValue(\n            lc,\n            idx.map,\n            IndexOperation.Add,\n            key,\n            newVal,\n            idx.meta.definition.jsonPointer,\n            idx.meta.definition.allowEmpty ?? false,\n          ),\n        );\n      }\n    }\n  }\n  await Promise.all(ps);\n}\n\nexport function readIndexesForWrite(\n  commit: Commit<CommitMeta>,\n  dagWrite: DagWrite,\n  formatVersion: FormatVersion,\n): Map<string, IndexWrite> {\n  const m = new Map();\n  for (const index of commit.indexes) {\n    m.set(\n      index.definition.name,\n      new IndexWrite(\n        index,\n        new BTreeWrite(dagWrite, formatVersion, index.valueHash),\n      ),\n    );\n  }\n  return m;\n}\n\nexport async function createIndexBTree(\n  lc: LogContext,\n  dagWrite: DagWrite,\n  valueMap: BTreeRead,\n  prefix: string,\n  jsonPointer: string,\n  allowEmpty: boolean,\n  formatVersion: FormatVersion,\n): Promise<BTreeWrite> {\n  const indexMap = new BTreeWrite(dagWrite, formatVersion);\n  for await (const entry of valueMap.scan(prefix)) {\n    const key = entry[0];\n    if (!key.startsWith(prefix)) {\n      break;\n    }\n    await indexValue(\n      lc,\n      indexMap,\n      IndexOperation.Add,\n      key,\n      entry[1],\n      jsonPointer,\n      allowEmpty,\n    );\n  }\n  return indexMap;\n}\n"],"names":["valueHash","MetaType.LocalDD31","FormatVersion.DD31","commitNewLocalDD31","MetaType.SnapshotDD31","commitNewSnapshotDD31","IndexOperation.Remove","IndexOperation.Add"],"mappings":"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"}

package/out/replicache/src/deleted-clients.js

@@ -0,0 +1,104 @@
+import { stringCompare } from "../../shared/src/string-compare.js";
+import { readonlyArray, readonlyObject, test } from "../../shared/src/valita.js";
+import { deepFreeze } from "./frozen-json.js";
+import { getClients, setClients } from "./persist/clients.js";
+import { clientIDSchema, clientGroupIDSchema } from "./sync/ids.js";
+const DELETED_CLIENTS_HEAD_NAME = "deleted-clients-v2";
+const deletedClientsSchema = readonlyArray(
+  readonlyObject({
+    clientGroupID: clientGroupIDSchema,
+    clientID: clientIDSchema
+  })
+);
+function compare(a, b) {
+  const cg = stringCompare(a.clientGroupID, b.clientGroupID);
+  if (cg !== 0) {
+    return cg;
+  }
+  return stringCompare(a.clientID, b.clientID);
+}
+function normalizeDeletedClients(deletedClients) {
+  return [...deletedClients].sort(compare).filter(
+    (item, index) => index === 0 || compare(item, [...deletedClients].sort(compare)[index - 1]) !== 0
+  );
+}
+function mergeDeletedClients(a, b) {
+  const merged = [];
+  a = normalizeDeletedClients(a);
+  b = normalizeDeletedClients(b);
+  for (let i = 0, j = 0; i < a.length || j < b.length; ) {
+    if (i < a.length && (j >= b.length || compare(a[i], b[j]) < 0)) {
+      merged.push(a[i]);
+      i++;
+    } else if (j < b.length && (i >= a.length || compare(b[j], a[i]) < 0)) {
+      merged.push(b[j]);
+      j++;
+    } else {
+      merged.push(a[i]);
+      i++;
+      j++;
+    }
+  }
+  return merged;
+}
+async function setDeletedClients(dagWrite, deletedClients) {
+  const data = normalizeDeletedClients(deletedClients);
+  const chunkData = deepFreeze(data);
+  const chunk = dagWrite.createChunk(chunkData, []);
+  await dagWrite.putChunk(chunk);
+  await dagWrite.setHead(DELETED_CLIENTS_HEAD_NAME, chunk.hash);
+  return data;
+}
+async function getDeletedClients(dagRead) {
+  const hash = await dagRead.getHead(DELETED_CLIENTS_HEAD_NAME);
+  if (hash === void 0) {
+    return [];
+  }
+  const chunk = await dagRead.mustGetChunk(hash);
+  const res = test(chunk.data, deletedClientsSchema);
+  if (!res.ok) {
+    return [];
+  }
+  return res.value;
+}
+async function addDeletedClients(dagWrite, deletedClientsToAdd) {
+  const oldDeletedClients = await getDeletedClients(dagWrite);
+  return setDeletedClients(
+    dagWrite,
+    mergeDeletedClients(oldDeletedClients, deletedClientsToAdd)
+  );
+}
+async function confirmDeletedClients(dagWrite, deletedClientIds, deletedClientGroupIds) {
+  const deletedClientIDSet = new Set(deletedClientIds);
+  const deletedClientGroupIDSet = new Set(deletedClientGroupIds);
+  const oldDeletedClients = await getDeletedClients(dagWrite);
+  const clients = new Map(await getClients(dagWrite));
+  for (const clientID of deletedClientIds) {
+    clients.delete(clientID);
+  }
+  for (const clientGroupID of deletedClientGroupIds) {
+    for (const [clientID, client] of clients) {
+      if (client.clientGroupID === clientGroupID) {
+        clients.delete(clientID);
+      }
+    }
+  }
+  await setClients(clients, dagWrite);
+  return setDeletedClients(
+    dagWrite,
+    oldDeletedClients.filter(
+      ({ clientGroupID, clientID }) => !deletedClientGroupIDSet.has(clientGroupID) && !deletedClientIDSet.has(clientID)
+    )
+  );
+}
+export {
+  DELETED_CLIENTS_HEAD_NAME,
+  addDeletedClients,
+  confirmDeletedClients,
+  deletedClientsSchema,
+  getDeletedClients,
+  mergeDeletedClients,
+  normalizeDeletedClients,
+  setDeletedClients
+};
+//# sourceMappingURL=deleted-clients.js.map

package/out/replicache/src/deleted-clients.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"deleted-clients.js","sources":["../../../../replicache/src/deleted-clients.ts"],"sourcesContent":["import {stringCompare} from '../../shared/src/string-compare.ts';\nimport * as v from '../../shared/src/valita.ts';\nimport type {Read, Write} from './dag/store.ts';\nimport {deepFreeze} from './frozen-json.ts';\nimport {getClients, setClients} from './persist/clients.ts';\nimport {\n  clientGroupIDSchema,\n  clientIDSchema,\n  type ClientGroupID,\n  type ClientID,\n} from './sync/ids.ts';\n\n/**\n * We keep track of deleted clients in the {@linkcode DELETED_CLIENTS_HEAD_NAME}\n * head.\n */\nexport const DELETED_CLIENTS_HEAD_NAME = 'deleted-clients-v2';\n\ntype ClientIDPair = {\n  clientGroupID: ClientGroupID;\n  clientID: ClientID;\n};\n\nexport type DeletedClients = readonly Readonly<ClientIDPair>[];\n\nexport type WritableDeletedClients = ClientIDPair[];\n\nexport const deletedClientsSchema: v.Type<DeletedClients> = v.readonlyArray(\n  v.readonlyObject({\n    clientGroupID: clientGroupIDSchema,\n    clientID: clientIDSchema,\n  }),\n);\n\nfunction compare(a: ClientIDPair, b: ClientIDPair): number {\n  const cg = stringCompare(a.clientGroupID, b.clientGroupID);\n  if (cg !== 0) {\n    return cg;\n  }\n  return stringCompare(a.clientID, b.clientID);\n}\n\nexport function normalizeDeletedClients(\n  deletedClients: DeletedClients,\n): DeletedClients {\n  // dedupe\n  return [...deletedClients]\n    .sort(compare)\n    .filter(\n      (item, index) =>\n        index === 0 ||\n        compare(item, [...deletedClients].sort(compare)[index - 1]) !== 0,\n    );\n}\n\nexport function mergeDeletedClients(\n  a: DeletedClients,\n  b: DeletedClients,\n): DeletedClients {\n  const merged: WritableDeletedClients = [];\n  a = normalizeDeletedClients(a);\n  b = normalizeDeletedClients(b);\n  for (let i = 0, j = 0; i < a.length || j < b.length; ) {\n    if (i < a.length && (j >= b.length || compare(a[i], b[j]) < 0)) {\n      merged.push(a[i]);\n      i++;\n    } else if (j < b.length && (i >= a.length || compare(b[j], a[i]) < 0)) {\n      merged.push(b[j]);\n      j++;\n    } else {\n      // equal\n      merged.push(a[i]);\n      i++;\n      j++;\n    }\n  }\n  return merged;\n}\n\nexport function removeFromDeletedClients(\n  old: DeletedClients,\n  toRemove: DeletedClients,\n): DeletedClients {\n  old = normalizeDeletedClients(old);\n  toRemove = normalizeDeletedClients(toRemove);\n  const result: WritableDeletedClients = [];\n  for (let i = 0, j = 0; i < old.length; ) {\n    if (j >= toRemove.length || compare(old[i], toRemove[j]) < 0) {\n      result.push(old[i]);\n      i++;\n    } else if (j < toRemove.length && compare(old[i], toRemove[j]) === 0) {\n      // equal, skip\n      i++;\n      j++;\n    } else {\n      // old[i] > toRemove[j]\n      j++;\n    }\n  }\n  return result;\n}\n\nexport async function setDeletedClients(\n  dagWrite: Write,\n  deletedClients: DeletedClients,\n): Promise<DeletedClients> {\n  // sort and dedupe\n\n  const data = normalizeDeletedClients(deletedClients);\n\n  const chunkData = deepFreeze(data);\n  const chunk = dagWrite.createChunk(chunkData, []);\n  await dagWrite.putChunk(chunk);\n  await dagWrite.setHead(DELETED_CLIENTS_HEAD_NAME, chunk.hash);\n  return data;\n}\n\nexport async function getDeletedClients(\n  dagRead: Read,\n): Promise<DeletedClients> {\n  const hash = await dagRead.getHead(DELETED_CLIENTS_HEAD_NAME);\n  if (hash === undefined) {\n    return [];\n  }\n  const chunk = await dagRead.mustGetChunk(hash);\n\n  const res = v.test(chunk.data, deletedClientsSchema);\n  if (!res.ok) {\n    // If not ok then we ignore this. It might be in the old format but we do\n    // not know the clientGroupID of the old clients.\n    return [];\n  }\n\n  return res.value;\n}\n\n/**\n * Adds deleted clients to the {@linkcode DELETED_CLIENTS_HEAD_NAME} head.\n * @returns the new list of deleted clients (sorted and deduped).\n */\nexport async function addDeletedClients(\n  dagWrite: Write,\n  deletedClientsToAdd: DeletedClients,\n): Promise<DeletedClients> {\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n\n  return setDeletedClients(\n    dagWrite,\n    mergeDeletedClients(oldDeletedClients, deletedClientsToAdd),\n  );\n}\n\nexport async function removeDeletedClients(\n  dagWrite: Write,\n  deletedClientsToRemove: DeletedClients,\n): Promise<DeletedClients> {\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n  return setDeletedClients(\n    dagWrite,\n    removeFromDeletedClients(oldDeletedClients, deletedClientsToRemove),\n  );\n}\n\nexport async function confirmDeletedClients(\n  dagWrite: Write,\n  deletedClientIds: readonly ClientID[],\n  deletedClientGroupIds: readonly ClientGroupID[],\n): Promise<DeletedClients> {\n  const deletedClientIDSet = new Set(deletedClientIds);\n  const deletedClientGroupIDSet = new Set(deletedClientGroupIds);\n  const oldDeletedClients = await getDeletedClients(dagWrite);\n  const clients = new Map(await getClients(dagWrite));\n  for (const clientID of deletedClientIds) {\n    clients.delete(clientID);\n  }\n  for (const clientGroupID of deletedClientGroupIds) {\n    for (const [clientID, client] of clients) {\n      if (client.clientGroupID === clientGroupID) {\n        clients.delete(clientID);\n      }\n    }\n  }\n\n  await setClients(clients, dagWrite);\n\n  return setDeletedClients(\n    dagWrite,\n    oldDeletedClients.filter(\n      ({clientGroupID, clientID}) =>\n        !deletedClientGroupIDSet.has(clientGroupID) &&\n        !deletedClientIDSet.has(clientID),\n    ),\n  );\n}\n\n/**\n * Sorts and dedupes the given array.\n */\nexport function normalize<T>(arr: readonly T[]): T[] {\n  return [...new Set(arr)].sort();\n}\n"],"names":["v.readonlyArray","v.readonlyObject","v.test"],"mappings":"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"}

package/out/replicache/src/error-responses.js

@@ -0,0 +1,34 @@
+import { assert } from "../../shared/src/asserts.js";
+function isError(obj, type) {
+  return typeof obj === "object" && obj !== null && obj.error === type;
+}
+function isErrorResponse(obj) {
+  return typeof obj.error === "string";
+}
+function isClientStateNotFoundResponse(v) {
+  return isError(v, "ClientStateNotFound");
+}
+function isVersionNotSupportedResponse(v) {
+  if (!isError(v, "VersionNotSupported")) {
+    return false;
+  }
+  const { versionType } = v;
+  switch (versionType) {
+    case void 0:
+    case "pull":
+    case "push":
+    case "schema":
+      return true;
+  }
+  return false;
+}
+function assertVersionNotSupportedResponse(v) {
+  assert(isVersionNotSupportedResponse(v));
+}
+export {
+  assertVersionNotSupportedResponse,
+  isClientStateNotFoundResponse,
+  isErrorResponse,
+  isVersionNotSupportedResponse
+};
+//# sourceMappingURL=error-responses.js.map

package/out/replicache/src/error-responses.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-responses.js","sources":["../../../../replicache/src/error-responses.ts"],"sourcesContent":["import {assert} from '../../shared/src/asserts.ts';\n\nfunction isError(obj: unknown, type: string): boolean {\n  return (\n    typeof obj === 'object' &&\n    obj !== null &&\n    (obj as {error: unknown}).error === type\n  );\n}\n\ntype ErrorResponse = {error: string};\n\nexport function isErrorResponse(obj: object): obj is ErrorResponse {\n  return typeof (obj as {error: unknown}).error === 'string';\n}\n\n/**\n * In certain scenarios the server can signal that it does not know about the\n * client. For example, the server might have lost all of its state (this might\n * happen during the development of the server).\n */\nexport type ClientStateNotFoundResponse = {\n  error: 'ClientStateNotFound';\n};\n\nexport function isClientStateNotFoundResponse(\n  v: unknown,\n): v is ClientStateNotFoundResponse {\n  return isError(v, 'ClientStateNotFound');\n}\n\n/**\n * The server endpoint may respond with a `VersionNotSupported` error if it does\n * not know how to handle the pull, push or schema version.\n */\nexport type VersionNotSupportedResponse = {\n  error: 'VersionNotSupported';\n  versionType?: 'pull' | 'push' | 'schema' | undefined;\n};\n\nexport function isVersionNotSupportedResponse(\n  v: unknown,\n): v is VersionNotSupportedResponse {\n  if (!isError(v, 'VersionNotSupported')) {\n    return false;\n  }\n\n  const {versionType} = v as Record<string, unknown>;\n  switch (versionType) {\n    case undefined:\n    case 'pull':\n    case 'push':\n    case 'schema':\n      return true;\n  }\n\n  return false;\n}\n\nexport function assertVersionNotSupportedResponse(\n  v: unknown,\n): asserts v is VersionNotSupportedResponse {\n  assert(isVersionNotSupportedResponse(v));\n}\n"],"names":[],"mappings":";AAEA,SAAS,QAAQ,KAAc,MAAuB;AACpD,SACE,OAAO,QAAQ,YACf,QAAQ,QACP,IAAyB,UAAU;AAExC;AAIO,SAAS,gBAAgB,KAAmC;AACjE,SAAO,OAAQ,IAAyB,UAAU;AACpD;AAWO,SAAS,8BACd,GACkC;AAClC,SAAO,QAAQ,GAAG,qBAAqB;AACzC;AAWO,SAAS,8BACd,GACkC;AAClC,MAAI,CAAC,QAAQ,GAAG,qBAAqB,GAAG;AACtC,WAAO;AAAA,EACT;AAEA,QAAM,EAAC,gBAAe;AACtB,UAAQ,aAAA;AAAA,IACN,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,EAAA;AAGX,SAAO;AACT;AAEO,SAAS,kCACd,GAC0C;AAC1C,SAAO,8BAA8B,CAAC,CAAC;AACzC;"}

package/out/replicache/src/format-version-enum.js

@@ -0,0 +1,11 @@
+const DD31 = 5;
+const V6 = 6;
+const V7 = 7;
+const Latest = V7;
+export {
+  DD31,
+  Latest,
+  V6,
+  V7
+};
+//# sourceMappingURL=format-version-enum.js.map

package/out/replicache/src/format-version-enum.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-version-enum.js","sources":["../../../../replicache/src/format-version-enum.ts"],"sourcesContent":["export const SDD = 4;\nexport const DD31 = 5;\n// V6 added refreshHashes and persistHash to Client to fix ChunkNotFound errors\nexport const V6 = 6;\n// V7 added sizeOfEntry to the BTree chunk data.\nexport const V7 = 7;\nexport const Latest = V7;\n\nexport type SDD = typeof SDD;\nexport type DD31 = typeof DD31;\nexport type V6 = typeof V6;\nexport type V7 = typeof V7;\nexport type Latest = typeof Latest;\n"],"names":[],"mappings":"AACO,MAAM,OAAO;AAEb,MAAM,KAAK;AAEX,MAAM,KAAK;AACX,MAAM,SAAS;"}

package/out/{chunk-EZM3XBAB.js → replicache/src/frozen-json.js}

@@ -1,63 +1,7 @@
-// ../shared/src/asserts.ts
-function assert(b, msg = "Assertion failed") {
-  if (!b) {
-    throw new Error(typeof msg === "string" ? msg : msg());
-  }
-}
-function assertString(v) {
-  assertType(v, "string");
-}
-function assertNumber(v) {
-  assertType(v, "number");
-}
-function assertBoolean(v) {
-  assertType(v, "boolean");
-}
-function assertType(v, t) {
-  if (typeof v !== t) {
-    throwInvalidType(v, t);
-  }
-}
-function assertObject(v) {
-  if (v === null) {
-    throwInvalidType(v, "object");
-  }
-  assertType(v, "object");
-}
-function assertArray(v) {
-  if (!Array.isArray(v)) {
-    throwInvalidType(v, "array");
-  }
-}
-function invalidType(v, t) {
-  let s = "Invalid type: ";
-  if (v === null || v === void 0) {
-    s += v;
-  } else {
-    s += `${typeof v} \`${v}\``;
-  }
-  return s + `, expected ${t}`;
-}
-function throwInvalidType(v, t) {
-  throw new Error(invalidType(v, t));
-}
-function assertNotNull(v) {
-  if (v === null) {
-    throw new Error("Expected non-null value");
-  }
-}
-function unreachable(_) {
-  throw new Error("Unreachable");
-}
-
-// ../shared/src/has-own.ts
-var { hasOwn } = Object;
-
-// ../shared/src/config.ts
-var isProd = process.env.NODE_ENV === "production";
-
-// ../replicache/src/frozen-json.ts
-var deepFrozenObjects = /* @__PURE__ */ new WeakSet();
+import { throwInvalidType } from "../../shared/src/asserts.js";
+import { isProd } from "../../shared/src/config.js";
+import { hasOwn } from "../../shared/src/has-own.js";
+const deepFrozenObjects = /* @__PURE__ */ new WeakSet();
 function deepFreeze(v) {
   if (isProd) {
     return v;
@@ -172,21 +116,10 @@ function deepFreezeAllowUndefined(v) {
   }
   return deepFreeze(v);
 }
-
 export {
-  assert,
-  assertString,
-  assertNumber,
-  assertBoolean,
-  assertObject,
-  assertArray,
-  throwInvalidType,
-  assertNotNull,
-  unreachable,
-  isProd,
-  hasOwn,
-  deepFreeze,
   assertDeepFrozen,
-  deepFreezeAllowUndefined
+  deepFreeze,
+  deepFreezeAllowUndefined,
+  isDeepFrozen
 };
-//# sourceMappingURL=chunk-EZM3XBAB.js.map
+//# sourceMappingURL=frozen-json.js.map

package/out/replicache/src/frozen-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"frozen-json.js","sources":["../../../../replicache/src/frozen-json.ts"],"sourcesContent":["import {throwInvalidType} from '../../shared/src/asserts.ts';\nimport {skipAssertJSONValue} from '../../shared/src/config.ts';\nimport {hasOwn} from '../../shared/src/has-own.ts';\nimport type {\n  ReadonlyJSONObject,\n  ReadonlyJSONValue,\n} from '../../shared/src/json.ts';\nimport {skipFreeze, skipFrozenAsserts} from './config.ts';\nimport type {Cookie, FrozenCookie} from './cookies.ts';\n\ndeclare const frozenJSONTag: unique symbol;\n\n/**\n * Used to mark a type as having been frozen.\n */\nexport type FrozenTag<T> = T & {readonly [frozenJSONTag]: true};\n\nexport type FrozenJSONValue =\n  | null\n  | string\n  | boolean\n  | number\n  | FrozenJSONArray\n  | FrozenJSONObject;\n\ntype FrozenJSONArray = FrozenTag<ReadonlyArray<FrozenJSONValue>>;\n\nexport type FrozenJSONObject = FrozenTag<{\n  readonly [key: string]: FrozenJSONValue;\n}>;\n\n/**\n * We tag deep frozen objects in debug mode so that we do not have to deep\n * freeze an object more than once.\n */\nconst deepFrozenObjects = new WeakSet<object>();\n\n/**\n * Recursively freezes the passed in value (mutates it) and returns it.\n *\n * This is controlled by `skipFreeze` which is true in release mode.\n */\nexport function deepFreeze(v: Cookie): FrozenCookie;\nexport function deepFreeze(v: ReadonlyJSONValue): FrozenJSONValue;\nexport function deepFreeze(v: ReadonlyJSONValue): FrozenJSONValue {\n  if (skipFreeze) {\n    return v as FrozenJSONValue;\n  }\n\n  deepFreezeInternal(v, []);\n  return v as FrozenJSONValue;\n}\n\nfunction deepFreezeInternal(\n  v: ReadonlyJSONValue | undefined,\n  seen: object[],\n): void {\n  switch (typeof v) {\n    case 'undefined':\n      throw new TypeError('Unexpected value undefined');\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return;\n    case 'object': {\n      if (v === null) {\n        return;\n      }\n\n      if (deepFrozenObjects.has(v)) {\n        return;\n      }\n      deepFrozenObjects.add(v);\n\n      if (seen.includes(v)) {\n        throwInvalidType(v, 'Cyclic JSON object');\n      }\n\n      seen.push(v);\n\n      Object.freeze(v);\n      if (Array.isArray(v)) {\n        deepFreezeArray(v, seen);\n      } else {\n        deepFreezeObject(v as ReadonlyJSONObject, seen);\n      }\n      seen.pop();\n      return;\n    }\n\n    default:\n      throwInvalidType(v, 'JSON value');\n  }\n}\n\nfunction deepFreezeArray(\n  v: ReadonlyArray<ReadonlyJSONValue>,\n  seen: object[],\n): void {\n  for (const item of v) {\n    deepFreezeInternal(item, seen);\n  }\n}\n\nfunction deepFreezeObject(v: ReadonlyJSONObject, seen: object[]): void {\n  for (const k in v) {\n    if (hasOwn(v, k)) {\n      const value = v[k];\n      if (value !== undefined) {\n        deepFreezeInternal(value, seen);\n      }\n    }\n  }\n}\n\nexport function assertFrozenJSONValue(\n  v: unknown,\n): asserts v is FrozenJSONValue {\n  if (skipFrozenAsserts || skipAssertJSONValue) {\n    return;\n  }\n\n  switch (typeof v) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return;\n    case 'object':\n      if (v === null) {\n        return;\n      }\n\n      if (isDeepFrozen(v, [])) {\n        return;\n      }\n  }\n  throwInvalidType(v, 'JSON value');\n}\n\nexport function assertDeepFrozen<V>(v: V): asserts v is Readonly<V> {\n  if (skipFrozenAsserts) {\n    return;\n  }\n\n  if (!isDeepFrozen(v, [])) {\n    throw new Error('Expected frozen object');\n  }\n}\n\n/**\n * Recursive deep frozen check.\n *\n * It adds frozen objects to the {@link deepFrozenObjects} WeakSet so that we do\n * not have to check the same object more than once.\n */\nexport function isDeepFrozen(v: unknown, seen: object[]): boolean {\n  switch (typeof v) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return true;\n    case 'object':\n      if (v === null) {\n        return true;\n      }\n\n      if (deepFrozenObjects.has(v)) {\n        return true;\n      }\n\n      if (!Object.isFrozen(v)) {\n        return false;\n      }\n\n      if (seen.includes(v)) {\n        throwInvalidType(v, 'Cyclic JSON object');\n      }\n\n      seen.push(v);\n\n      if (Array.isArray(v)) {\n        for (const item of v) {\n          if (!isDeepFrozen(item, seen)) {\n            seen.pop();\n            return false;\n          }\n        }\n      } else {\n        for (const k in v) {\n          if (hasOwn(v, k)) {\n            const value = (v as Record<string, unknown>)[k];\n            if (value !== undefined && !isDeepFrozen(value, seen)) {\n              seen.pop();\n              return false;\n            }\n          }\n        }\n      }\n\n      deepFrozenObjects.add(v);\n      seen.pop();\n      return true;\n\n    default:\n      throwInvalidType(v, 'JSON value');\n  }\n}\n\nexport type P = Parameters<typeof deepFreeze>[0];\nexport type R = ReturnType<typeof deepFreeze>;\nexport function deepFreezeAllowUndefined(v: P | undefined): R | undefined {\n  if (v === undefined) {\n    return undefined;\n  }\n  return deepFreeze(v) as R;\n}\n"],"names":["skipFreeze","skipFrozenAsserts"],"mappings":";;;AAmCA,MAAM,wCAAwB,QAAA;AASvB,SAAS,WAAW,GAAuC;AAChE,MAAIA,QAAY;AACd,WAAO;AAAA,EACT;AAEA,qBAAmB,GAAG,EAAE;AACxB,SAAO;AACT;AAEA,SAAS,mBACP,GACA,MACM;AACN,UAAQ,OAAO,GAAA;AAAA,IACb,KAAK;AACH,YAAM,IAAI,UAAU,4BAA4B;AAAA,IAClD,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH;AAAA,IACF,KAAK,UAAU;AACb,UAAI,MAAM,MAAM;AACd;AAAA,MACF;AAEA,UAAI,kBAAkB,IAAI,CAAC,GAAG;AAC5B;AAAA,MACF;AACA,wBAAkB,IAAI,CAAC;AAEvB,UAAI,KAAK,SAAS,CAAC,GAAG;AACpB,yBAAiB,GAAG,oBAAoB;AAAA,MAC1C;AAEA,WAAK,KAAK,CAAC;AAEX,aAAO,OAAO,CAAC;AACf,UAAI,MAAM,QAAQ,CAAC,GAAG;AACpB,wBAAgB,GAAG,IAAI;AAAA,MACzB,OAAO;AACL,yBAAiB,GAAyB,IAAI;AAAA,MAChD;AACA,WAAK,IAAA;AACL;AAAA,IACF;AAAA,IAEA;AACE,uBAAiB,GAAG,YAAY;AAAA,EAAA;AAEtC;AAEA,SAAS,gBACP,GACA,MACM;AACN,aAAW,QAAQ,GAAG;AACpB,uBAAmB,MAAM,IAAI;AAAA,EAC/B;AACF;AAEA,SAAS,iBAAiB,GAAuB,MAAsB;AACrE,aAAW,KAAK,GAAG;AACjB,QAAI,OAAO,GAAG,CAAC,GAAG;AAChB,YAAM,QAAQ,EAAE,CAAC;AACjB,UAAI,UAAU,QAAW;AACvB,2BAAmB,OAAO,IAAI;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AACF;AA0BO,SAAS,iBAAoB,GAAgC;AAClE,MAAIC,QAAmB;AACrB;AAAA,EACF;AAEA,MAAI,CAAC,aAAa,GAAG,CAAA,CAAE,GAAG;AACxB,UAAM,IAAI,MAAM,wBAAwB;AAAA,EAC1C;AACF;AAQO,SAAS,aAAa,GAAY,MAAyB;AAChE,UAAQ,OAAO,GAAA;AAAA,IACb,KAAK;AAAA,IACL,KAAK;AAAA,IACL,KAAK;AACH,aAAO;AAAA,IACT,KAAK;AACH,UAAI,MAAM,MAAM;AACd,eAAO;AAAA,MACT;AAEA,UAAI,kBAAkB,IAAI,CAAC,GAAG;AAC5B,eAAO;AAAA,MACT;AAEA,UAAI,CAAC,OAAO,SAAS,CAAC,GAAG;AACvB,eAAO;AAAA,MACT;AAEA,UAAI,KAAK,SAAS,CAAC,GAAG;AACpB,yBAAiB,GAAG,oBAAoB;AAAA,MAC1C;AAEA,WAAK,KAAK,CAAC;AAEX,UAAI,MAAM,QAAQ,CAAC,GAAG;AACpB,mBAAW,QAAQ,GAAG;AACpB,cAAI,CAAC,aAAa,MAAM,IAAI,GAAG;AAC7B,iBAAK,IAAA;AACL,mBAAO;AAAA,UACT;AAAA,QACF;AAAA,MACF,OAAO;AACL,mBAAW,KAAK,GAAG;AACjB,cAAI,OAAO,GAAG,CAAC,GAAG;AAChB,kBAAM,QAAS,EAA8B,CAAC;AAC9C,gBAAI,UAAU,UAAa,CAAC,aAAa,OAAO,IAAI,GAAG;AACrD,mBAAK,IAAA;AACL,qBAAO;AAAA,YACT;AAAA,UACF;AAAA,QACF;AAAA,MACF;AAEA,wBAAkB,IAAI,CAAC;AACvB,WAAK,IAAA;AACL,aAAO;AAAA,IAET;AACE,uBAAiB,GAAG,YAAY;AAAA,EAAA;AAEtC;AAIO,SAAS,yBAAyB,GAAiC;AACxE,MAAI,MAAM,QAAW;AACnB,WAAO;AAAA,EACT;AACA,SAAO,WAAW,CAAC;AACrB;"}