@rocicorp/zero 1.6.0-canary.0 → 1.6.0-canary.10

package/out/replicache/src/transactions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"transactions.js","names":["#keys","#scans","#tx"],"sources":["../../../../replicache/src/transactions.ts"],"sourcesContent":["import type {LogContext} from '@rocicorp/logger';\nimport {greaterThan} from 'compare-utf8';\nimport type {JSONValue, ReadonlyJSONValue} from '../../shared/src/json.ts';\nimport {type IndexKey, decodeIndexKey} from './db/index.ts';\nimport type {Read} from './db/read.ts';\nimport type {Write} from './db/write.ts';\nimport {deepFreeze} from './frozen-json.ts';\nimport type {IndexDefinition} from './index-defs.ts';\nimport type {ZeroTxData} from './replicache-options.ts';\nimport type {ScanResult} from './scan-iterator.ts';\nimport {ScanResultImpl, fromKeyForIndexScanInternal} from './scan-iterator.ts';\nimport {\n  type KeyTypeForScanOptions,\n  type ScanIndexOptions,\n  type ScanNoIndexOptions,\n  type ScanOptions,\n  isScanIndexOptions,\n  toDbScanOptions,\n} from './scan-options.ts';\nimport type {ScanSubscriptionInfo} from './subscriptions.ts';\nimport type {ClientID} from './sync/ids.ts';\nimport {rejectIfClosed, throwIfClosed} from './transaction-closed-error.ts';\n\nexport type TransactionEnvironment = 'client' | 'server';\nexport type TransactionLocation = TransactionEnvironment;\nexport type TransactionReason = 'initial' | 'rebase' | 'authoritative';\n\n/**\n * Basic deep readonly type. It works for {@link JSONValue}.\n */\nexport type DeepReadonly<T> = T extends\n  | null\n  | boolean\n  | string\n  | number\n  | undefined\n  ? T\n  : DeepReadonlyObject<T>;\n\nexport type DeepReadonlyObject<T> = {\n  readonly [K in keyof T]: DeepReadonly<T[K]>;\n};\n\n/**\n * ReadTransactions are used with {@link Replicache.query} and\n * {@link Replicache.subscribe} and allows read operations on the\n * database.\n */\nexport interface ReadTransaction {\n  readonly clientID: ClientID;\n  /** @deprecated Use {@link ReadTransaction.location} instead. */\n  readonly environment: TransactionLocation;\n  readonly location: TransactionLocation;\n\n  /**\n   * Get a single value from the database. If the `key` is not present this\n   * returns `undefined`.\n   *\n   * Important: The returned JSON is readonly and should not be modified. This\n   * is only enforced statically by TypeScript and there are no runtime checks\n   * for performance reasons. If you mutate the return value you will get\n   * undefined behavior.\n   */\n\n  get(key: string): Promise<ReadonlyJSONValue | undefined>;\n  get<T extends JSONValue>(key: string): Promise<DeepReadonly<T> | undefined>;\n\n  /** Determines if a single `key` is present in the database. */\n  has(key: string): Promise<boolean>;\n\n  /** Whether the database is empty. */\n  isEmpty(): Promise<boolean>;\n\n  /**\n   * Gets many values from the database. This returns a {@link ScanResult} which\n   * implements `AsyncIterable`. It also has methods to iterate over the\n   * {@link ScanResult.keys | keys} and {@link ScanResult.entries | entries}.\n   *\n   * If `options` has an `indexName`, then this does a scan over an index with\n   * that name. A scan over an index uses a tuple for the key consisting of\n   * `[secondary: string, primary: string]`.\n   *\n   * If the {@link ScanResult} is used after the `ReadTransaction` has been closed\n   * it will throw a {@link TransactionClosedError}.\n   *\n   * Important: The returned JSON is readonly and should not be modified. This\n   * is only enforced statically by TypeScript and there are no runtime checks\n   * for performance reasons. If you mutate the return value you will get\n   * undefined behavior.\n   */\n  scan(options: ScanIndexOptions): ScanResult<IndexKey, ReadonlyJSONValue>;\n  scan(options?: ScanNoIndexOptions): ScanResult<string, ReadonlyJSONValue>;\n  scan(options?: ScanOptions): ScanResult<IndexKey | string, ReadonlyJSONValue>;\n\n  scan<V extends ReadonlyJSONValue>(\n    options: ScanIndexOptions,\n  ): ScanResult<IndexKey, DeepReadonly<V>>;\n  scan<V extends ReadonlyJSONValue>(\n    options?: ScanNoIndexOptions,\n  ): ScanResult<string, DeepReadonly<V>>;\n  scan<V extends ReadonlyJSONValue>(\n    options?: ScanOptions,\n  ): ScanResult<IndexKey | string, DeepReadonly<V>>;\n}\n\nlet transactionIDCounter = 0;\n\nexport class ReadTransactionImpl implements ReadTransaction {\n  readonly clientID: ClientID;\n  readonly dbtx: Read;\n  protected readonly _lc: LogContext;\n\n  /**\n   * The location in which this transaction is being used. This is either `client` or `server`.\n   */\n  readonly location: TransactionLocation;\n  /** @deprecated Use {@link ReadTransaction.location} instead. */\n  readonly environment: TransactionLocation;\n\n  constructor(\n    clientID: ClientID,\n    dbRead: Read,\n    lc: LogContext,\n    rpcName = 'openReadTransaction',\n  ) {\n    this.clientID = clientID;\n    this.dbtx = dbRead;\n    this._lc = lc\n      .withContext(rpcName)\n      .withContext('txid', transactionIDCounter++);\n    this.environment = 'client';\n    this.location = 'client';\n  }\n\n  get(key: string): Promise<ReadonlyJSONValue | undefined>;\n  get<V extends JSONValue>(key: string): Promise<DeepReadonly<V> | undefined> {\n    return (\n      rejectIfClosed(this.dbtx) ||\n      (this.dbtx.get(key) as Promise<DeepReadonly<V> | undefined>)\n    );\n  }\n\n  // oxlint-disable-next-line require-await\n  async has(key: string): Promise<boolean> {\n    throwIfClosed(this.dbtx);\n    return this.dbtx.has(key);\n  }\n\n  // oxlint-disable-next-line require-await\n  async isEmpty(): Promise<boolean> {\n    throwIfClosed(this.dbtx);\n    return this.dbtx.isEmpty();\n  }\n\n  scan(options: ScanIndexOptions): ScanResult<IndexKey, ReadonlyJSONValue>;\n  scan(options?: ScanNoIndexOptions): ScanResult<string, ReadonlyJSONValue>;\n  scan(options?: ScanOptions): ScanResult<IndexKey | string, ReadonlyJSONValue>;\n\n  scan<V extends ReadonlyJSONValue>(\n    options: ScanIndexOptions,\n  ): ScanResult<IndexKey, DeepReadonly<V>>;\n  scan<V extends ReadonlyJSONValue>(\n    options?: ScanNoIndexOptions,\n  ): ScanResult<string, DeepReadonly<V>>;\n  scan<V extends ReadonlyJSONValue>(\n    options?: ScanOptions,\n  ): ScanResult<IndexKey | string, DeepReadonly<V>>;\n\n  scan(\n    options?: ScanOptions,\n  ): ScanResult<IndexKey | string, ReadonlyJSONValue> {\n    return scan(options, this.dbtx, noop);\n  }\n}\n\nfunction noop(_: unknown): void {\n  // empty\n}\n\nfunction scan<Options extends ScanOptions, V extends JSONValue>(\n  options: Options | undefined,\n  dbRead: Read,\n  onLimitKey: (inclusiveLimitKey: string) => void,\n): ScanResult<KeyTypeForScanOptions<Options>, V> {\n  const iter = getScanIterator<Options, V>(dbRead, options);\n  return makeScanResultFromScanIteratorInternal(\n    iter,\n    options ?? ({} as Options),\n    dbRead,\n    onLimitKey,\n  );\n}\n\n// An implementation of ReadTransaction that keeps track of `keys` and `scans`\n// for use with Subscriptions.\nexport class SubscriptionTransactionWrapper implements ReadTransaction {\n  readonly #keys: Set<string> = new Set();\n  readonly #scans: ScanSubscriptionInfo[] = [];\n  readonly #tx: ReadTransactionImpl;\n\n  constructor(tx: ReadTransactionImpl) {\n    this.#tx = tx;\n  }\n\n  get environment(): TransactionLocation {\n    return this.#tx.location;\n  }\n\n  get location(): TransactionLocation {\n    return this.#tx.location;\n  }\n\n  get clientID(): string {\n    return this.#tx.clientID;\n  }\n\n  isEmpty(): Promise<boolean> {\n    // Any change to the subscription requires rerunning it.\n    this.#scans.push({options: {}});\n    return this.#tx.isEmpty();\n  }\n\n  get(key: string): Promise<ReadonlyJSONValue | undefined>;\n  get<T extends JSONValue>(key: string): Promise<DeepReadonly<T> | undefined> {\n    this.#keys.add(key);\n    return this.#tx.get(key) as Promise<DeepReadonly<T> | undefined>;\n  }\n\n  has(key: string): Promise<boolean> {\n    this.#keys.add(key);\n    return this.#tx.has(key);\n  }\n\n  scan(options: ScanIndexOptions): ScanResult<IndexKey, ReadonlyJSONValue>;\n  scan(options?: ScanNoIndexOptions): ScanResult<string, ReadonlyJSONValue>;\n  scan(options?: ScanOptions): ScanResult<IndexKey | string, ReadonlyJSONValue>;\n\n  scan<V extends ReadonlyJSONValue>(\n    options: ScanIndexOptions,\n  ): ScanResult<IndexKey, DeepReadonly<V>>;\n  scan<V extends ReadonlyJSONValue>(\n    options?: ScanNoIndexOptions,\n  ): ScanResult<string, DeepReadonly<V>>;\n  scan<V extends ReadonlyJSONValue>(\n    options?: ScanOptions,\n  ): ScanResult<IndexKey | string, DeepReadonly<V>>;\n\n  scan(\n    options?: ScanOptions,\n  ): ScanResult<IndexKey | string, ReadonlyJSONValue> {\n    const scanInfo: ScanSubscriptionInfo = {\n      options: toDbScanOptions(options),\n      inclusiveLimitKey: undefined,\n    };\n    this.#scans.push(scanInfo);\n    return scan(options, this.#tx.dbtx, inclusiveLimitKey => {\n      scanInfo.inclusiveLimitKey = inclusiveLimitKey;\n    });\n  }\n\n  get keys(): ReadonlySet<string> {\n    return this.#keys;\n  }\n\n  get scans(): ScanSubscriptionInfo[] {\n    return this.#scans;\n  }\n}\n\n/**\n * WriteTransactions are used with *mutators* which are registered using\n * {@link ReplicacheOptions.mutators} and allows read and write operations on the\n * database.\n */\nexport interface WriteTransaction extends ReadTransaction {\n  /**\n   * The ID of the mutation that is being applied.\n   */\n  readonly mutationID: number;\n\n  /**\n   * The reason for the transaction. This can be `initial`, `rebase` or `authoriative`.\n   */\n  readonly reason: TransactionReason;\n\n  /**\n   * Sets a single `value` in the database. The value will be frozen (using\n   * `Object.freeze`) in debug mode.\n   */\n  set(key: string, value: ReadonlyJSONValue): Promise<void>;\n\n  /**\n   * @deprecated Use {@link WriteTransaction.set} instead.\n   */\n  put(key: string, value: ReadonlyJSONValue): Promise<void>;\n\n  /**\n   * Removes a `key` and its value from the database. Returns `true` if there was a\n   * `key` to remove.\n   */\n  del(key: string): Promise<boolean>;\n}\n\n// Internal symbol, not exported by Replicache\n// but accessible to Zero.\nexport const zeroData = Symbol();\n\nexport class WriteTransactionImpl\n  extends ReadTransactionImpl\n  implements WriteTransaction\n{\n  // use `declare` to specialize the type.\n  declare readonly dbtx: Write;\n  readonly reason: TransactionReason;\n  readonly mutationID: number;\n  readonly [zeroData]: ZeroTxData | undefined;\n\n  constructor(\n    clientID: ClientID,\n    mutationID: number,\n    reason: TransactionReason,\n    zData: ZeroTxData | undefined,\n    dbWrite: Write,\n    lc: LogContext,\n    rpcName = 'openWriteTransaction',\n  ) {\n    super(clientID, dbWrite, lc, rpcName);\n    this.mutationID = mutationID;\n    this.reason = reason;\n    this[zeroData] = zData;\n  }\n\n  put(key: string, value: ReadonlyJSONValue): Promise<void> {\n    return this.set(key, value);\n  }\n\n  async set(key: string, value: ReadonlyJSONValue): Promise<void> {\n    throwIfClosed(this.dbtx);\n    await this.dbtx.put(this._lc, key, deepFreeze(value));\n  }\n\n  del(key: string): Promise<boolean> {\n    return rejectIfClosed(this.dbtx) ?? this.dbtx.del(this._lc, key);\n  }\n}\n\nexport type CreateIndexDefinition = IndexDefinition & {name: string};\n\ntype Entry<Key, Value> = readonly [key: Key, value: Value];\n\ntype IndexKeyEntry<Value> = Entry<IndexKey, Value>;\n\ntype StringKeyEntry<Value> = Entry<string, Value>;\n\nexport type EntryForOptions<\n  Options extends ScanOptions,\n  V,\n> = Options extends ScanIndexOptions ? IndexKeyEntry<V> : StringKeyEntry<V>;\n\nfunction getScanIterator<Options extends ScanOptions, V>(\n  dbRead: Read,\n  options: Options | undefined,\n): AsyncIterable<EntryForOptions<Options, V>> {\n  if (options && isScanIndexOptions(options)) {\n    return getScanIteratorForIndexMap(dbRead, options) as AsyncIterable<\n      EntryForOptions<Options, V>\n    >;\n  }\n\n  return dbRead.map.scan(fromKeyForNonIndexScan(options)) as AsyncIterable<\n    EntryForOptions<Options, V>\n  >;\n}\n\nexport function fromKeyForNonIndexScan(\n  options: ScanNoIndexOptions | undefined,\n): string {\n  if (!options) {\n    return '';\n  }\n\n  const {prefix = '', start} = options;\n  if (start && greaterThan(start.key, prefix)) {\n    return start.key;\n  }\n  return prefix;\n}\n\nfunction makeScanResultFromScanIteratorInternal<\n  Options extends ScanOptions,\n  V extends JSONValue,\n>(\n  iter: AsyncIterable<EntryForOptions<Options, V>>,\n  options: Options,\n  dbRead: Read,\n  onLimitKey: (inclusiveLimitKey: string) => void,\n): ScanResult<KeyTypeForScanOptions<Options>, V> {\n  return new ScanResultImpl(iter, options, dbRead, onLimitKey);\n}\n\nasync function* getScanIteratorForIndexMap(\n  dbRead: Read,\n  options: ScanIndexOptions,\n): AsyncIterable<IndexKeyEntry<ReadonlyJSONValue>> {\n  const map = dbRead.getMapForIndex(options.indexName);\n  for await (const entry of map.scan(fromKeyForIndexScanInternal(options))) {\n    yield [decodeIndexKey(entry[0]), entry[1]];\n  }\n}\n"],"mappings":"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"}

package/out/replicache/src/version.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"version.js","names":[],"sources":["../../../../replicache/src/version.ts"],"sourcesContent":["// The env value should be filled in by esbuild.\n\ndeclare const process: {\n  env: {\n    ['REPLICACHE_VERSION']?: string;\n  };\n};\n\n/**\n * The current version of Replicache.\n */\nexport const version: string = process.env.REPLICACHE_VERSION ?? '0.0.0';\n"],"mappings":";;;;AAWA,IAAa,UAAA"}

package/out/replicache/src/with-transactions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"with-transactions.js","names":[],"sources":["../../../../replicache/src/with-transactions.ts"],"sourcesContent":["export interface Release {\n  release(): void;\n}\n\nexport interface Commit {\n  commit(): Promise<void>;\n}\n\ninterface ReadStore<Read extends Release> {\n  read(): Promise<Read>;\n}\n\ninterface WriteStore<Write extends Release> {\n  write(): Promise<Write>;\n}\n\nexport function withRead<Read extends Release, Return>(\n  store: ReadStore<Read>,\n  fn: (read: Read) => Return | Promise<Return>,\n): Promise<Return> {\n  return using(store.read(), fn);\n}\n\nexport function withWriteNoImplicitCommit<Write extends Release, Return>(\n  store: WriteStore<Write>,\n  fn: (write: Write) => Return | Promise<Return>,\n): Promise<Return> {\n  return using(store.write(), fn);\n}\n\nexport function withWrite<Write extends Release & Commit, Return>(\n  store: WriteStore<Write>,\n  fn: (write: Write) => Return | Promise<Return>,\n): Promise<Return> {\n  return using(store.write(), async write => {\n    const result = await fn(write);\n    await write.commit();\n    return result;\n  });\n}\n\n/**\n * This function takes a promise for a resource and a function that uses that\n * resource. It will release the resource after the function returns by calling\n * the `release` function\n */\nexport async function using<TX extends Release, Return>(\n  x: Promise<TX>,\n  fn: (tx: TX) => Return | Promise<Return>,\n): Promise<Return> {\n  const write = await x;\n  let result: Return | undefined;\n  let operationError: unknown;\n  try {\n    result = await fn(write);\n  } catch (e) {\n    operationError = e;\n  }\n\n  try {\n    write.release();\n  } catch (releaseError) {\n    if (operationError !== undefined) {\n      const combinedError = new Error(\n        `Transaction operation failed and release also failed: operation error = ${String(\n          operationError,\n        )}; release error = ${String(releaseError)}`,\n      );\n      combinedError.cause = operationError;\n      throw combinedError;\n    }\n    throw releaseError;\n  }\n\n  if (operationError !== undefined) {\n    throw operationError;\n  }\n  return result as Return;\n}\n"],"mappings":";AAgBA,SAAgB,SACd,OACA,IACiB;AACjB,QAAO,MAAM,MAAM,MAAM,EAAE,GAAG;;AAGhC,SAAgB,0BACd,OACA,IACiB;AACjB,QAAO,MAAM,MAAM,OAAO,EAAE,GAAG;;AAGjC,SAAgB,UACd,OACA,IACiB;AACjB,QAAO,MAAM,MAAM,OAAO,EAAE,OAAM,UAAS;EACzC,MAAM,SAAS,MAAM,GAAG,MAAM;AAC9B,QAAM,MAAM,QAAQ;AACpB,SAAO;GACP;;;;;;;AAQJ,eAAsB,MACpB,GACA,IACiB;CACjB,MAAM,QAAQ,MAAM;CACpB,IAAI;CACJ,IAAI;AACJ,KAAI;AACF,WAAS,MAAM,GAAG,MAAM;UACjB,GAAG;AACV,mBAAiB;;AAGnB,KAAI;AACF,QAAM,SAAS;UACR,cAAc;AACrB,MAAI,mBAAmB,KAAA,GAAW;GAChC,MAAM,gCAAgB,IAAI,MACxB,2EAA2E,OACzE,eACD,CAAC,oBAAoB,OAAO,aAAa,GAC3C;AACD,iBAAc,QAAQ;AACtB,SAAM;;AAER,QAAM;;AAGR,KAAI,mBAAmB,KAAA,EACrB,OAAM;AAER,QAAO"}

package/out/shared/src/abort-error.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"abort-error.js","names":[],"sources":["../../../../shared/src/abort-error.ts"],"sourcesContent":["export class AbortError extends Error {\n  name = 'AbortError';\n}\n"],"mappings":";AAAA,IAAa,aAAb,cAAgC,MAAM;CACpC,OAAO"}

package/out/shared/src/arrays.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrays.js","names":[],"sources":["../../../../shared/src/arrays.ts"],"sourcesContent":["import {assert} from './asserts.ts';\n\n/**\n * Returns `arr` as is if none of the elements are `undefined`.\n * Otherwise returns a new array with only defined elements in `arr`.\n */\nexport function defined<T>(arr: (T | undefined)[]): T[] {\n  // avoid an array copy if possible\n  let i = arr.findIndex(x => x === undefined);\n  if (i < 0) {\n    return arr as T[];\n  }\n  const defined: T[] = arr.slice(0, i) as T[];\n  for (i++; i < arr.length; i++) {\n    const x = arr[i];\n    if (x !== undefined) {\n      defined.push(x);\n    }\n  }\n  return defined;\n}\n\nexport function areEqual<T>(arr1: readonly T[], arr2: readonly T[]): boolean {\n  return arr1.length === arr2.length && arr1.every((e, i) => e === arr2[i]);\n}\n\nexport function zip<T1, T2>(a1: readonly T1[], a2: readonly T2[]): [T1, T2][] {\n  assert(a1.length === a2.length, 'zip: arrays must have equal length');\n  const result: [T1, T2][] = [];\n  for (let i = 0; i < a1.length; i++) {\n    result.push([a1[i], a2[i]]);\n  }\n  return result;\n}\n\nexport function last<T>(arr: T[]): T | undefined {\n  return arr.at(-1);\n}\n\nexport function groupBy<T, K>(\n  arr: readonly T[],\n  keyFn: (el: T) => K,\n): Map<K, T[]> {\n  const groups = new Map<K, T[]>();\n  for (const el of arr) {\n    const key = keyFn(el);\n    let group = groups.get(key);\n    if (group === undefined) {\n      group = [];\n      groups.set(key, group);\n    }\n    group.push(el);\n  }\n  return groups;\n}\n"],"mappings":";;;;;;AAMA,SAAgB,QAAW,KAA6B;CAEtD,IAAI,IAAI,IAAI,WAAU,MAAK,MAAM,KAAA,EAAU;AAC3C,KAAI,IAAI,EACN,QAAO;CAET,MAAM,UAAe,IAAI,MAAM,GAAG,EAAE;AACpC,MAAK,KAAK,IAAI,IAAI,QAAQ,KAAK;EAC7B,MAAM,IAAI,IAAI;AACd,MAAI,MAAM,KAAA,EACR,SAAQ,KAAK,EAAE;;AAGnB,QAAO;;AAGT,SAAgB,SAAY,MAAoB,MAA6B;AAC3E,QAAO,KAAK,WAAW,KAAK,UAAU,KAAK,OAAO,GAAG,MAAM,MAAM,KAAK,GAAG;;AAG3E,SAAgB,IAAY,IAAmB,IAA+B;AAC5E,QAAO,GAAG,WAAW,GAAG,QAAQ,qCAAqC;CACrE,MAAM,SAAqB,EAAE;AAC7B,MAAK,IAAI,IAAI,GAAG,IAAI,GAAG,QAAQ,IAC7B,QAAO,KAAK,CAAC,GAAG,IAAI,GAAG,GAAG,CAAC;AAE7B,QAAO;;AAGT,SAAgB,KAAQ,KAAyB;AAC/C,QAAO,IAAI,GAAG,GAAG;;AAGnB,SAAgB,QACd,KACA,OACa;CACb,MAAM,yBAAS,IAAI,KAAa;AAChC,MAAK,MAAM,MAAM,KAAK;EACpB,MAAM,MAAM,MAAM,GAAG;EACrB,IAAI,QAAQ,OAAO,IAAI,IAAI;AAC3B,MAAI,UAAU,KAAA,GAAW;AACvB,WAAQ,EAAE;AACV,UAAO,IAAI,KAAK,MAAM;;AAExB,QAAM,KAAK,GAAG;;AAEhB,QAAO"}

package/out/shared/src/asserts.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"asserts.js","names":[],"sources":["../../../../shared/src/asserts.ts"],"sourcesContent":["export function assert(b: unknown, msg: string | (() => string)): asserts b {\n  if (!b) {\n    throw new Error(typeof msg === 'string' ? msg : msg());\n  }\n}\n\nexport function assertString(v: unknown): asserts v is string {\n  assertType(v, 'string');\n}\n\nexport function assertNumber(v: unknown): asserts v is number {\n  assertType(v, 'number');\n}\n\nexport function assertBoolean(v: unknown): asserts v is boolean {\n  assertType(v, 'boolean');\n}\n\nfunction assertType(v: unknown, t: string) {\n  if (typeof v !== t) {\n    throwInvalidType(v, t);\n  }\n}\n\nexport function assertObject(v: unknown): asserts v is Record<string, unknown> {\n  if (v === null) {\n    throwInvalidType(v, 'object');\n  }\n  assertType(v, 'object');\n}\n\nexport function assertArray(v: unknown): asserts v is unknown[] {\n  if (!Array.isArray(v)) {\n    throwInvalidType(v, 'array');\n  }\n}\n\nexport function invalidType(v: unknown, t: string): string {\n  let s = 'Invalid type: ';\n  if (v === null || v === undefined) {\n    s += v;\n  } else {\n    s += `${typeof v} \\`${v}\\``;\n  }\n  return s + `, expected ${t}`;\n}\n\nexport function throwInvalidType(v: unknown, t: string): never {\n  throw new Error(invalidType(v, t));\n}\n\nexport function assertNotNull<T>(v: T | null): asserts v is T {\n  if (v === null) {\n    throw new Error('Expected non-null value');\n  }\n}\n\nexport function assertUndefined<T>(\n  v: T | undefined,\n  msg = 'Expected undefined value',\n): asserts v is T {\n  if (v !== undefined) {\n    throw new Error(msg);\n  }\n}\n\nexport function assertNotUndefined<T>(\n  v: T | undefined,\n  msg = 'Expected non undefined value',\n): asserts v is T {\n  if (v === undefined) {\n    throw new Error(msg);\n  }\n}\n\nexport function assertInstanceof<T>(\n  v: unknown,\n  t: new (...args: unknown[]) => T,\n): asserts v is T {\n  if (!(v instanceof t)) {\n    throw new Error(`Expected instanceof ${t.name}`);\n  }\n}\n\nexport function assertUint8Array(v: unknown): asserts v is Uint8Array {\n  assertInstanceof(v, Uint8Array);\n}\n\nexport function unreachable(): never;\nexport function unreachable(v: never): never;\nexport function unreachable(_?: never): never {\n  throw new Error('Unreachable');\n}\n\nexport function notImplemented(): never {\n  throw new Error('Not implemented');\n}\n"],"mappings":";AAAA,SAAgB,OAAO,GAAY,KAAyC;AAC1E,KAAI,CAAC,EACH,OAAM,IAAI,MAAM,OAAO,QAAQ,WAAW,MAAM,KAAK,CAAC;;AAI1D,SAAgB,aAAa,GAAiC;AAC5D,YAAW,GAAG,SAAS;;AAGzB,SAAgB,aAAa,GAAiC;AAC5D,YAAW,GAAG,SAAS;;AAGzB,SAAgB,cAAc,GAAkC;AAC9D,YAAW,GAAG,UAAU;;AAG1B,SAAS,WAAW,GAAY,GAAW;AACzC,KAAI,OAAO,MAAM,EACf,kBAAiB,GAAG,EAAE;;AAI1B,SAAgB,aAAa,GAAkD;AAC7E,KAAI,MAAM,KACR,kBAAiB,GAAG,SAAS;AAE/B,YAAW,GAAG,SAAS;;AAGzB,SAAgB,YAAY,GAAoC;AAC9D,KAAI,CAAC,MAAM,QAAQ,EAAE,CACnB,kBAAiB,GAAG,QAAQ;;AAIhC,SAAgB,YAAY,GAAY,GAAmB;CACzD,IAAI,IAAI;AACR,KAAI,MAAM,QAAQ,MAAM,KAAA,EACtB,MAAK;KAEL,MAAK,GAAG,OAAO,EAAE,KAAK,EAAE;AAE1B,QAAO,IAAI,cAAc;;AAG3B,SAAgB,iBAAiB,GAAY,GAAkB;AAC7D,OAAM,IAAI,MAAM,YAAY,GAAG,EAAE,CAAC;;AAGpC,SAAgB,cAAiB,GAA6B;AAC5D,KAAI,MAAM,KACR,OAAM,IAAI,MAAM,0BAA0B;;AAa9C,SAAgB,mBACd,GACA,MAAM,gCACU;AAChB,KAAI,MAAM,KAAA,EACR,OAAM,IAAI,MAAM,IAAI;;AAmBxB,SAAgB,YAAY,GAAkB;AAC5C,OAAM,IAAI,MAAM,cAAc"}

package/out/shared/src/bigint-json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bigint-json.js","names":[],"sources":["../../../../shared/src/bigint-json.ts"],"sourcesContent":["/**\n * Background for using `json-custom-numbers`:\n *\n * https://neon.tech/blog/parsing-json-from-postgres-in-js\n */\nimport {\n  parse as customParse,\n  stringify as customStringify,\n} from 'json-custom-numbers';\nimport * as v from './valita.ts';\n\nfunction numberParser(_: unknown, v: string) {\n  const n = +v;\n  if (n >= Number.MIN_SAFE_INTEGER && n <= Number.MAX_SAFE_INTEGER) return n;\n  if (v.includes('.') || v.includes('e') || v.includes('E')) {\n    return n;\n  }\n  return BigInt(v);\n}\n\n// Variant of postgres.JSONValue adapted to include bigints\nexport type JSONValue =\n  | null\n  | string\n  | number\n  | bigint\n  | boolean\n  | readonly JSONValue[]\n  | JSONObject;\n\nexport type JSONObject = {readonly [prop: string]: JSONValue | undefined};\n\nexport const jsonValueSchema: v.Type<JSONValue> = v.lazy(() => {\n  const jsonObjectSchema = v.readonly(v.record(jsonValueSchema));\n\n  return v.union(\n    v.null(),\n    v.string(),\n    v.number(),\n    v.bigint(),\n    v.boolean(),\n    v.readonly(v.array(jsonValueSchema)),\n    jsonObjectSchema,\n  );\n});\n\nexport const jsonObjectSchema = v.readonly(v.record(jsonValueSchema));\n\n/**\n * Parses JSON strings that may contain arbitrarily large integers. Integers\n * larger than {@link Number.MAX_SAFE_INTEGER} are deserialized as a `bigint`.\n */\nexport function parse(\n  str: string,\n  reviver?: (k: string, v: unknown) => unknown,\n): JSONValue {\n  return customParse(str, reviver, numberParser);\n}\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nfunction customSerializer(_: string, v: any, type: string) {\n  if (type === 'bigint') return v.toString();\n}\n\n/**\n * Stringifies objects to JSON, supporting objects containing bigint values.\n * Note that the resulting JSON string may not be deserializable by\n * all environments, but it is supported by Postgres. The string should be\n * deserialized with the corresponding {@link parse} method that will represent\n * large numbers as bigints. From there it is up to the application to suitably\n * handle bigints passed to downstream logic.\n */\nexport function stringify(\n  obj: unknown,\n  replacer?:\n    | (string | number)[]\n    | ((key: string, value: unknown) => unknown)\n    | null,\n  indent?: string | number,\n) {\n  return customStringify(obj, replacer, indent, customSerializer);\n}\n\nexport const BigIntJSON = {\n  parse,\n  stringify,\n} as const;\n"],"mappings":";;;;;;;;AAWA,SAAS,aAAa,GAAY,GAAW;CAC3C,MAAM,IAAI,CAAC;AACX,KAAI,KAAK,OAAO,oBAAoB,KAAK,OAAO,iBAAkB,QAAO;AACzE,KAAI,EAAE,SAAS,IAAI,IAAI,EAAE,SAAS,IAAI,IAAI,EAAE,SAAS,IAAI,CACvD,QAAO;AAET,QAAO,OAAO,EAAE;;AAelB,IAAa,kBAAqC,eAAE,WAAW;CAC7D,MAAM,mBAAmB,SAAW,eAAE,OAAO,gBAAgB,CAAC;AAE9D,QAAO,eAAE,MACP,eAAE,MAAM,EACR,eAAE,QAAQ,EACV,eAAE,QAAQ,EACV,eAAE,QAAQ,EACV,eAAE,SAAS,EACX,SAAW,eAAE,MAAM,gBAAgB,CAAC,EACpC,iBACD;EACD;AAEF,IAAa,mBAAmB,SAAW,eAAE,OAAO,gBAAgB,CAAC;;;;;AAMrE,SAAgB,QACd,KACA,SACW;AACX,QAAO,MAAY,KAAK,SAAS,aAAa;;AAIhD,SAAS,iBAAiB,GAAW,GAAQ,MAAc;AACzD,KAAI,SAAS,SAAU,QAAO,EAAE,UAAU;;;;;;;;;;AAW5C,SAAgB,YACd,KACA,UAIA,QACA;AACA,QAAO,UAAgB,KAAK,UAAU,QAAQ,iBAAiB;;AAGjE,IAAa,aAAa;CACxB,OAAA;CACA,WAAA;CACD"}

package/out/shared/src/binary-search.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary-search.js","names":[],"sources":["../../../../shared/src/binary-search.ts"],"sourcesContent":["/**\n * This is a binary search that returns the index of the first element in the\n * array that is greater than or equal to the given value.\n *\n * Typical usage:\n *\n * ```\n * const haystack = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];\n * const needle = 3;\n * const index = binarySearch(haystack.length, i => needle - haystack[i]);\n * const found = index < haystack.length && haystack[index] === needle;\n * ```\n */\nexport function binarySearch(high: number, compare: (i: number) => number) {\n  let low = 0;\n  while (low < high) {\n    const mid = low + ((high - low) >> 1);\n    const i = compare(mid);\n    if (i === 0) {\n      return mid;\n    }\n    if (i > 0) {\n      low = mid + 1;\n    } else {\n      high = mid;\n    }\n  }\n  return low;\n}\n"],"mappings":";;;;;;;;;;;;;;AAaA,SAAgB,aAAa,MAAc,SAAgC;CACzE,IAAI,MAAM;AACV,QAAO,MAAM,MAAM;EACjB,MAAM,MAAM,OAAQ,OAAO,OAAQ;EACnC,MAAM,IAAI,QAAQ,IAAI;AACtB,MAAI,MAAM,EACR,QAAO;AAET,MAAI,IAAI,EACN,OAAM,MAAM;MAEZ,QAAO;;AAGX,QAAO"}

package/out/shared/src/broadcast-channel.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"broadcast-channel.js","names":[],"sources":["../../../../shared/src/broadcast-channel.ts"],"sourcesContent":["/* oxlint-disable @typescript-eslint/no-explicit-any */\n\nclass NoopBroadcastChannel implements BroadcastChannel {\n  readonly name: string;\n\n  onmessage: ((this: BroadcastChannel, ev: MessageEvent<any>) => any) | null =\n    null;\n\n  onmessageerror:\n    | ((this: BroadcastChannel, ev: MessageEvent<any>) => any)\n    | null = null;\n\n  constructor(name: string) {\n    this.name = name;\n  }\n\n  addEventListener(): void {\n    // noop\n  }\n  removeEventListener(): void {\n    // noop\n  }\n  dispatchEvent(): boolean {\n    return false;\n  }\n\n  close(): void {\n    // noop\n  }\n\n  postMessage(): void {\n    // noop\n  }\n}\n\nconst bc: typeof BroadcastChannel =\n  typeof BroadcastChannel === 'undefined'\n    ? NoopBroadcastChannel\n    : BroadcastChannel;\n\nexport {bc as BroadcastChannel};\n"],"mappings":";AAEA,IAAM,uBAAN,MAAuD;CACrD;CAEA,YACE;CAEF,iBAEW;CAEX,YAAY,MAAc;AACxB,OAAK,OAAO;;CAGd,mBAAyB;CAGzB,sBAA4B;CAG5B,gBAAyB;AACvB,SAAO;;CAGT,QAAc;CAId,cAAoB;;AAKtB,IAAM,KACJ,OAAO,qBAAqB,cACxB,uBACA"}

package/out/shared/src/browser-env.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"browser-env.js","names":[],"sources":["../../../../shared/src/browser-env.ts"],"sourcesContent":["// Helpers for some objects from the browser environment. These are wrapped in\n// functions because Replicache runs in environments that do not have these\n// objects (such as Web Workers, Deno etc).\n\ntype GlobalThis = typeof globalThis;\n\nconst overrides = new Map<keyof GlobalThis, GlobalThis[keyof GlobalThis]>();\n\nexport function overrideBrowserGlobal<T extends keyof GlobalThis>(\n  name: T,\n  value: GlobalThis[T],\n) {\n  overrides.set(name, value);\n}\n\nexport function clearBrowserOverrides() {\n  overrides.clear();\n}\n\nexport function getBrowserGlobal<T extends keyof GlobalThis>(\n  name: T,\n): GlobalThis[T] | undefined {\n  if (overrides.has(name)) {\n    return overrides.get(name);\n  }\n  return globalThis[name];\n}\n\n/**\n * Returns the global method with the given name, bound to the global object.\n * This is important because some methods (e.g. `requestAnimationFrame`) are not\n * bound to the global object by default.\n *\n * If you end up using {@linkcode getBrowserGlobal} instead in a case like this:\n *\n * ```js\n * this.#raf = getBrowserGlobal('requestAnimationFrame') ?? rafFallback;\n * ...\n * this.#raf(() => ...);\n * ```\n *\n * You will end up with `Uncaught TypeError: Illegal invocation` because `this`\n * is not bound to the global object\n */\nexport function getBrowserGlobalMethod<T extends keyof GlobalThis>(\n  name: T,\n): GlobalThis[T] | undefined {\n  return getBrowserGlobal(name)?.bind(globalThis);\n}\n\nexport function mustGetBrowserGlobal<T extends keyof GlobalThis>(\n  name: T,\n): GlobalThis[T] {\n  const r = getBrowserGlobal(name);\n  if (r === undefined) {\n    throw new Error(\n      `Unsupported JavaScript environment: Could not find ${name}.`,\n    );\n  }\n  return r;\n}\n"],"mappings":";AAMA,IAAM,4BAAY,IAAI,KAAqD;AAa3E,SAAgB,iBACd,MAC2B;AAC3B,KAAI,UAAU,IAAI,KAAK,CACrB,QAAO,UAAU,IAAI,KAAK;AAE5B,QAAO,WAAW;;AAyBpB,SAAgB,qBACd,MACe;CACf,MAAM,IAAI,iBAAiB,KAAK;AAChC,KAAI,MAAM,KAAA,EACR,OAAM,IAAI,MACR,sDAAsD,KAAK,GAC5D;AAEH,QAAO"}

package/out/shared/src/btree-set.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"btree-set.js","names":["#root","#delete","#maxKey","#nodeQueue","#nodeIndex","#leaf","#i"],"sources":["../../../../shared/src/btree-set.ts"],"sourcesContent":["import {assert} from './asserts.ts';\n\nconst MAX_NODE_SIZE = 32;\n\ntype Comparator<K> = (a: K, b: K) => number;\n\nexport class BTreeSet<K> {\n  #root: BNode<K> = emptyLeaf as BNode<K>;\n  size: number = 0;\n\n  readonly comparator: Comparator<K>;\n\n  constructor(comparator: Comparator<K>, entries?: IterableIterator<K>) {\n    this.comparator = comparator;\n    if (entries) {\n      for (const key of entries) {\n        this.add(key);\n      }\n    }\n  }\n\n  /** Releases the tree so that its size is 0. */\n  clear() {\n    this.#root = emptyLeaf as BNode<K>;\n    this.size = 0;\n  }\n\n  clone() {\n    this.#root.isShared = true;\n    const ret = new BTreeSet<K>(this.comparator);\n    ret.#root = this.#root;\n    ret.size = this.size;\n    return ret;\n  }\n\n  get(key: K): K | undefined {\n    return this.#root.get(key, this);\n  }\n\n  add(key: K): this {\n    if (this.#root.isShared) this.#root = this.#root.clone();\n    const result = this.#root.set(key, this);\n    if (result === null) return this;\n    // Root node has split, so create a new root node.\n    this.#root = new BNodeInternal<K>([this.#root, result]);\n    return this;\n  }\n\n  /**\n   * Returns true if the key exists in the B+ tree, false if not.\n   * Use get() for best performance; use has() if you need to\n   * distinguish between \"undefined value\" and \"key not present\".\n   * @param key Key to detect\n   * @description Computational complexity: O(log size)\n   */\n  has(key: K): boolean {\n    return this.#root.has(key, this);\n  }\n\n  /**\n   * Removes a single key-value pair from the B+ tree.\n   * @param key Key to find\n   * @returns true if a pair was found and removed, false otherwise.\n   * @description Computational complexity: O(log size)\n   */\n  delete(key: K): boolean {\n    return this.#delete(key);\n  }\n\n  #delete(key: K): boolean {\n    let root = this.#root;\n    if (root.isShared) {\n      this.#root = root = root.clone();\n    }\n    try {\n      return root.delete(key, this);\n    } finally {\n      let isShared;\n      while (root.keys.length <= 1 && root.isInternal()) {\n        isShared ||= root.isShared;\n        this.#root = root =\n          root.keys.length === 0 ? emptyLeaf : root.children[0];\n      }\n      // If any ancestor of the new root was shared, the new root must also be shared\n      if (isShared) {\n        root.isShared = true;\n      }\n    }\n  }\n\n  keys(): IterableIterator<K> {\n    return valuesFrom(this.#root, this.comparator, undefined, true);\n  }\n\n  values(): IterableIterator<K> {\n    return valuesFrom(this.#root, this.comparator, undefined, true);\n  }\n\n  valuesFrom(lowestKey?: K, inclusive: boolean = true): IterableIterator<K> {\n    return valuesFrom(this.#root, this.comparator, lowestKey, inclusive);\n  }\n\n  valuesReversed(): IterableIterator<K> {\n    return valuesFromReversed(\n      this.#maxKey(),\n      this.#root,\n      this.comparator,\n      undefined,\n      true,\n    );\n  }\n\n  valuesFromReversed(\n    highestKey?: K,\n    inclusive: boolean = true,\n  ): IterableIterator<K> {\n    return valuesFromReversed(\n      this.#maxKey(),\n      this.#root,\n      this.comparator,\n      highestKey,\n      inclusive,\n    );\n  }\n\n  /** Gets the highest key in the tree. Complexity: O(1) */\n  #maxKey(): K | undefined {\n    return this.#root.maxKey();\n  }\n\n  [Symbol.iterator](): IterableIterator<K> {\n    return this.keys();\n  }\n\n  /**\n   * Builds a BTreeSet from a pre-sorted iterable in O(N) by constructing\n   * the tree bottom-up. The caller must ensure entries are sorted by\n   * `comparator`; violating this produces an invalid tree.\n   */\n  static fromSorted<K>(\n    comparator: Comparator<K>,\n    sortedEntries: Iterable<K>,\n  ): BTreeSet<K> {\n    const tree = new BTreeSet<K>(comparator);\n\n    // Stream through entries, flushing a leaf node each time we fill MAX_NODE_SIZE keys.\n    const leaves: BNode<K>[] = [];\n    let currentKeys: K[] = [];\n    let size = 0;\n\n    for (const key of sortedEntries) {\n      currentKeys.push(key);\n      if (currentKeys.length === MAX_NODE_SIZE) {\n        leaves.push(new BNode<K>(currentKeys));\n        currentKeys = [];\n      }\n      size++;\n    }\n\n    if (currentKeys.length > 0) {\n      leaves.push(new BNode<K>(currentKeys));\n    }\n\n    if (leaves.length === 0) return tree;\n\n    tree.size = size;\n\n    if (leaves.length === 1) {\n      tree.#root = leaves[0];\n      return tree;\n    }\n\n    // Build internal nodes bottom-up until a single root remains.\n    let currentLevel: BNode<K>[] = leaves;\n    while (currentLevel.length > 1) {\n      const nextLevel: BNodeInternal<K>[] = [];\n      for (let i = 0; i < currentLevel.length; i += MAX_NODE_SIZE) {\n        nextLevel.push(\n          new BNodeInternal<K>(currentLevel.slice(i, i + MAX_NODE_SIZE)),\n        );\n      }\n      currentLevel = nextLevel;\n    }\n\n    tree.#root = currentLevel[0];\n    return tree;\n  }\n}\n\nclass BTreeForwardIterator<K> implements IterableIterator<K> {\n  readonly #nodeQueue: BNode<K>[][];\n  readonly #nodeIndex: number[];\n  #leaf: BNode<K>;\n  #i: number;\n\n  constructor(\n    nodeQueue: BNode<K>[][],\n    nodeIndex: number[],\n    leaf: BNode<K>,\n    startI: number,\n  ) {\n    this.#nodeQueue = nodeQueue;\n    this.#nodeIndex = nodeIndex;\n    this.#leaf = leaf;\n    this.#i = startI;\n  }\n\n  next(): IteratorResult<K> {\n    for (;;) {\n      if (++this.#i < this.#leaf.keys.length) {\n        return {done: false, value: this.#leaf.keys[this.#i]};\n      }\n\n      let level = -1;\n      for (;;) {\n        if (++level >= this.#nodeQueue.length) {\n          return {done: true, value: undefined as unknown as K};\n        }\n        if (++this.#nodeIndex[level] < this.#nodeQueue[level].length) {\n          break;\n        }\n      }\n      for (; level > 0; level--) {\n        this.#nodeQueue[level - 1] = (\n          this.#nodeQueue[level][this.#nodeIndex[level]] as BNodeInternal<K>\n        ).children;\n        this.#nodeIndex[level - 1] = 0;\n      }\n      this.#leaf = this.#nodeQueue[0][this.#nodeIndex[0]];\n      this.#i = -1;\n    }\n  }\n\n  [Symbol.iterator]() {\n    return this;\n  }\n}\n\nclass BTreeReverseIterator<K> implements IterableIterator<K> {\n  readonly #nodeQueue: BNode<K>[][];\n  readonly #nodeIndex: number[];\n  #leaf: BNode<K>;\n  #i: number;\n\n  constructor(\n    nodeQueue: BNode<K>[][],\n    nodeIndex: number[],\n    leaf: BNode<K>,\n    startI: number,\n  ) {\n    this.#nodeQueue = nodeQueue;\n    this.#nodeIndex = nodeIndex;\n    this.#leaf = leaf;\n    this.#i = startI;\n  }\n\n  next(): IteratorResult<K> {\n    for (;;) {\n      if (--this.#i >= 0) {\n        return {done: false, value: this.#leaf.keys[this.#i]};\n      }\n\n      let level;\n      // Advance to the next leaf node\n      for (level = -1; ; ) {\n        if (++level >= this.#nodeQueue.length) {\n          return {done: true, value: undefined as unknown as K};\n        }\n        if (--this.#nodeIndex[level] >= 0) {\n          break;\n        }\n      }\n      for (; level > 0; level--) {\n        this.#nodeQueue[level - 1] = (\n          this.#nodeQueue[level][this.#nodeIndex[level]] as BNodeInternal<K>\n        ).children;\n        this.#nodeIndex[level - 1] = this.#nodeQueue[level - 1].length - 1;\n      }\n      this.#leaf = this.#nodeQueue[0][this.#nodeIndex[0]];\n      this.#i = this.#leaf.keys.length;\n    }\n  }\n\n  [Symbol.iterator]() {\n    return this;\n  }\n}\n\nfunction valuesFrom<K>(\n  root: BNode<K>,\n  comparator: Comparator<K>,\n  lowestKey: K | undefined,\n  inclusive: boolean,\n): IterableIterator<K> {\n  const info = findPath(lowestKey, root, comparator);\n  if (info === undefined) {\n    return iterator<K>(() => ({done: true, value: undefined}));\n  }\n\n  let [nodeQueue, nodeIndex, leaf] = info;\n  let i =\n    lowestKey === undefined\n      ? -1\n      : indexOf(lowestKey, leaf.keys, 0, comparator) - 1;\n\n  if (\n    !inclusive &&\n    lowestKey !== undefined &&\n    // +1 because we did -1 above.\n    i + 1 < leaf.keys.length &&\n    comparator(leaf.keys[i + 1], lowestKey) === 0\n  ) {\n    i++;\n  }\n\n  return new BTreeForwardIterator(nodeQueue, nodeIndex, leaf, i);\n}\n\nfunction valuesFromReversed<K>(\n  maxKey: K | undefined,\n  root: BNode<K>,\n  comparator: Comparator<K>,\n  highestKey: K | undefined,\n  inclusive: boolean,\n): IterableIterator<K> {\n  if (highestKey === undefined) {\n    highestKey = maxKey;\n    if (highestKey === undefined) {\n      return iterator<K>(() => ({done: true, value: undefined}));\n    } // collection is empty\n  }\n  let [nodeQueue, nodeIndex, leaf] =\n    findPath(highestKey, root, comparator) ||\n    findPath(maxKey, root, comparator)!;\n  assert(\n    !nodeQueue[0] || leaf === nodeQueue[0][nodeIndex[0]],\n    'BTreeSet: leaf node mismatch in iteration',\n  );\n  let i = indexOf(highestKey, leaf.keys, 0, comparator);\n  if (\n    inclusive &&\n    i < leaf.keys.length &&\n    comparator(leaf.keys[i], highestKey) <= 0\n  ) {\n    i++;\n  }\n\n  return new BTreeReverseIterator(nodeQueue, nodeIndex, leaf, i);\n}\n\nfunction findPath<K>(\n  key: K | undefined,\n  root: BNode<K>,\n  comparator: Comparator<K>,\n): [nodeQueue: BNode<K>[][], nodeIndex: number[], leaf: BNode<K>] | undefined {\n  let nextNode = root;\n  const nodeQueue: BNode<K>[][] = [];\n  const nodeIndex: number[] = [];\n\n  if (nextNode.isInternal()) {\n    for (let d = 0; nextNode.isInternal(); d++) {\n      nodeQueue[d] = nextNode.children;\n      nodeIndex[d] =\n        key === undefined ? 0 : indexOf(key, nextNode.keys, 0, comparator);\n      if (nodeIndex[d] >= nodeQueue[d].length) return; // first key > maxKey()\n      nextNode = nodeQueue[d][nodeIndex[d]];\n    }\n    nodeQueue.reverse();\n    nodeIndex.reverse();\n  }\n  return [nodeQueue, nodeIndex, nextNode];\n}\n\nfunction iterator<T>(next: () => IteratorResult<T>): IterableIterator<T> {\n  return {\n    next,\n    [Symbol.iterator]() {\n      return this;\n    },\n  };\n}\n\n/** Leaf node / base class. **************************************************/\nclass BNode<K> {\n  // If this is an internal node, _keys[i] is the highest key in children[i].\n  keys: K[];\n  // True if this node might be within multiple `BTree`s (or have multiple parents).\n  // If so, it must be cloned before being mutated to avoid changing an unrelated tree.\n  // This is transitive: if it's true, children are also shared even if `isShared!=true`\n  // in those children. (Certain operations will propagate isShared=true to children.)\n  isShared: true | undefined;\n\n  constructor(keys: K[]) {\n    this.keys = keys;\n    this.isShared = undefined;\n  }\n\n  isInternal(): this is BNodeInternal<K> {\n    return false;\n  }\n\n  maxKey() {\n    // oxlint-disable-next-line typescript/no-non-null-assertion\n    return this.keys.at(-1)!;\n  }\n\n  minKey(): K | undefined {\n    return this.keys[0];\n  }\n\n  clone(): BNode<K> {\n    return new BNode<K>(this.keys.slice(0));\n  }\n\n  get(key: K, tree: BTreeSet<K>): K | undefined {\n    const i = indexOf(key, this.keys, -1, tree.comparator);\n    return i < 0 ? undefined : this.keys[i];\n  }\n\n  has(key: K, tree: BTreeSet<K>): boolean {\n    const i = indexOf(key, this.keys, -1, tree.comparator);\n    return i >= 0 && i < this.keys.length;\n  }\n\n  set(key: K, tree: BTreeSet<K>): null | BNode<K> {\n    let i = indexOf(key, this.keys, -1, tree.comparator);\n    if (i < 0) {\n      // key does not exist yet\n      i = ~i;\n      tree.size++;\n\n      if (this.keys.length < MAX_NODE_SIZE) {\n        this.keys.splice(i, 0, key);\n        return null;\n      }\n      // This leaf node is full and must split\n      const newRightSibling = this.splitOffRightSide();\n      // oxlint-disable-next-line @typescript-eslint/no-this-alias\n      let target: BNode<K> = this;\n      if (i > this.keys.length) {\n        i -= this.keys.length;\n        target = newRightSibling;\n      }\n      // target.#insertInLeaf(i, key);\n      target.keys.splice(i, 0, key);\n\n      return newRightSibling;\n    }\n\n    // usually this is a no-op, but some users may wish to edit the key\n    this.keys[i] = key;\n    return null;\n  }\n\n  takeFromRight(rhs: BNode<K>) {\n    this.keys.push(rhs.keys.shift()!);\n  }\n\n  takeFromLeft(lhs: BNode<K>) {\n    this.keys.unshift(lhs.keys.pop()!);\n  }\n\n  splitOffRightSide(): BNode<K> {\n    const half = this.keys.length >> 1;\n    const keys = this.keys.splice(half);\n    return new BNode<K>(keys);\n  }\n\n  delete(key: K, tree: BTreeSet<K>): boolean {\n    const cmp = tree.comparator;\n    const iLow = indexOf(key, this.keys, -1, cmp);\n    const iHigh = iLow + 1;\n\n    if (iLow < 0) {\n      return false;\n    }\n\n    const {keys} = this;\n    for (let i = iLow; i < iHigh; i++) {\n      const key = keys[i];\n\n      if (key !== keys[i] || this.isShared === true) {\n        throw new Error('BTree illegally changed or cloned in delete');\n      }\n\n      this.keys.splice(i, 1);\n      tree.size--;\n      return true;\n    }\n\n    return false;\n  }\n\n  mergeSibling(rhs: BNode<K>, _: number) {\n    this.keys.push(...rhs.keys);\n  }\n}\n\n/** Internal node (non-leaf node) ********************************************/\nclass BNodeInternal<K> extends BNode<K> {\n  // Note: conventionally B+ trees have one fewer key than the number of\n  // children, but I find it easier to keep the array lengths equal: each\n  // keys[i] caches the value of children[i].maxKey().\n  children: BNode<K>[];\n\n  /**\n   * This does not mark `children` as shared, so it is the responsibility of the caller\n   * to ensure children are either marked shared, or aren't included in another tree.\n   */\n  constructor(children: BNode<K>[], keys?: K[]) {\n    if (!keys) {\n      keys = [];\n      for (let i = 0; i < children.length; i++) {\n        keys[i] = children[i].maxKey();\n      }\n    }\n    super(keys);\n    this.children = children;\n  }\n\n  isInternal(): this is BNodeInternal<K> {\n    return true;\n  }\n\n  clone(): BNode<K> {\n    const children = this.children.slice(0);\n    for (let i = 0; i < children.length; i++) {\n      children[i].isShared = true;\n    }\n    return new BNodeInternal<K>(children, this.keys.slice(0));\n  }\n\n  minKey() {\n    return this.children[0].minKey();\n  }\n\n  get(key: K, tree: BTreeSet<K>): K | undefined {\n    const i = indexOf(key, this.keys, 0, tree.comparator);\n    const {children} = this;\n    return i < children.length ? children[i].get(key, tree) : undefined;\n  }\n\n  has(key: K, tree: BTreeSet<K>): boolean {\n    const i = indexOf(key, this.keys, 0, tree.comparator);\n    const {children} = this;\n    return i < children.length ? children[i].has(key, tree) : false;\n  }\n\n  set(key: K, tree: BTreeSet<K>): null | BNode<K> {\n    const c = this.children;\n    const cmp = tree.comparator;\n    let i = Math.min(indexOf(key, this.keys, 0, cmp), c.length - 1);\n    let child = c[i];\n\n    if (child.isShared) {\n      c[i] = child = child.clone();\n    }\n    if (child.keys.length >= MAX_NODE_SIZE) {\n      // child is full; inserting anything else will cause a split.\n      // Shifting an item to the left or right sibling may avoid a split.\n      // We can do a shift if the adjacent node is not full and if the\n      // current key can still be placed in the same node after the shift.\n      let other: BNode<K>;\n      if (\n        i > 0 &&\n        (other = c[i - 1]).keys.length < MAX_NODE_SIZE &&\n        cmp(child.keys[0], key) < 0\n      ) {\n        if (other.isShared) {\n          c[i - 1] = other = other.clone();\n        }\n        other.takeFromRight(child);\n        this.keys[i - 1] = other.maxKey();\n      } else if (\n        (other = c[i + 1]) !== undefined &&\n        other.keys.length < MAX_NODE_SIZE &&\n        cmp(child.maxKey(), key) < 0\n      ) {\n        if (other.isShared) c[i + 1] = other = other.clone();\n        other.takeFromLeft(child);\n        this.keys[i] = c[i].maxKey();\n      }\n    }\n\n    const result = child.set(key, tree);\n    this.keys[i] = child.maxKey();\n    if (result === null) return null;\n\n    // The child has split and `result` is a new right child... does it fit?\n    if (this.keys.length < MAX_NODE_SIZE) {\n      // yes\n      this.insert(i + 1, result);\n      return null;\n    }\n    // no, we must split also\n    const newRightSibling = this.splitOffRightSide();\n    // oxlint-disable-next-line @typescript-eslint/no-this-alias\n    let target: BNodeInternal<K> = this;\n    if (cmp(result.maxKey(), this.maxKey()) > 0) {\n      target = newRightSibling;\n      i -= this.keys.length;\n    }\n    target.insert(i + 1, result);\n    return newRightSibling;\n  }\n\n  /**\n   * Inserts `child` at index `i`.\n   * This does not mark `child` as shared, so it is the responsibility of the caller\n   * to ensure that either child is marked shared, or it is not included in another tree.\n   */\n  insert(i: number, child: BNode<K>) {\n    this.children.splice(i, 0, child);\n    this.keys.splice(i, 0, child.maxKey());\n  }\n\n  /**\n   * Split this node.\n   * Modifies this to remove the second half of the items, returning a separate node containing them.\n   */\n  splitOffRightSide() {\n    const half = this.children.length >> 1;\n    return new BNodeInternal<K>(\n      this.children.splice(half),\n      this.keys.splice(half),\n    );\n  }\n\n  takeFromRight(rhs: BNode<K>) {\n    this.keys.push(rhs.keys.shift()!);\n    this.children.push((rhs as BNodeInternal<K>).children.shift()!);\n  }\n\n  takeFromLeft(lhs: BNode<K>) {\n    this.keys.unshift(lhs.keys.pop()!);\n    this.children.unshift((lhs as BNodeInternal<K>).children.pop()!);\n  }\n\n  delete(key: K, tree: BTreeSet<K>): boolean {\n    const cmp = tree.comparator;\n    const {keys} = this;\n    const {children} = this;\n    let iLow = indexOf(key, this.keys, 0, cmp);\n    let i = iLow;\n    const iHigh = Math.min(iLow, keys.length - 1);\n    if (i <= iHigh) {\n      try {\n        if (children[i].isShared) {\n          children[i] = children[i].clone();\n        }\n        const result = children[i].delete(key, tree);\n        // Note: if children[i] is empty then keys[i]=undefined.\n        //       This is an invalid state, but it is fixed below.\n        keys[i] = children[i].maxKey();\n        return result;\n      } finally {\n        // Deletions may have occurred, so look for opportunities to merge nodes.\n        const half = MAX_NODE_SIZE >> 1;\n        if (iLow > 0) iLow--;\n        for (i = iHigh; i >= iLow; i--) {\n          if (children[i].keys.length <= half) {\n            if (children[i].keys.length !== 0) {\n              this.tryMerge(i, MAX_NODE_SIZE);\n            } else {\n              // child is empty! delete it!\n              keys.splice(i, 1);\n              children.splice(i, 1);\n            }\n          }\n        }\n      }\n    }\n    return false;\n  }\n\n  /** Merges child i with child i+1 if their combined size is not too large */\n  tryMerge(i: number, maxSize: number): boolean {\n    const {children} = this;\n    if (i >= 0 && i + 1 < children.length) {\n      if (children[i].keys.length + children[i + 1].keys.length <= maxSize) {\n        if (\n          children[i].isShared\n        ) // cloned already UNLESS i is outside scan range\n        {\n          children[i] = children[i].clone();\n        }\n        children[i].mergeSibling(children[i + 1], maxSize);\n        children.splice(i + 1, 1);\n        this.keys.splice(i + 1, 1);\n        this.keys[i] = children[i].maxKey();\n        return true;\n      }\n    }\n    return false;\n  }\n\n  /**\n   * Move children from `rhs` into this.\n   * `rhs` must be part of this tree, and be removed from it after this call\n   * (otherwise isShared for its children could be incorrect).\n   */\n  mergeSibling(rhs: BNode<K>, maxNodeSize: number) {\n    // assert !this.isShared;\n    const oldLength = this.keys.length;\n    this.keys.push(...rhs.keys);\n    const rhsChildren = (rhs as unknown as BNodeInternal<K>).children;\n    this.children.push(...rhsChildren);\n\n    if (rhs.isShared && !this.isShared) {\n      // All children of a shared node are implicitly shared, and since their new\n      // parent is not shared, they must now be explicitly marked as shared.\n      for (let i = 0; i < rhsChildren.length; i++) {\n        rhsChildren[i].isShared = true;\n      }\n    }\n\n    // If our children are themselves almost empty due to a mass-delete,\n    // they may need to be merged too (but only the oldLength-1 and its\n    // right sibling should need this).\n    this.tryMerge(oldLength - 1, maxNodeSize);\n  }\n}\n\n// If key not found, returns i^failXor where i is the insertion index.\n// Callers that don't care whether there was a match will set failXor=0.\nfunction indexOf<K>(\n  key: K,\n  keys: K[],\n  failXor: number,\n  comparator: Comparator<K>,\n): number {\n  let lo = 0;\n  let hi = keys.length;\n  let mid = hi >> 1;\n  while (lo < hi) {\n    const c = comparator(keys[mid], key);\n    if (c < 0) {\n      lo = mid + 1;\n    } else if (c > 0) {\n      // key < keys[mid]\n      hi = mid;\n    } else if (c === 0) {\n      return mid;\n    } else {\n      // c is NaN or otherwise invalid\n      if (key === key) {\n        // at least the search key is not NaN\n        return keys.length;\n      }\n      throw new Error('NaN was used as a key');\n    }\n    mid = (lo + hi) >> 1;\n  }\n  return mid ^ failXor;\n}\n\n// oxlint-disable-next-line @typescript-eslint/no-explicit-any\nconst emptyLeaf = new BNode<any>([]);\nemptyLeaf.isShared = true;\n"],"mappings":";;AAEA,IAAM,gBAAgB;AAItB,IAAa,WAAb,MAAa,SAAY;CACvB,QAAkB;CAClB,OAAe;CAEf;CAEA,YAAY,YAA2B,SAA+B;AACpE,OAAK,aAAa;AAClB,MAAI,QACF,MAAK,MAAM,OAAO,QAChB,MAAK,IAAI,IAAI;;;CAMnB,QAAQ;AACN,QAAA,OAAa;AACb,OAAK,OAAO;;CAGd,QAAQ;AACN,QAAA,KAAW,WAAW;EACtB,MAAM,MAAM,IAAI,SAAY,KAAK,WAAW;AAC5C,OAAA,OAAY,MAAA;AACZ,MAAI,OAAO,KAAK;AAChB,SAAO;;CAGT,IAAI,KAAuB;AACzB,SAAO,MAAA,KAAW,IAAI,KAAK,KAAK;;CAGlC,IAAI,KAAc;AAChB,MAAI,MAAA,KAAW,SAAU,OAAA,OAAa,MAAA,KAAW,OAAO;EACxD,MAAM,SAAS,MAAA,KAAW,IAAI,KAAK,KAAK;AACxC,MAAI,WAAW,KAAM,QAAO;AAE5B,QAAA,OAAa,IAAI,cAAiB,CAAC,MAAA,MAAY,OAAO,CAAC;AACvD,SAAO;;;;;;;;;CAUT,IAAI,KAAiB;AACnB,SAAO,MAAA,KAAW,IAAI,KAAK,KAAK;;;;;;;;CASlC,OAAO,KAAiB;AACtB,SAAO,MAAA,OAAa,IAAI;;CAG1B,QAAQ,KAAiB;EACvB,IAAI,OAAO,MAAA;AACX,MAAI,KAAK,SACP,OAAA,OAAa,OAAO,KAAK,OAAO;AAElC,MAAI;AACF,UAAO,KAAK,OAAO,KAAK,KAAK;YACrB;GACR,IAAI;AACJ,UAAO,KAAK,KAAK,UAAU,KAAK,KAAK,YAAY,EAAE;AACjD,iBAAa,KAAK;AAClB,UAAA,OAAa,OACX,KAAK,KAAK,WAAW,IAAI,YAAY,KAAK,SAAS;;AAGvD,OAAI,SACF,MAAK,WAAW;;;CAKtB,OAA4B;AAC1B,SAAO,WAAW,MAAA,MAAY,KAAK,YAAY,KAAA,GAAW,KAAK;;CAGjE,SAA8B;AAC5B,SAAO,WAAW,MAAA,MAAY,KAAK,YAAY,KAAA,GAAW,KAAK;;CAGjE,WAAW,WAAe,YAAqB,MAA2B;AACxE,SAAO,WAAW,MAAA,MAAY,KAAK,YAAY,WAAW,UAAU;;CAGtE,iBAAsC;AACpC,SAAO,mBACL,MAAA,QAAc,EACd,MAAA,MACA,KAAK,YACL,KAAA,GACA,KACD;;CAGH,mBACE,YACA,YAAqB,MACA;AACrB,SAAO,mBACL,MAAA,QAAc,EACd,MAAA,MACA,KAAK,YACL,YACA,UACD;;;CAIH,UAAyB;AACvB,SAAO,MAAA,KAAW,QAAQ;;CAG5B,CAAC,OAAO,YAAiC;AACvC,SAAO,KAAK,MAAM;;;;;;;CAQpB,OAAO,WACL,YACA,eACa;EACb,MAAM,OAAO,IAAI,SAAY,WAAW;EAGxC,MAAM,SAAqB,EAAE;EAC7B,IAAI,cAAmB,EAAE;EACzB,IAAI,OAAO;AAEX,OAAK,MAAM,OAAO,eAAe;AAC/B,eAAY,KAAK,IAAI;AACrB,OAAI,YAAY,WAAW,eAAe;AACxC,WAAO,KAAK,IAAI,MAAS,YAAY,CAAC;AACtC,kBAAc,EAAE;;AAElB;;AAGF,MAAI,YAAY,SAAS,EACvB,QAAO,KAAK,IAAI,MAAS,YAAY,CAAC;AAGxC,MAAI,OAAO,WAAW,EAAG,QAAO;AAEhC,OAAK,OAAO;AAEZ,MAAI,OAAO,WAAW,GAAG;AACvB,SAAA,OAAa,OAAO;AACpB,UAAO;;EAIT,IAAI,eAA2B;AAC/B,SAAO,aAAa,SAAS,GAAG;GAC9B,MAAM,YAAgC,EAAE;AACxC,QAAK,IAAI,IAAI,GAAG,IAAI,aAAa,QAAQ,KAAK,cAC5C,WAAU,KACR,IAAI,cAAiB,aAAa,MAAM,GAAG,IAAI,cAAc,CAAC,CAC/D;AAEH,kBAAe;;AAGjB,QAAA,OAAa,aAAa;AAC1B,SAAO;;;AAIX,IAAM,uBAAN,MAA6D;CAC3D;CACA;CACA;CACA;CAEA,YACE,WACA,WACA,MACA,QACA;AACA,QAAA,YAAkB;AAClB,QAAA,YAAkB;AAClB,QAAA,OAAa;AACb,QAAA,IAAU;;CAGZ,OAA0B;AACxB,WAAS;AACP,OAAI,EAAE,MAAA,IAAU,MAAA,KAAW,KAAK,OAC9B,QAAO;IAAC,MAAM;IAAO,OAAO,MAAA,KAAW,KAAK,MAAA;IAAS;GAGvD,IAAI,QAAQ;AACZ,YAAS;AACP,QAAI,EAAE,SAAS,MAAA,UAAgB,OAC7B,QAAO;KAAC,MAAM;KAAM,OAAO,KAAA;KAA0B;AAEvD,QAAI,EAAE,MAAA,UAAgB,SAAS,MAAA,UAAgB,OAAO,OACpD;;AAGJ,UAAO,QAAQ,GAAG,SAAS;AACzB,UAAA,UAAgB,QAAQ,KACtB,MAAA,UAAgB,OAAO,MAAA,UAAgB,QACvC;AACF,UAAA,UAAgB,QAAQ,KAAK;;AAE/B,SAAA,OAAa,MAAA,UAAgB,GAAG,MAAA,UAAgB;AAChD,SAAA,IAAU;;;CAId,CAAC,OAAO,YAAY;AAClB,SAAO;;;AAIX,IAAM,uBAAN,MAA6D;CAC3D;CACA;CACA;CACA;CAEA,YACE,WACA,WACA,MACA,QACA;AACA,QAAA,YAAkB;AAClB,QAAA,YAAkB;AAClB,QAAA,OAAa;AACb,QAAA,IAAU;;CAGZ,OAA0B;AACxB,WAAS;AACP,OAAI,EAAE,MAAA,KAAW,EACf,QAAO;IAAC,MAAM;IAAO,OAAO,MAAA,KAAW,KAAK,MAAA;IAAS;GAGvD,IAAI;AAEJ,QAAK,QAAQ,MAAQ;AACnB,QAAI,EAAE,SAAS,MAAA,UAAgB,OAC7B,QAAO;KAAC,MAAM;KAAM,OAAO,KAAA;KAA0B;AAEvD,QAAI,EAAE,MAAA,UAAgB,UAAU,EAC9B;;AAGJ,UAAO,QAAQ,GAAG,SAAS;AACzB,UAAA,UAAgB,QAAQ,KACtB,MAAA,UAAgB,OAAO,MAAA,UAAgB,QACvC;AACF,UAAA,UAAgB,QAAQ,KAAK,MAAA,UAAgB,QAAQ,GAAG,SAAS;;AAEnE,SAAA,OAAa,MAAA,UAAgB,GAAG,MAAA,UAAgB;AAChD,SAAA,IAAU,MAAA,KAAW,KAAK;;;CAI9B,CAAC,OAAO,YAAY;AAClB,SAAO;;;AAIX,SAAS,WACP,MACA,YACA,WACA,WACqB;CACrB,MAAM,OAAO,SAAS,WAAW,MAAM,WAAW;AAClD,KAAI,SAAS,KAAA,EACX,QAAO,gBAAmB;EAAC,MAAM;EAAM,OAAO,KAAA;EAAU,EAAE;CAG5D,IAAI,CAAC,WAAW,WAAW,QAAQ;CACnC,IAAI,IACF,cAAc,KAAA,IACV,KACA,QAAQ,WAAW,KAAK,MAAM,GAAG,WAAW,GAAG;AAErD,KACE,CAAC,aACD,cAAc,KAAA,KAEd,IAAI,IAAI,KAAK,KAAK,UAClB,WAAW,KAAK,KAAK,IAAI,IAAI,UAAU,KAAK,EAE5C;AAGF,QAAO,IAAI,qBAAqB,WAAW,WAAW,MAAM,EAAE;;AAGhE,SAAS,mBACP,QACA,MACA,YACA,YACA,WACqB;AACrB,KAAI,eAAe,KAAA,GAAW;AAC5B,eAAa;AACb,MAAI,eAAe,KAAA,EACjB,QAAO,gBAAmB;GAAC,MAAM;GAAM,OAAO,KAAA;GAAU,EAAE;;CAG9D,IAAI,CAAC,WAAW,WAAW,QACzB,SAAS,YAAY,MAAM,WAAW,IACtC,SAAS,QAAQ,MAAM,WAAW;AACpC,QACE,CAAC,UAAU,MAAM,SAAS,UAAU,GAAG,UAAU,KACjD,4CACD;CACD,IAAI,IAAI,QAAQ,YAAY,KAAK,MAAM,GAAG,WAAW;AACrD,KACE,aACA,IAAI,KAAK,KAAK,UACd,WAAW,KAAK,KAAK,IAAI,WAAW,IAAI,EAExC;AAGF,QAAO,IAAI,qBAAqB,WAAW,WAAW,MAAM,EAAE;;AAGhE,SAAS,SACP,KACA,MACA,YAC4E;CAC5E,IAAI,WAAW;CACf,MAAM,YAA0B,EAAE;CAClC,MAAM,YAAsB,EAAE;AAE9B,KAAI,SAAS,YAAY,EAAE;AACzB,OAAK,IAAI,IAAI,GAAG,SAAS,YAAY,EAAE,KAAK;AAC1C,aAAU,KAAK,SAAS;AACxB,aAAU,KACR,QAAQ,KAAA,IAAY,IAAI,QAAQ,KAAK,SAAS,MAAM,GAAG,WAAW;AACpE,OAAI,UAAU,MAAM,UAAU,GAAG,OAAQ;AACzC,cAAW,UAAU,GAAG,UAAU;;AAEpC,YAAU,SAAS;AACnB,YAAU,SAAS;;AAErB,QAAO;EAAC;EAAW;EAAW;EAAS;;AAGzC,SAAS,SAAY,MAAoD;AACvE,QAAO;EACL;EACA,CAAC,OAAO,YAAY;AAClB,UAAO;;EAEV;;;AAIH,IAAM,QAAN,MAAM,MAAS;CAEb;CAKA;CAEA,YAAY,MAAW;AACrB,OAAK,OAAO;AACZ,OAAK,WAAW,KAAA;;CAGlB,aAAuC;AACrC,SAAO;;CAGT,SAAS;AAEP,SAAO,KAAK,KAAK,GAAG,GAAG;;CAGzB,SAAwB;AACtB,SAAO,KAAK,KAAK;;CAGnB,QAAkB;AAChB,SAAO,IAAI,MAAS,KAAK,KAAK,MAAM,EAAE,CAAC;;CAGzC,IAAI,KAAQ,MAAkC;EAC5C,MAAM,IAAI,QAAQ,KAAK,KAAK,MAAM,IAAI,KAAK,WAAW;AACtD,SAAO,IAAI,IAAI,KAAA,IAAY,KAAK,KAAK;;CAGvC,IAAI,KAAQ,MAA4B;EACtC,MAAM,IAAI,QAAQ,KAAK,KAAK,MAAM,IAAI,KAAK,WAAW;AACtD,SAAO,KAAK,KAAK,IAAI,KAAK,KAAK;;CAGjC,IAAI,KAAQ,MAAoC;EAC9C,IAAI,IAAI,QAAQ,KAAK,KAAK,MAAM,IAAI,KAAK,WAAW;AACpD,MAAI,IAAI,GAAG;AAET,OAAI,CAAC;AACL,QAAK;AAEL,OAAI,KAAK,KAAK,SAAS,eAAe;AACpC,SAAK,KAAK,OAAO,GAAG,GAAG,IAAI;AAC3B,WAAO;;GAGT,MAAM,kBAAkB,KAAK,mBAAmB;GAEhD,IAAI,SAAmB;AACvB,OAAI,IAAI,KAAK,KAAK,QAAQ;AACxB,SAAK,KAAK,KAAK;AACf,aAAS;;AAGX,UAAO,KAAK,OAAO,GAAG,GAAG,IAAI;AAE7B,UAAO;;AAIT,OAAK,KAAK,KAAK;AACf,SAAO;;CAGT,cAAc,KAAe;AAC3B,OAAK,KAAK,KAAK,IAAI,KAAK,OAAO,CAAE;;CAGnC,aAAa,KAAe;AAC1B,OAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,CAAE;;CAGpC,oBAA8B;EAC5B,MAAM,OAAO,KAAK,KAAK,UAAU;AAEjC,SAAO,IAAI,MADE,KAAK,KAAK,OAAO,KAAK,CACV;;CAG3B,OAAO,KAAQ,MAA4B;EACzC,MAAM,MAAM,KAAK;EACjB,MAAM,OAAO,QAAQ,KAAK,KAAK,MAAM,IAAI,IAAI;EAC7C,MAAM,QAAQ,OAAO;AAErB,MAAI,OAAO,EACT,QAAO;EAGT,MAAM,EAAC,SAAQ;AACf,OAAK,IAAI,IAAI,MAAM,IAAI,OAAO,KAAK;AAGjC,OAFY,KAAK,OAEL,KAAK,MAAM,KAAK,aAAa,KACvC,OAAM,IAAI,MAAM,8CAA8C;AAGhE,QAAK,KAAK,OAAO,GAAG,EAAE;AACtB,QAAK;AACL,UAAO;;AAGT,SAAO;;CAGT,aAAa,KAAe,GAAW;AACrC,OAAK,KAAK,KAAK,GAAG,IAAI,KAAK;;;;AAK/B,IAAM,gBAAN,MAAM,sBAAyB,MAAS;CAItC;;;;;CAMA,YAAY,UAAsB,MAAY;AAC5C,MAAI,CAAC,MAAM;AACT,UAAO,EAAE;AACT,QAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,IACnC,MAAK,KAAK,SAAS,GAAG,QAAQ;;AAGlC,QAAM,KAAK;AACX,OAAK,WAAW;;CAGlB,aAAuC;AACrC,SAAO;;CAGT,QAAkB;EAChB,MAAM,WAAW,KAAK,SAAS,MAAM,EAAE;AACvC,OAAK,IAAI,IAAI,GAAG,IAAI,SAAS,QAAQ,IACnC,UAAS,GAAG,WAAW;AAEzB,SAAO,IAAI,cAAiB,UAAU,KAAK,KAAK,MAAM,EAAE,CAAC;;CAG3D,SAAS;AACP,SAAO,KAAK,SAAS,GAAG,QAAQ;;CAGlC,IAAI,KAAQ,MAAkC;EAC5C,MAAM,IAAI,QAAQ,KAAK,KAAK,MAAM,GAAG,KAAK,WAAW;EACrD,MAAM,EAAC,aAAY;AACnB,SAAO,IAAI,SAAS,SAAS,SAAS,GAAG,IAAI,KAAK,KAAK,GAAG,KAAA;;CAG5D,IAAI,KAAQ,MAA4B;EACtC,MAAM,IAAI,QAAQ,KAAK,KAAK,MAAM,GAAG,KAAK,WAAW;EACrD,MAAM,EAAC,aAAY;AACnB,SAAO,IAAI,SAAS,SAAS,SAAS,GAAG,IAAI,KAAK,KAAK,GAAG;;CAG5D,IAAI,KAAQ,MAAoC;EAC9C,MAAM,IAAI,KAAK;EACf,MAAM,MAAM,KAAK;EACjB,IAAI,IAAI,KAAK,IAAI,QAAQ,KAAK,KAAK,MAAM,GAAG,IAAI,EAAE,EAAE,SAAS,EAAE;EAC/D,IAAI,QAAQ,EAAE;AAEd,MAAI,MAAM,SACR,GAAE,KAAK,QAAQ,MAAM,OAAO;AAE9B,MAAI,MAAM,KAAK,UAAU,eAAe;GAKtC,IAAI;AACJ,OACE,IAAI,MACH,QAAQ,EAAE,IAAI,IAAI,KAAK,SAAS,iBACjC,IAAI,MAAM,KAAK,IAAI,IAAI,GAAG,GAC1B;AACA,QAAI,MAAM,SACR,GAAE,IAAI,KAAK,QAAQ,MAAM,OAAO;AAElC,UAAM,cAAc,MAAM;AAC1B,SAAK,KAAK,IAAI,KAAK,MAAM,QAAQ;eAEhC,QAAQ,EAAE,IAAI,QAAQ,KAAA,KACvB,MAAM,KAAK,SAAS,iBACpB,IAAI,MAAM,QAAQ,EAAE,IAAI,GAAG,GAC3B;AACA,QAAI,MAAM,SAAU,GAAE,IAAI,KAAK,QAAQ,MAAM,OAAO;AACpD,UAAM,aAAa,MAAM;AACzB,SAAK,KAAK,KAAK,EAAE,GAAG,QAAQ;;;EAIhC,MAAM,SAAS,MAAM,IAAI,KAAK,KAAK;AACnC,OAAK,KAAK,KAAK,MAAM,QAAQ;AAC7B,MAAI,WAAW,KAAM,QAAO;AAG5B,MAAI,KAAK,KAAK,SAAS,eAAe;AAEpC,QAAK,OAAO,IAAI,GAAG,OAAO;AAC1B,UAAO;;EAGT,MAAM,kBAAkB,KAAK,mBAAmB;EAEhD,IAAI,SAA2B;AAC/B,MAAI,IAAI,OAAO,QAAQ,EAAE,KAAK,QAAQ,CAAC,GAAG,GAAG;AAC3C,YAAS;AACT,QAAK,KAAK,KAAK;;AAEjB,SAAO,OAAO,IAAI,GAAG,OAAO;AAC5B,SAAO;;;;;;;CAQT,OAAO,GAAW,OAAiB;AACjC,OAAK,SAAS,OAAO,GAAG,GAAG,MAAM;AACjC,OAAK,KAAK,OAAO,GAAG,GAAG,MAAM,QAAQ,CAAC;;;;;;CAOxC,oBAAoB;EAClB,MAAM,OAAO,KAAK,SAAS,UAAU;AACrC,SAAO,IAAI,cACT,KAAK,SAAS,OAAO,KAAK,EAC1B,KAAK,KAAK,OAAO,KAAK,CACvB;;CAGH,cAAc,KAAe;AAC3B,OAAK,KAAK,KAAK,IAAI,KAAK,OAAO,CAAE;AACjC,OAAK,SAAS,KAAM,IAAyB,SAAS,OAAO,CAAE;;CAGjE,aAAa,KAAe;AAC1B,OAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,CAAE;AAClC,OAAK,SAAS,QAAS,IAAyB,SAAS,KAAK,CAAE;;CAGlE,OAAO,KAAQ,MAA4B;EACzC,MAAM,MAAM,KAAK;EACjB,MAAM,EAAC,SAAQ;EACf,MAAM,EAAC,aAAY;EACnB,IAAI,OAAO,QAAQ,KAAK,KAAK,MAAM,GAAG,IAAI;EAC1C,IAAI,IAAI;EACR,MAAM,QAAQ,KAAK,IAAI,MAAM,KAAK,SAAS,EAAE;AAC7C,MAAI,KAAK,MACP,KAAI;AACF,OAAI,SAAS,GAAG,SACd,UAAS,KAAK,SAAS,GAAG,OAAO;GAEnC,MAAM,SAAS,SAAS,GAAG,OAAO,KAAK,KAAK;AAG5C,QAAK,KAAK,SAAS,GAAG,QAAQ;AAC9B,UAAO;YACC;GAER,MAAM,OAAO,iBAAiB;AAC9B,OAAI,OAAO,EAAG;AACd,QAAK,IAAI,OAAO,KAAK,MAAM,IACzB,KAAI,SAAS,GAAG,KAAK,UAAU,KAC7B,KAAI,SAAS,GAAG,KAAK,WAAW,EAC9B,MAAK,SAAS,GAAG,cAAc;QAC1B;AAEL,SAAK,OAAO,GAAG,EAAE;AACjB,aAAS,OAAO,GAAG,EAAE;;;AAM/B,SAAO;;;CAIT,SAAS,GAAW,SAA0B;EAC5C,MAAM,EAAC,aAAY;AACnB,MAAI,KAAK,KAAK,IAAI,IAAI,SAAS;OACzB,SAAS,GAAG,KAAK,SAAS,SAAS,IAAI,GAAG,KAAK,UAAU,SAAS;AACpE,QACE,SAAS,GAAG,SAGZ,UAAS,KAAK,SAAS,GAAG,OAAO;AAEnC,aAAS,GAAG,aAAa,SAAS,IAAI,IAAI,QAAQ;AAClD,aAAS,OAAO,IAAI,GAAG,EAAE;AACzB,SAAK,KAAK,OAAO,IAAI,GAAG,EAAE;AAC1B,SAAK,KAAK,KAAK,SAAS,GAAG,QAAQ;AACnC,WAAO;;;AAGX,SAAO;;;;;;;CAQT,aAAa,KAAe,aAAqB;EAE/C,MAAM,YAAY,KAAK,KAAK;AAC5B,OAAK,KAAK,KAAK,GAAG,IAAI,KAAK;EAC3B,MAAM,cAAe,IAAoC;AACzD,OAAK,SAAS,KAAK,GAAG,YAAY;AAElC,MAAI,IAAI,YAAY,CAAC,KAAK,SAGxB,MAAK,IAAI,IAAI,GAAG,IAAI,YAAY,QAAQ,IACtC,aAAY,GAAG,WAAW;AAO9B,OAAK,SAAS,YAAY,GAAG,YAAY;;;AAM7C,SAAS,QACP,KACA,MACA,SACA,YACQ;CACR,IAAI,KAAK;CACT,IAAI,KAAK,KAAK;CACd,IAAI,MAAM,MAAM;AAChB,QAAO,KAAK,IAAI;EACd,MAAM,IAAI,WAAW,KAAK,MAAM,IAAI;AACpC,MAAI,IAAI,EACN,MAAK,MAAM;WACF,IAAI,EAEb,MAAK;WACI,MAAM,EACf,QAAO;OACF;AAEL,OAAI,QAAQ,IAEV,QAAO,KAAK;AAEd,SAAM,IAAI,MAAM,wBAAwB;;AAE1C,QAAO,KAAK,MAAO;;AAErB,QAAO,MAAM;;AAIf,IAAM,YAAY,IAAI,MAAW,EAAE,CAAC;AACpC,UAAU,WAAW"}

package/out/shared/src/cache.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"cache.js","names":["#cache","#ttlMs","#intervalHandle"],"sources":["../../../../shared/src/cache.ts"],"sourcesContent":["/**\n * Stores values with an expiration time at time of insertion.\n * Does not update the expiration time on retrieval.\n * Values are automatically removed from the cache after the TTL expires.\n * The cache is cleaned up periodically based on the TTL so it does\n * not grow indefinitely.\n */\nexport class TimedCache<T> {\n  readonly #cache: Map<string, {value: T; expiresAt: number}>;\n  readonly #ttlMs: number;\n  readonly #intervalHandle: NodeJS.Timeout;\n\n  constructor(ttlMs: number) {\n    this.#cache = new Map();\n    this.#ttlMs = ttlMs;\n    this.#intervalHandle = setInterval(() => {\n      const now = Date.now();\n      for (const [key, entry] of this.#cache.entries()) {\n        if (entry.expiresAt < now) {\n          this.#cache.delete(key);\n        }\n      }\n    }, ttlMs * 2);\n  }\n\n  set(key: string, value: T): void {\n    const entry = {value, expiresAt: Date.now() + this.#ttlMs};\n    this.#cache.set(key, entry);\n  }\n\n  get(key: string): T | undefined {\n    const entry = this.#cache.get(key);\n    if (entry === undefined || entry.expiresAt < Date.now()) {\n      this.#cache.delete(key);\n      return undefined;\n    }\n    return entry.value;\n  }\n\n  destroy(): void {\n    clearInterval(this.#intervalHandle);\n    this.#cache.clear();\n  }\n}\n"],"mappings":";;;;;;;;AAOA,IAAa,aAAb,MAA2B;CACzB;CACA;CACA;CAEA,YAAY,OAAe;AACzB,QAAA,wBAAc,IAAI,KAAK;AACvB,QAAA,QAAc;AACd,QAAA,iBAAuB,kBAAkB;GACvC,MAAM,MAAM,KAAK,KAAK;AACtB,QAAK,MAAM,CAAC,KAAK,UAAU,MAAA,MAAY,SAAS,CAC9C,KAAI,MAAM,YAAY,IACpB,OAAA,MAAY,OAAO,IAAI;KAG1B,QAAQ,EAAE;;CAGf,IAAI,KAAa,OAAgB;EAC/B,MAAM,QAAQ;GAAC;GAAO,WAAW,KAAK,KAAK,GAAG,MAAA;GAAY;AAC1D,QAAA,MAAY,IAAI,KAAK,MAAM;;CAG7B,IAAI,KAA4B;EAC9B,MAAM,QAAQ,MAAA,MAAY,IAAI,IAAI;AAClC,MAAI,UAAU,KAAA,KAAa,MAAM,YAAY,KAAK,KAAK,EAAE;AACvD,SAAA,MAAY,OAAO,IAAI;AACvB;;AAEF,SAAO,MAAM;;CAGf,UAAgB;AACd,gBAAc,MAAA,eAAqB;AACnC,QAAA,MAAY,OAAO"}

package/out/shared/src/centroid.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"centroid.js","names":[],"sources":["../../../../shared/src/centroid.ts"],"sourcesContent":["// Apache License 2.0\n// https://github.com/influxdata/tdigest\n\n// Centroid average position of all points in a shape\nexport class Centroid {\n  mean: number;\n  weight: number;\n\n  constructor(mean: number, weight: number) {\n    this.mean = mean;\n    this.weight = weight;\n  }\n\n  add(r: Centroid): void {\n    if (r.weight < 0) {\n      throw new Error('centroid weight cannot be less than zero');\n    }\n    if (this.weight !== 0) {\n      this.weight += r.weight;\n      this.mean += (r.weight * (r.mean - this.mean)) / this.weight;\n    } else {\n      this.weight = r.weight;\n      this.mean = r.mean;\n    }\n  }\n}\n\n/** CentroidList is sorted by the mean of the centroid, ascending. */\nexport type CentroidList = Centroid[];\n\nexport function sortCentroidList(centroids: CentroidList): void {\n  centroids.sort((a, b) => a.mean - b.mean);\n}\n"],"mappings":";AAIA,IAAa,WAAb,MAAsB;CACpB;CACA;CAEA,YAAY,MAAc,QAAgB;AACxC,OAAK,OAAO;AACZ,OAAK,SAAS;;CAGhB,IAAI,GAAmB;AACrB,MAAI,EAAE,SAAS,EACb,OAAM,IAAI,MAAM,2CAA2C;AAE7D,MAAI,KAAK,WAAW,GAAG;AACrB,QAAK,UAAU,EAAE;AACjB,QAAK,QAAS,EAAE,UAAU,EAAE,OAAO,KAAK,QAAS,KAAK;SACjD;AACL,QAAK,SAAS,EAAE;AAChB,QAAK,OAAO,EAAE;;;;AAQpB,SAAgB,iBAAiB,WAA+B;AAC9D,WAAU,MAAM,GAAG,MAAM,EAAE,OAAO,EAAE,KAAK"}

package/out/shared/src/config.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"config.js","names":[],"sources":["../../../../shared/src/config.ts"],"sourcesContent":["declare const process: {\n  env: {\n    NODE_ENV?: string;\n  };\n};\n\nexport const isProd = process.env.NODE_ENV === 'production';\n\nexport {isProd as skipAssertJSONValue};\n"],"mappings":";AAMA,IAAa,SAAA,QAAA,IAAA,aAAkC"}

package/out/shared/src/custom-key-map.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-key-map.js","names":["#toKey","#map"],"sources":["../../../../shared/src/custom-key-map.ts"],"sourcesContent":["type Primitive = undefined | null | boolean | string | number | symbol | bigint;\n\n/**\n * A {@link Map} that uses a custom key transformation function to convert keys\n * to a primitive type that can be used as a {@link Map} key.\n *\n * This allows for using objects as keys in a {@link Map} without worrying about\n * reference equality.\n */\nexport class CustomKeyMap<K, V> {\n  readonly [Symbol.toStringTag] = 'CustomKeyMap';\n  readonly #toKey: (key: K) => Primitive;\n  readonly #map = new Map<Primitive, readonly [K, V]>();\n\n  constructor(\n    toKey: (key: K) => Primitive,\n    iterable?: Iterable<readonly [K, V]> | null,\n  ) {\n    this.#toKey = toKey;\n    if (iterable) {\n      for (const [key, value] of iterable ?? []) {\n        this.#map.set(toKey(key), [key, value]);\n      }\n    }\n  }\n\n  clear(): void {\n    this.#map.clear();\n  }\n\n  delete(key: K): boolean {\n    return this.#map.delete(this.#toKey(key));\n  }\n\n  forEach(\n    callbackfn: (value: V, key: K, map: CustomKeyMap<K, V>) => void,\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    thisArg?: any,\n  ): void {\n    for (const [key, value] of this.#map.values()) {\n      callbackfn.call(thisArg, value, key, this);\n    }\n  }\n\n  get(key: K): V | undefined {\n    return this.#map.get(this.#toKey(key))?.[1];\n  }\n\n  has(key: K): boolean {\n    return this.#map.has(this.#toKey(key));\n  }\n\n  set(key: K, value: V): this {\n    this.#map.set(this.#toKey(key), [key, value]);\n    return this;\n  }\n\n  get size(): number {\n    return this.#map.size;\n  }\n\n  *entries(): MapIterator<[K, V]> {\n    for (const entry of this.#map.values()) {\n      yield entry.slice(0, 2) as [K, V];\n    }\n  }\n\n  *keys(): MapIterator<K> {\n    for (const entry of this.#map.values()) {\n      yield entry[0];\n    }\n  }\n\n  *values(): MapIterator<V> {\n    for (const entry of this.#map.values()) {\n      yield entry[1];\n    }\n  }\n\n  [Symbol.iterator](): MapIterator<[K, V]> {\n    return this.entries();\n  }\n}\n"],"mappings":";;;;;;;;AASA,IAAa,eAAb,MAAgC;CAC9B,CAAU,OAAO,eAAe;CAChC;CACA,uBAAgB,IAAI,KAAiC;CAErD,YACE,OACA,UACA;AACA,QAAA,QAAc;AACd,MAAI,SACF,MAAK,MAAM,CAAC,KAAK,UAAU,YAAY,EAAE,CACvC,OAAA,IAAU,IAAI,MAAM,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;;CAK7C,QAAc;AACZ,QAAA,IAAU,OAAO;;CAGnB,OAAO,KAAiB;AACtB,SAAO,MAAA,IAAU,OAAO,MAAA,MAAY,IAAI,CAAC;;CAG3C,QACE,YAEA,SACM;AACN,OAAK,MAAM,CAAC,KAAK,UAAU,MAAA,IAAU,QAAQ,CAC3C,YAAW,KAAK,SAAS,OAAO,KAAK,KAAK;;CAI9C,IAAI,KAAuB;AACzB,SAAO,MAAA,IAAU,IAAI,MAAA,MAAY,IAAI,CAAC,GAAG;;CAG3C,IAAI,KAAiB;AACnB,SAAO,MAAA,IAAU,IAAI,MAAA,MAAY,IAAI,CAAC;;CAGxC,IAAI,KAAQ,OAAgB;AAC1B,QAAA,IAAU,IAAI,MAAA,MAAY,IAAI,EAAE,CAAC,KAAK,MAAM,CAAC;AAC7C,SAAO;;CAGT,IAAI,OAAe;AACjB,SAAO,MAAA,IAAU;;CAGnB,CAAC,UAA+B;AAC9B,OAAK,MAAM,SAAS,MAAA,IAAU,QAAQ,CACpC,OAAM,MAAM,MAAM,GAAG,EAAE;;CAI3B,CAAC,OAAuB;AACtB,OAAK,MAAM,SAAS,MAAA,IAAU,QAAQ,CACpC,OAAM,MAAM;;CAIhB,CAAC,SAAyB;AACxB,OAAK,MAAM,SAAS,MAAA,IAAU,QAAQ,CACpC,OAAM,MAAM;;CAIhB,CAAC,OAAO,YAAiC;AACvC,SAAO,KAAK,SAAS"}

package/out/shared/src/custom-key-set.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"custom-key-set.js","names":["#toKey","#map"],"sources":["../../../../shared/src/custom-key-set.ts"],"sourcesContent":["type Primitive = undefined | null | boolean | string | number | symbol | bigint;\n\n/**\n * A {@link Set} that uses a custom value transformation function to convert values\n * to a primitive type that can be used as a {@link Set} value.\n *\n * This allows for using objects as values in a {@link Set} without worrying about\n * reference equality.\n */\n\nexport class CustomKeySet<V> {\n  readonly [Symbol.toStringTag] = 'CustomKeySet';\n  readonly #toKey: (value: V) => Primitive;\n  readonly #map = new Map<Primitive, V>();\n\n  constructor(toKey: (value: V) => Primitive, iterable?: Iterable<V> | null) {\n    this.#toKey = toKey;\n    if (iterable) {\n      for (const value of iterable ?? []) {\n        this.#map.set(toKey(value), value);\n      }\n    }\n  }\n\n  add(value: V): this {\n    this.#map.set(this.#toKey(value), value);\n    return this;\n  }\n\n  clear(): void {\n    this.#map.clear();\n  }\n\n  delete(value: V): boolean {\n    return this.#map.delete(this.#toKey(value));\n  }\n\n  forEach(\n    callbackfn: (value: V, value2: V, set: CustomKeySet<V>) => void,\n    // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n    thisArg?: any,\n  ): void {\n    this.#map.forEach(value => {\n      callbackfn.call(thisArg, value, value, this);\n    });\n  }\n\n  has(value: V): boolean {\n    return this.#map.has(this.#toKey(value));\n  }\n\n  get size(): number {\n    return this.#map.size;\n  }\n\n  *entries(): IterableIterator<[V, V]> {\n    for (const value of this.#map.values()) {\n      yield [value, value];\n    }\n  }\n\n  keys(): IterableIterator<V> {\n    return this.#map.values();\n  }\n\n  values(): IterableIterator<V> {\n    return this.#map.values();\n  }\n\n  [Symbol.iterator](): IterableIterator<V> {\n    return this.#map.values();\n  }\n}\n"],"mappings":";;;;;;;;AAUA,IAAa,eAAb,MAA6B;CAC3B,CAAU,OAAO,eAAe;CAChC;CACA,uBAAgB,IAAI,KAAmB;CAEvC,YAAY,OAAgC,UAA+B;AACzE,QAAA,QAAc;AACd,MAAI,SACF,MAAK,MAAM,SAAS,YAAY,EAAE,CAChC,OAAA,IAAU,IAAI,MAAM,MAAM,EAAE,MAAM;;CAKxC,IAAI,OAAgB;AAClB,QAAA,IAAU,IAAI,MAAA,MAAY,MAAM,EAAE,MAAM;AACxC,SAAO;;CAGT,QAAc;AACZ,QAAA,IAAU,OAAO;;CAGnB,OAAO,OAAmB;AACxB,SAAO,MAAA,IAAU,OAAO,MAAA,MAAY,MAAM,CAAC;;CAG7C,QACE,YAEA,SACM;AACN,QAAA,IAAU,SAAQ,UAAS;AACzB,cAAW,KAAK,SAAS,OAAO,OAAO,KAAK;IAC5C;;CAGJ,IAAI,OAAmB;AACrB,SAAO,MAAA,IAAU,IAAI,MAAA,MAAY,MAAM,CAAC;;CAG1C,IAAI,OAAe;AACjB,SAAO,MAAA,IAAU;;CAGnB,CAAC,UAAoC;AACnC,OAAK,MAAM,SAAS,MAAA,IAAU,QAAQ,CACpC,OAAM,CAAC,OAAO,MAAM;;CAIxB,OAA4B;AAC1B,SAAO,MAAA,IAAU,QAAQ;;CAG3B,SAA8B;AAC5B,SAAO,MAAA,IAAU,QAAQ;;CAG3B,CAAC,OAAO,YAAiC;AACvC,SAAO,MAAA,IAAU,QAAQ"}

package/out/shared/src/deep-clone.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-clone.js","names":[],"sources":["../../../../shared/src/deep-clone.ts"],"sourcesContent":["import {hasOwn} from './has-own.ts';\nimport type {JSONValue, ReadonlyJSONValue} from './json.ts';\n\nexport function deepClone(value: ReadonlyJSONValue): JSONValue {\n  const seen: Array<ReadonlyJSONValue> = [];\n  return internalDeepClone(value, seen);\n}\n\nexport function internalDeepClone(\n  value: ReadonlyJSONValue,\n  seen: Array<ReadonlyJSONValue>,\n): JSONValue {\n  switch (typeof value) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n    case 'undefined':\n      return value;\n    case 'object': {\n      if (value === null) {\n        return null;\n      }\n      if (seen.includes(value)) {\n        throw new Error('Cyclic object');\n      }\n      seen.push(value);\n      if (Array.isArray(value)) {\n        const rv = value.map(v => internalDeepClone(v, seen));\n        seen.pop();\n        return rv;\n      }\n\n      const obj: JSONValue = {};\n\n      for (const k in value) {\n        if (hasOwn(value, k)) {\n          const v = (value as Record<string, ReadonlyJSONValue>)[k];\n          if (v !== undefined) {\n            obj[k] = internalDeepClone(v, seen);\n          }\n        }\n      }\n      seen.pop();\n      return obj;\n    }\n\n    default:\n      throw new Error(`Invalid type: ${typeof value}`);\n  }\n}\n"],"mappings":";;AAGA,SAAgB,UAAU,OAAqC;AAE7D,QAAO,kBAAkB,OADc,EAAE,CACJ;;AAGvC,SAAgB,kBACd,OACA,MACW;AACX,SAAQ,OAAO,OAAf;EACE,KAAK;EACL,KAAK;EACL,KAAK;EACL,KAAK,YACH,QAAO;EACT,KAAK,UAAU;AACb,OAAI,UAAU,KACZ,QAAO;AAET,OAAI,KAAK,SAAS,MAAM,CACtB,OAAM,IAAI,MAAM,gBAAgB;AAElC,QAAK,KAAK,MAAM;AAChB,OAAI,MAAM,QAAQ,MAAM,EAAE;IACxB,MAAM,KAAK,MAAM,KAAI,MAAK,kBAAkB,GAAG,KAAK,CAAC;AACrD,SAAK,KAAK;AACV,WAAO;;GAGT,MAAM,MAAiB,EAAE;AAEzB,QAAK,MAAM,KAAK,MACd,KAAI,OAAO,OAAO,EAAE,EAAE;IACpB,MAAM,IAAK,MAA4C;AACvD,QAAI,MAAM,KAAA,EACR,KAAI,KAAK,kBAAkB,GAAG,KAAK;;AAIzC,QAAK,KAAK;AACV,UAAO;;EAGT,QACE,OAAM,IAAI,MAAM,iBAAiB,OAAO,QAAQ"}

package/out/shared/src/deep-merge.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"deep-merge.js","names":[],"sources":["../../../../shared/src/deep-merge.ts"],"sourcesContent":["// Force TypeScript to evaluate/flatten a type\ntype Simplify<T> = {[K in keyof T]: T[K]} & {};\n\n// Helper to check if T is a plain object (not array or function)\ntype IsPlainObject<T> = T extends object\n  ? T extends Function | readonly unknown[]\n    ? false\n    : true\n  : false;\n\ntype IsLeaf<T, Leaf> = [T] extends [Leaf] ? true : false;\n\ntype MergeValue<A, B, Leaf> =\n  IsLeaf<A, Leaf> extends true\n    ? B\n    : IsLeaf<B, Leaf> extends true\n      ? B\n      : IsPlainObject<A> extends true\n        ? IsPlainObject<B> extends true\n          ? DeepMerge<A & {}, B & {}, Leaf>\n          : B\n        : B;\n\n/**\n * Type-level deep merge of two object types. Properties from B override\n * properties from A. When both A[K] and B[K] are objects (not arrays or\n * functions), they are recursively merged.\n */\nexport type DeepMerge<A, B, Leaf = never> = Simplify<\n  Omit<A, keyof B> & {\n    [K in keyof B]: K extends keyof A ? MergeValue<A[K], B[K], Leaf> : B[K];\n  }\n>;\n\nexport function isPlainObject(\n  value: unknown,\n): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null;\n}\n\n/**\n * Deep merges two objects. Properties from `b` override properties from `a`.\n * Nested objects are recursively merged.\n *\n * @param a - The base object.\n * @param b - The object to merge into `a`.\n * @param isLeaf - Optional predicate to determine if a value should be treated\n *   as a leaf (not recursed into). Defaults to checking if the value is not a\n *   plain object.\n */\nexport function deepMerge<\n  A extends Record<string, unknown>,\n  B extends Record<string, unknown>,\n  Leaf = never,\n>(\n  a: A,\n  b: B,\n  isLeaf: (value: unknown) => boolean = v => !isPlainObject(v),\n): DeepMerge<A, B, Leaf> {\n  const result: Record<string, unknown> = {};\n\n  // Copy all keys from a\n  for (const key of Object.keys(a)) {\n    result[key] = a[key];\n  }\n\n  // Merge/override with keys from b\n  for (const key of Object.keys(b)) {\n    const aVal = a[key];\n    const bVal = b[key];\n\n    if (key in a && !isLeaf(aVal) && !isLeaf(bVal)) {\n      result[key] = deepMerge<\n        Record<string, unknown>,\n        Record<string, unknown>,\n        Leaf\n      >(\n        aVal as Record<string, unknown>,\n        bVal as Record<string, unknown>,\n        isLeaf,\n      );\n    } else {\n      result[key] = bVal;\n    }\n  }\n\n  return result as DeepMerge<A, B, Leaf>;\n}\n"],"mappings":";AAkCA,SAAgB,cACd,OACkC;AAClC,QAAO,OAAO,UAAU,YAAY,UAAU;;;;;;;;;;;;AAahD,SAAgB,UAKd,GACA,GACA,UAAsC,MAAK,CAAC,cAAc,EAAE,EACrC;CACvB,MAAM,SAAkC,EAAE;AAG1C,MAAK,MAAM,OAAO,OAAO,KAAK,EAAE,CAC9B,QAAO,OAAO,EAAE;AAIlB,MAAK,MAAM,OAAO,OAAO,KAAK,EAAE,EAAE;EAChC,MAAM,OAAO,EAAE;EACf,MAAM,OAAO,EAAE;AAEf,MAAI,OAAO,KAAK,CAAC,OAAO,KAAK,IAAI,CAAC,OAAO,KAAK,CAC5C,QAAO,OAAO,UAKZ,MACA,MACA,OACD;MAED,QAAO,OAAO;;AAIlB,QAAO"}

package/out/shared/src/document-visible.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"document-visible.js","names":["#doc","#hiddenIntervalMS","#promises","#onVisibilityChange","#timeoutID","#setVisibilityState","#waitFor"],"sources":["../../../../shared/src/document-visible.ts"],"sourcesContent":["import {resolver} from '@rocicorp/resolver';\n\ntype PartialDocument = Pick<\n  Document,\n  'visibilityState' | 'addEventListener' | 'removeEventListener'\n>;\n\nexport function getDocumentVisibilityWatcher(\n  doc: PartialDocument | undefined,\n  hiddenIntervalMS: number,\n  signal: AbortSignal,\n): DocumentVisibilityWatcher {\n  return doc\n    ? new DocumentVisibilityWatcherImpl(doc, hiddenIntervalMS, signal)\n    : new DocumentVisibilityWatcherNoDoc();\n}\n\nexport interface DocumentVisibilityWatcher {\n  readonly visibilityState: DocumentVisibilityState;\n  waitForVisible(): Promise<unknown>;\n  waitForHidden(): Promise<unknown>;\n}\n\nclass DocumentVisibilityWatcherImpl implements DocumentVisibilityWatcher {\n  readonly #doc: PartialDocument;\n  readonly #hiddenIntervalMS: number;\n  #timeoutID: ReturnType<typeof setTimeout> | 0 = 0;\n\n  // This trails doc.visibilityState by hiddenIntervalMS when being hidden. This\n  // is because we want to wait for the tab to be hidden for a while before\n  // considering as hidden.\n  visibilityState: DocumentVisibilityState;\n\n  readonly #promises = new Set<{\n    resolve: () => void;\n    state: DocumentVisibilityState;\n  }>();\n\n  constructor(\n    doc: PartialDocument,\n    hiddenIntervalMS: number,\n    signal: AbortSignal,\n  ) {\n    this.#doc = doc;\n    this.#hiddenIntervalMS = hiddenIntervalMS;\n    this.visibilityState = doc.visibilityState;\n    // Safari got support for abort signal in addEventListener in version\n    // 15 (Released 2021-09-20)\n    this.#doc.addEventListener('visibilitychange', this.#onVisibilityChange, {\n      signal,\n    });\n  }\n\n  #onVisibilityChange = () => {\n    if (this.#doc.visibilityState === 'visible') {\n      clearTimeout(this.#timeoutID);\n      this.#setVisibilityState('visible');\n    } else {\n      this.#timeoutID = setTimeout(() => {\n        this.#setVisibilityState('hidden');\n      }, this.#hiddenIntervalMS);\n    }\n  };\n\n  #setVisibilityState(visibilityState: DocumentVisibilityState) {\n    if (visibilityState === this.visibilityState) {\n      return;\n    }\n    this.visibilityState = visibilityState;\n    for (const entry of this.#promises) {\n      const {resolve, state} = entry;\n      if (state === visibilityState) {\n        resolve();\n        this.#promises.delete(entry);\n      }\n    }\n  }\n\n  waitForVisible(): Promise<unknown> {\n    return this.#waitFor('visible');\n  }\n\n  waitForHidden(): Promise<unknown> {\n    return this.#waitFor('hidden');\n  }\n\n  #waitFor(state: DocumentVisibilityState): Promise<unknown> {\n    if (this.visibilityState === state) {\n      return Promise.resolve();\n    }\n\n    const {promise, resolve} = resolver();\n    this.#promises.add({resolve, state});\n    return promise;\n  }\n}\n\nconst resolvedPromise = Promise.resolve();\nconst promiseThatNeverResolves = new Promise(() => undefined);\n\nclass DocumentVisibilityWatcherNoDoc implements DocumentVisibilityWatcher {\n  readonly visibilityState: DocumentVisibilityState = 'visible';\n  waitForVisible(): Promise<unknown> {\n    return resolvedPromise;\n  }\n\n  waitForHidden(): Promise<unknown> {\n    return promiseThatNeverResolves;\n  }\n}\n"],"mappings":";;AAOA,SAAgB,6BACd,KACA,kBACA,QAC2B;AAC3B,QAAO,MACH,IAAI,8BAA8B,KAAK,kBAAkB,OAAO,GAChE,IAAI,gCAAgC;;AAS1C,IAAM,gCAAN,MAAyE;CACvE;CACA;CACA,aAAgD;CAKhD;CAEA,4BAAqB,IAAI,KAGrB;CAEJ,YACE,KACA,kBACA,QACA;AACA,QAAA,MAAY;AACZ,QAAA,mBAAyB;AACzB,OAAK,kBAAkB,IAAI;AAG3B,QAAA,IAAU,iBAAiB,oBAAoB,MAAA,oBAA0B,EACvE,QACD,CAAC;;CAGJ,4BAA4B;AAC1B,MAAI,MAAA,IAAU,oBAAoB,WAAW;AAC3C,gBAAa,MAAA,UAAgB;AAC7B,SAAA,mBAAyB,UAAU;QAEnC,OAAA,YAAkB,iBAAiB;AACjC,SAAA,mBAAyB,SAAS;KACjC,MAAA,iBAAuB;;CAI9B,oBAAoB,iBAA0C;AAC5D,MAAI,oBAAoB,KAAK,gBAC3B;AAEF,OAAK,kBAAkB;AACvB,OAAK,MAAM,SAAS,MAAA,UAAgB;GAClC,MAAM,EAAC,SAAS,UAAS;AACzB,OAAI,UAAU,iBAAiB;AAC7B,aAAS;AACT,UAAA,SAAe,OAAO,MAAM;;;;CAKlC,iBAAmC;AACjC,SAAO,MAAA,QAAc,UAAU;;CAGjC,gBAAkC;AAChC,SAAO,MAAA,QAAc,SAAS;;CAGhC,SAAS,OAAkD;AACzD,MAAI,KAAK,oBAAoB,MAC3B,QAAO,QAAQ,SAAS;EAG1B,MAAM,EAAC,SAAS,YAAW,UAAU;AACrC,QAAA,SAAe,IAAI;GAAC;GAAS;GAAM,CAAC;AACpC,SAAO;;;AAIX,IAAM,kBAAkB,QAAQ,SAAS;AACzC,IAAM,2BAA2B,IAAI,cAAc,KAAA,EAAU;AAE7D,IAAM,iCAAN,MAA0E;CACxE,kBAAoD;CACpD,iBAAmC;AACjC,SAAO;;CAGT,gBAAkC;AAChC,SAAO"}

package/out/shared/src/dotenv.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"dotenv.js","names":[],"sources":["../../../../shared/src/dotenv.ts"],"sourcesContent":["import {config as dotenvxConfig} from '@dotenvx/dotenvx';\n\n// Import env vars from .env file if present but don't whine if not present.\n// Also no free marketing for dotenvx.\ndotenvxConfig({\n  ignore: ['MISSING_ENV_FILE'],\n  quiet: true,\n});\n"],"mappings":";;AAIA,OAAc;CACZ,QAAQ,CAAC,mBAAmB;CAC5B,OAAO;CACR,CAAC"}

package/out/shared/src/error.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"error.js","names":[],"sources":["../../../../shared/src/error.ts"],"sourcesContent":["import {jsonSchema} from './json-schema.ts';\nimport type {ReadonlyJSONValue} from './json.ts';\n\nexport function getErrorMessage(error: unknown): string {\n  return getErrorMessageInternal(error, new Set());\n}\n\nfunction getErrorMessageInternal(error: unknown, seen: Set<unknown>): string {\n  if (typeof error === 'string') {\n    return error;\n  }\n\n  if (typeof error === 'object' && error !== null) {\n    if (seen.has(error)) {\n      return 'Circular error reference detected while extracting the error message.';\n    }\n    seen.add(error);\n  }\n\n  if (error instanceof Error) {\n    if (error.message) {\n      return error.message;\n    }\n\n    if ('cause' in error) {\n      const {cause} = error as {cause: unknown};\n      if (cause !== undefined) {\n        const causeMessage = getErrorMessageInternal(cause, seen);\n        if (causeMessage) {\n          return causeMessage;\n        }\n      }\n    }\n  }\n\n  if (\n    typeof error === 'object' &&\n    error !== null &&\n    'message' in error &&\n    typeof (error as {message: unknown}).message === 'string'\n  ) {\n    const message = (error as {message: string}).message;\n    if (message) {\n      return message;\n    }\n  }\n\n  try {\n    const json = jsonSchema.parse(error);\n    return `Parsed message: ${JSON.stringify(json)}`;\n  } catch {}\n\n  return `Unknown error of type ${typeof error} was thrown and the message could not be determined. See cause for details.`;\n}\n\nexport function getErrorDetails(error: unknown): ReadonlyJSONValue | undefined {\n  if (error instanceof Error) {\n    if ('details' in error) {\n      try {\n        return jsonSchema.parse(error?.details);\n      } catch {}\n    }\n\n    if (error.name && error.name !== 'Error') {\n      return {name: error.name};\n    }\n\n    return undefined;\n  }\n\n  if (typeof error === 'object' && error !== null && 'details' in error) {\n    try {\n      return jsonSchema.parse((error as {details: ReadonlyJSONValue})?.details);\n    } catch {}\n  }\n\n  try {\n    return jsonSchema.parse(error);\n  } catch {}\n\n  return undefined;\n}\n"],"mappings":";;AAGA,SAAgB,gBAAgB,OAAwB;AACtD,QAAO,wBAAwB,uBAAO,IAAI,KAAK,CAAC;;AAGlD,SAAS,wBAAwB,OAAgB,MAA4B;AAC3E,KAAI,OAAO,UAAU,SACnB,QAAO;AAGT,KAAI,OAAO,UAAU,YAAY,UAAU,MAAM;AAC/C,MAAI,KAAK,IAAI,MAAM,CACjB,QAAO;AAET,OAAK,IAAI,MAAM;;AAGjB,KAAI,iBAAiB,OAAO;AAC1B,MAAI,MAAM,QACR,QAAO,MAAM;AAGf,MAAI,WAAW,OAAO;GACpB,MAAM,EAAC,UAAS;AAChB,OAAI,UAAU,KAAA,GAAW;IACvB,MAAM,eAAe,wBAAwB,OAAO,KAAK;AACzD,QAAI,aACF,QAAO;;;;AAMf,KACE,OAAO,UAAU,YACjB,UAAU,QACV,aAAa,SACb,OAAQ,MAA6B,YAAY,UACjD;EACA,MAAM,UAAW,MAA4B;AAC7C,MAAI,QACF,QAAO;;AAIX,KAAI;EACF,MAAM,OAAO,WAAW,MAAM,MAAM;AACpC,SAAO,mBAAmB,KAAK,UAAU,KAAK;SACxC;AAER,QAAO,yBAAyB,OAAO,MAAM;;AAG/C,SAAgB,gBAAgB,OAA+C;AAC7E,KAAI,iBAAiB,OAAO;AAC1B,MAAI,aAAa,MACf,KAAI;AACF,UAAO,WAAW,MAAM,OAAO,QAAQ;UACjC;AAGV,MAAI,MAAM,QAAQ,MAAM,SAAS,QAC/B,QAAO,EAAC,MAAM,MAAM,MAAK;AAG3B;;AAGF,KAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,aAAa,MAC9D,KAAI;AACF,SAAO,WAAW,MAAO,OAAwC,QAAQ;SACnE;AAGV,KAAI;AACF,SAAO,WAAW,MAAM,MAAM;SACxB"}

package/out/shared/src/has-own.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"has-own.js","names":[],"sources":["../../../../shared/src/has-own.ts"],"sourcesContent":["// hasOwn was added in ES2022\nexport const {hasOwn} = Object;\n"],"mappings":";AACA,IAAa,EAAC,WAAU"}

package/out/shared/src/hash.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"hash.js","names":[],"sources":["../../../../shared/src/hash.ts"],"sourcesContent":["import {xxHash32} from 'js-xxhash';\n\nexport const h32 = (s: string) => xxHash32(s, 0);\nexport const h64 = (s: string) => hash(s, 2);\nexport const h128 = (s: string) => hash(s, 4);\n\n/**\n * xxHash32 only computes 32-bit values. Run it n times with different seeds to\n * get a larger hash with better collision resistance.\n */\nfunction hash(str: string, words: number): bigint {\n  let hash = 0n;\n  for (let i = 0; i < words; i++) {\n    hash = (hash << 32n) + BigInt(xxHash32(str, i));\n  }\n  return hash;\n}\n"],"mappings":";;AAEA,IAAa,OAAO,MAAc,SAAS,GAAG,EAAE;AAChD,IAAa,OAAO,MAAc,KAAK,GAAG,EAAE;AAC5C,IAAa,QAAQ,MAAc,KAAK,GAAG,EAAE;;;;;AAM7C,SAAS,KAAK,KAAa,OAAuB;CAChD,IAAI,OAAO;AACX,MAAK,IAAI,IAAI,GAAG,IAAI,OAAO,IACzB,SAAQ,QAAQ,OAAO,OAAO,SAAS,KAAK,EAAE,CAAC;AAEjD,QAAO"}

package/out/shared/src/iterables.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"iterables.js","names":["#iterator"],"sources":["../../../../shared/src/iterables.ts"],"sourcesContent":["export function* joinIterables<T>(...iters: Iterable<T>[]) {\n  for (const iter of iters) {\n    yield* iter;\n  }\n}\n\nfunction* filterIter<T>(\n  iter: Iterable<T>,\n  p: (t: T, index: number) => boolean,\n): Iterable<T> {\n  let index = 0;\n  for (const t of iter) {\n    if (p(t, index++)) {\n      yield t;\n    }\n  }\n}\n\nfunction* mapIter<T, U>(\n  iter: Iterable<T>,\n  f: (t: T, index: number) => U,\n): Iterable<U> {\n  let index = 0;\n  for (const t of iter) {\n    yield f(t, index++);\n  }\n}\n\nexport function first<T>(stream: Iterable<T>): T | undefined {\n  const it = stream[Symbol.iterator]();\n  const {value} = it.next();\n  it.return?.();\n  return value;\n}\n\nexport function* once<T>(stream: Iterable<T>): Iterable<T> {\n  const it = stream[Symbol.iterator]();\n  const {value} = it.next();\n  if (value !== undefined) {\n    yield value;\n  }\n  it.return?.();\n}\n\n// ES2024 Iterator helpers are available in Node 22+ and part of ES2024.\n// https://github.com/tc39/proposal-iterator-helpers\n\ntype IteratorWithHelpers<T> = Iterator<T> & {\n  map<U>(f: (t: T, index: number) => U): IteratorWithHelpers<U>;\n  filter(p: (t: T, index: number) => boolean): IteratorWithHelpers<T>;\n  [Symbol.iterator](): IteratorWithHelpers<T>;\n};\n\ntype IteratorConstructor = {\n  from<T>(this: void, iter: Iterable<T>): IteratorWithHelpers<T>;\n};\n\n// Check if native Iterator.from is available and bind it once at startup\n// We use globalThis to access the runtime value safely\nconst iteratorCtor = (globalThis as {Iterator?: IteratorConstructor}).Iterator;\nconst nativeIteratorFrom = iteratorCtor?.from as\n  | (<T>(iter: Iterable<T>) => IteratorWithHelpers<T>)\n  | undefined;\n\nconst iteratorFrom: <T>(e: Iterable<T>) => IteratorWithHelpers<T> =\n  nativeIteratorFrom ?? (e => new IterWrapper(e));\n\n// Fallback implementation for environments without ES2024 Iterator helpers\nclass IterWrapper<T> implements IteratorWithHelpers<T>, IterableIterator<T> {\n  readonly #iterator: Iterator<T>;\n\n  constructor(iterable: Iterable<T>) {\n    this.#iterator = iterable[Symbol.iterator]();\n  }\n\n  next(): IteratorResult<T> {\n    return this.#iterator.next();\n  }\n\n  [Symbol.iterator](): IteratorWithHelpers<T> {\n    return this;\n  }\n\n  map<U>(f: (t: T, index: number) => U): IterWrapper<U> {\n    return new IterWrapper(mapIter(this, f));\n  }\n\n  filter(p: (t: T, index: number) => boolean): IterWrapper<T> {\n    return new IterWrapper(filterIter(this, p));\n  }\n}\n\nexport function wrapIterable<T>(iter: Iterable<T>): IteratorWithHelpers<T> {\n  return iteratorFrom(iter);\n}\n\n/**\n * This will make a new array where the elements are the same as the iterable\n * but sorted according to the compare function. If the compare function is not\n * provided, it will sort the elements in JS standard way which is string\n * compare.\n */\nexport function toSorted<T>(\n  iter: Iterable<T>,\n  compare?: (a: T, b: T) => number,\n): T[] {\n  // oxlint-disable-next-line e18e/prefer-array-to-sorted\n  return [...iter].sort(compare);\n}\n"],"mappings":";AAAA,UAAiB,cAAiB,GAAG,OAAsB;AACzD,MAAK,MAAM,QAAQ,MACjB,QAAO;;AAIX,UAAU,WACR,MACA,GACa;CACb,IAAI,QAAQ;AACZ,MAAK,MAAM,KAAK,KACd,KAAI,EAAE,GAAG,QAAQ,CACf,OAAM;;AAKZ,UAAU,QACR,MACA,GACa;CACb,IAAI,QAAQ;AACZ,MAAK,MAAM,KAAK,KACd,OAAM,EAAE,GAAG,QAAQ;;AAWvB,UAAiB,KAAQ,QAAkC;CACzD,MAAM,KAAK,OAAO,OAAO,WAAW;CACpC,MAAM,EAAC,UAAS,GAAG,MAAM;AACzB,KAAI,UAAU,KAAA,EACZ,OAAM;AAER,IAAG,UAAU;;AAuBf,IAAM,eALgB,WAAgD,UAC7B,UAKhB,MAAK,IAAI,YAAY,EAAE;AAGhD,IAAM,cAAN,MAAM,YAAsE;CAC1E;CAEA,YAAY,UAAuB;AACjC,QAAA,WAAiB,SAAS,OAAO,WAAW;;CAG9C,OAA0B;AACxB,SAAO,MAAA,SAAe,MAAM;;CAG9B,CAAC,OAAO,YAAoC;AAC1C,SAAO;;CAGT,IAAO,GAA+C;AACpD,SAAO,IAAI,YAAY,QAAQ,MAAM,EAAE,CAAC;;CAG1C,OAAO,GAAqD;AAC1D,SAAO,IAAI,YAAY,WAAW,MAAM,EAAE,CAAC;;;AAI/C,SAAgB,aAAgB,MAA2C;AACzE,QAAO,aAAa,KAAK;;;;;;;;AAS3B,SAAgB,SACd,MACA,SACK;AAEL,QAAO,CAAC,GAAG,KAAK,CAAC,KAAK,QAAQ"}

package/out/shared/src/json-schema.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json-schema.js","names":[],"sources":["../../../../shared/src/json-schema.ts"],"sourcesContent":["import * as valita from '@badrap/valita';\nimport {skipAssertJSONValue} from './config.ts';\nimport type {ReadonlyJSONObject, ReadonlyJSONValue} from './json.ts';\nimport {isJSONObject, isJSONValue} from './json.ts';\nimport * as v from './valita.ts';\n\nconst path: (string | number)[] = [];\n\nexport const jsonSchema: valita.Type<ReadonlyJSONValue> = v\n  .unknown()\n  .chain(v => {\n    if (skipAssertJSONValue) {\n      return valita.ok(v as ReadonlyJSONValue);\n    }\n    const rv = isJSONValue(v, path)\n      ? valita.ok(v)\n      : valita.err({\n          message: `Not a JSON value`,\n          path: path.slice(),\n        });\n    path.length = 0;\n    return rv;\n  });\n\nexport const jsonObjectSchema: valita.Type<ReadonlyJSONObject> = v\n  .unknown()\n  .chain(v => {\n    if (skipAssertJSONValue) {\n      return valita.ok(v as ReadonlyJSONObject);\n    }\n    const rv = isJSONObject(v, path)\n      ? valita.ok(v)\n      : valita.err({\n          message: `Not a JSON object`,\n          path: path.slice(),\n        });\n    path.length = 0;\n    return rv;\n  });\n"],"mappings":";;;;;AAMA,IAAM,OAA4B,EAAE;AAEpC,IAAa,aAA6C,eACvD,SAAS,CACT,OAAM,MAAK;AACV,KAAI,OACF,QAAO,OAAO,GAAG,EAAuB;CAE1C,MAAM,KAAK,YAAY,GAAG,KAAK,GAC3B,OAAO,GAAG,EAAE,GACZ,OAAO,IAAI;EACT,SAAS;EACT,MAAM,KAAK,OAAO;EACnB,CAAC;AACN,MAAK,SAAS;AACd,QAAO;EACP;AAEJ,IAAa,mBAAoD,eAC9D,SAAS,CACT,OAAM,MAAK;AACV,KAAI,OACF,QAAO,OAAO,GAAG,EAAwB;CAE3C,MAAM,KAAK,aAAa,GAAG,KAAK,GAC5B,OAAO,GAAG,EAAE,GACZ,OAAO,IAAI;EACT,SAAS;EACT,MAAM,KAAK,OAAO;EACnB,CAAC;AACN,MAAK,SAAS;AACd,QAAO;EACP"}

package/out/shared/src/json.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"json.js","names":[],"sources":["../../../../shared/src/json.ts"],"sourcesContent":["import {assertObject, throwInvalidType} from './asserts.ts';\nimport {skipAssertJSONValue} from './config.ts';\nimport {hasOwn} from './has-own.ts';\n\n/** The values that can be represented in JSON */\nexport type JSONValue =\n  | null\n  | string\n  | boolean\n  | number\n  | Array<JSONValue>\n  | JSONObject;\n\n/**\n * A JSON object. This is a map from strings to JSON values or `undefined`. We\n * allow `undefined` values as a convenience... but beware that the `undefined`\n * values do not round trip to the server. For example:\n *\n * ```\n * // Time t1\n * await tx.set('a', {a: undefined});\n *\n * // time passes, in a new transaction\n * const v = await tx.get('a');\n * console.log(v); // either {a: undefined} or {}\n * ```\n */\nexport type JSONObject = {[key: string]: JSONValue | undefined};\n\n/** Like {@link JSONValue} but deeply readonly */\nexport type ReadonlyJSONValue =\n  | null\n  | string\n  | boolean\n  | number\n  | ReadonlyArray<ReadonlyJSONValue>\n  | ReadonlyJSONObject;\n\n/** Like {@link JSONObject} but deeply readonly */\nexport type ReadonlyJSONObject = {\n  readonly [key: string]: ReadonlyJSONValue | undefined;\n};\n\n/**\n * Checks deep equality of two JSON value with (almost) same semantics as\n * `JSON.stringify`. The only difference is that with `JSON.stringify` the\n * ordering of the properties in an object/map/dictionary matters. In\n * {@link deepEqual} the following two values are consider equal, even though the\n * strings JSON.stringify would produce is different:\n *\n * ```js\n * assert(deepEqual(t({a: 1, b: 2}, {b: 2, a: 1}))\n * ```\n */\nexport function deepEqual(\n  a: ReadonlyJSONValue | undefined,\n  b: ReadonlyJSONValue | undefined,\n): boolean {\n  if (a === b) {\n    return true;\n  }\n\n  if (typeof a !== typeof b) {\n    return false;\n  }\n\n  switch (typeof a) {\n    case 'boolean':\n    case 'number':\n    case 'string':\n      return false;\n  }\n\n  // a cannot be undefined here because either a and b are undefined or their\n  // types are different.\n  // oxlint-disable-next-line  @typescript-eslint/no-non-null-assertion\n  a = a!;\n\n  // 'object'\n  if (Array.isArray(a)) {\n    if (!Array.isArray(b)) {\n      return false;\n    }\n    if (a.length !== b.length) {\n      return false;\n    }\n    for (let i = 0; i < a.length; i++) {\n      if (!deepEqual(a[i], b[i])) {\n        return false;\n      }\n    }\n    return true;\n  }\n\n  if (a === null || b === null) {\n    return false;\n  }\n\n  if (Array.isArray(b)) {\n    return false;\n  }\n\n  // We know a and b are objects here but type inference is not smart enough.\n  a = a as ReadonlyJSONObject;\n  b = b as ReadonlyJSONObject;\n\n  // We use for-in loops instead of for of Object.keys() to make sure deepEquals\n  // does not allocate any objects.\n\n  let aSize = 0;\n  for (const key in a) {\n    if (hasOwn(a, key)) {\n      if (!deepEqual(a[key], b[key])) {\n        return false;\n      }\n      aSize++;\n    }\n  }\n\n  let bSize = 0;\n  for (const key in b) {\n    if (hasOwn(b, key)) {\n      bSize++;\n    }\n  }\n\n  return aSize === bSize;\n}\n\nexport function assertJSONValue(v: unknown): asserts v is JSONValue {\n  if (skipAssertJSONValue) {\n    return;\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      if (Array.isArray(v)) {\n        return assertJSONArray(v);\n      }\n      return assertObjectIsJSONObject(v as Record<string, unknown>);\n  }\n  throwInvalidType(v, 'JSON value');\n}\n\nexport function assertJSONObject(v: unknown): asserts v is JSONObject {\n  assertObject(v);\n  assertObjectIsJSONObject(v);\n}\n\nfunction assertObjectIsJSONObject(\n  v: Record<string, unknown>,\n): asserts v is JSONObject {\n  for (const k in v) {\n    if (hasOwn(v, k)) {\n      const value = v[k];\n      if (value !== undefined) {\n        assertJSONValue(value);\n      }\n    }\n  }\n}\n\nfunction assertJSONArray(v: unknown[]): asserts v is JSONValue[] {\n  for (const item of v) {\n    assertJSONValue(item);\n  }\n}\n\ninterface Path {\n  push(key: string | number): void;\n  pop(): void;\n}\n\n/**\n * Checks if a value is a JSON value. If there is a value that is not a JSON\n * value, the path parameter is updated to the path of the invalid value.\n */\nexport function isJSONValue(v: unknown, path: Path): v is JSONValue {\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      if (Array.isArray(v)) {\n        return isJSONArray(v, path);\n      }\n      return objectIsJSONObject(v as Record<string, unknown>, path);\n  }\n  return false;\n}\n\nexport function isJSONObject(v: unknown, path: Path): v is JSONObject {\n  if (typeof v !== 'object' || v === null) {\n    return false;\n  }\n  return objectIsJSONObject(v as Record<string, unknown>, path);\n}\n\nfunction objectIsJSONObject(\n  v: Record<string, unknown>,\n  path: Path,\n): v is JSONObject {\n  for (const k in v) {\n    if (hasOwn(v, k)) {\n      path.push(k);\n      const value = v[k];\n      if (value !== undefined && !isJSONValue(value, path)) {\n        return false;\n      }\n      path.pop();\n    }\n  }\n  return true;\n}\n\nfunction isJSONArray(v: unknown[], path: Path): v is JSONValue[] {\n  for (let i = 0; i < v.length; i++) {\n    path.push(i);\n    if (!isJSONValue(v[i], path)) {\n      return false;\n    }\n    path.pop();\n  }\n  return true;\n}\n\n/** Basic deep readonly type. It works for {@link JSONValue} types. */\nexport type DeepReadonly<T> = T extends\n  | null\n  | boolean\n  | string\n  | number\n  | undefined\n  ? T\n  : {readonly [K in keyof T]: DeepReadonly<T[K]>};\n"],"mappings":";;;;;;;;;;;;;;;AAsDA,SAAgB,UACd,GACA,GACS;AACT,KAAI,MAAM,EACR,QAAO;AAGT,KAAI,OAAO,MAAM,OAAO,EACtB,QAAO;AAGT,SAAQ,OAAO,GAAf;EACE,KAAK;EACL,KAAK;EACL,KAAK,SACH,QAAO;;AAMX,KAAI;AAGJ,KAAI,MAAM,QAAQ,EAAE,EAAE;AACpB,MAAI,CAAC,MAAM,QAAQ,EAAE,CACnB,QAAO;AAET,MAAI,EAAE,WAAW,EAAE,OACjB,QAAO;AAET,OAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,IAC5B,KAAI,CAAC,UAAU,EAAE,IAAI,EAAE,GAAG,CACxB,QAAO;AAGX,SAAO;;AAGT,KAAI,MAAM,QAAQ,MAAM,KACtB,QAAO;AAGT,KAAI,MAAM,QAAQ,EAAE,CAClB,QAAO;AAIT,KAAI;AACJ,KAAI;CAKJ,IAAI,QAAQ;AACZ,MAAK,MAAM,OAAO,EAChB,KAAI,OAAO,GAAG,IAAI,EAAE;AAClB,MAAI,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,CAC5B,QAAO;AAET;;CAIJ,IAAI,QAAQ;AACZ,MAAK,MAAM,OAAO,EAChB,KAAI,OAAO,GAAG,IAAI,CAChB;AAIJ,QAAO,UAAU;;AAGnB,SAAgB,gBAAgB,GAAoC;AAClE,KAAI,OACF;AAEF,SAAQ,OAAO,GAAf;EACE,KAAK;EACL,KAAK;EACL,KAAK,SACH;EACF,KAAK;AACH,OAAI,MAAM,KACR;AAEF,OAAI,MAAM,QAAQ,EAAE,CAClB,QAAO,gBAAgB,EAAE;AAE3B,UAAO,yBAAyB,EAA6B;;AAEjE,kBAAiB,GAAG,aAAa;;AAGnC,SAAgB,iBAAiB,GAAqC;AACpE,cAAa,EAAE;AACf,0BAAyB,EAAE;;AAG7B,SAAS,yBACP,GACyB;AACzB,MAAK,MAAM,KAAK,EACd,KAAI,OAAO,GAAG,EAAE,EAAE;EAChB,MAAM,QAAQ,EAAE;AAChB,MAAI,UAAU,KAAA,EACZ,iBAAgB,MAAM;;;AAM9B,SAAS,gBAAgB,GAAwC;AAC/D,MAAK,MAAM,QAAQ,EACjB,iBAAgB,KAAK;;;;;;AAazB,SAAgB,YAAY,GAAY,MAA4B;AAClE,SAAQ,OAAO,GAAf;EACE,KAAK;EACL,KAAK;EACL,KAAK,SACH,QAAO;EACT,KAAK;AACH,OAAI,MAAM,KACR,QAAO;AAET,OAAI,MAAM,QAAQ,EAAE,CAClB,QAAO,YAAY,GAAG,KAAK;AAE7B,UAAO,mBAAmB,GAA8B,KAAK;;AAEjE,QAAO;;AAGT,SAAgB,aAAa,GAAY,MAA6B;AACpE,KAAI,OAAO,MAAM,YAAY,MAAM,KACjC,QAAO;AAET,QAAO,mBAAmB,GAA8B,KAAK;;AAG/D,SAAS,mBACP,GACA,MACiB;AACjB,MAAK,MAAM,KAAK,EACd,KAAI,OAAO,GAAG,EAAE,EAAE;AAChB,OAAK,KAAK,EAAE;EACZ,MAAM,QAAQ,EAAE;AAChB,MAAI,UAAU,KAAA,KAAa,CAAC,YAAY,OAAO,KAAK,CAClD,QAAO;AAET,OAAK,KAAK;;AAGd,QAAO;;AAGT,SAAS,YAAY,GAAc,MAA8B;AAC/D,MAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAAK;AACjC,OAAK,KAAK,EAAE;AACZ,MAAI,CAAC,YAAY,EAAE,IAAI,KAAK,CAC1B,QAAO;AAET,OAAK,KAAK;;AAEZ,QAAO"}

package/out/shared/src/logging-test-utils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"logging-test-utils.js","names":[],"sources":["../../../../shared/src/logging-test-utils.ts"],"sourcesContent":["import {\n  type Context,\n  LogContext,\n  type LogLevel,\n  type LogSink,\n} from '@rocicorp/logger';\n\nexport class TestLogSink implements LogSink {\n  messages: [LogLevel, Context | undefined, unknown[]][] = [];\n  flushCallCount = 0;\n\n  log(level: LogLevel, context: Context | undefined, ...args: unknown[]): void {\n    this.messages.push([level, context, args]);\n  }\n\n  flush() {\n    this.flushCallCount++;\n    return Promise.resolve();\n  }\n}\n\nexport class SilentLogSink implements LogSink {\n  log(_l: LogLevel, _c: Context | undefined, ..._args: unknown[]): void {\n    return;\n  }\n}\n\nexport function createSilentLogContext() {\n  return new LogContext('error', undefined, new SilentLogSink());\n}\n"],"mappings":";;AAqBA,IAAa,gBAAb,MAA8C;CAC5C,IAAI,IAAc,IAAyB,GAAG,OAAwB;;AAKxE,SAAgB,yBAAyB;AACvC,QAAO,IAAI,WAAW,SAAS,KAAA,GAAW,IAAI,eAAe,CAAC"}

package/out/shared/src/logging.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"logging.js","names":[],"sources":["../../../../shared/src/logging.ts"],"sourcesContent":["import {pid} from 'node:process';\nimport {styleText} from 'node:util';\n/* oxlint-disable no-console */\nimport {\n  type Context,\n  LogContext,\n  type LogLevel,\n  type LogSink,\n} from '@rocicorp/logger';\nimport {stringify} from './bigint-json.ts';\n\nexport type LogConfig = {\n  level: LogLevel;\n  format: 'text' | 'json';\n};\n\nfunction style(color: 'gray' | 'yellow' | 'red', args: unknown[]) {\n  return styleText(color, args.join(' '));\n}\n\nconst COLOR_DEBUG = 'gray';\nconst COLOR_WARN = 'yellow';\nconst COLOR_ERROR = 'red';\n\n/**\n * Returns an object for writing colorized output to a provided console.\n * Note this should only be used when console is a TTY (i.e., Node).\n */\nexport const colorConsole = {\n  log: (...args: unknown[]) => {\n    console.log(...args);\n  },\n  debug: (...args: unknown[]) => {\n    console.debug(style(COLOR_DEBUG, args));\n  },\n  info: (...args: unknown[]) => {\n    console.info(...args);\n  },\n  warn: (...args: unknown[]) => {\n    console.warn(style(COLOR_WARN, args));\n  },\n  error: (...args: unknown[]) => {\n    console.error(style(COLOR_ERROR, args));\n  },\n};\n\nexport const consoleSink: LogSink = {\n  log(level, context, ...args) {\n    colorConsole[level](\n      toLocalIsoString(),\n      stringifyContext(context),\n      ...args.map(stringifyValue),\n    );\n  },\n};\n\nfunction toLocalIsoString(date = new Date()) {\n  const tzo = -date.getTimezoneOffset();\n  const sign = tzo >= 0 ? '+' : '-';\n  const pad = (n: number, len = 2) => String(Math.abs(n)).padStart(len, '0');\n\n  return (\n    date.getFullYear() +\n    '-' +\n    pad(date.getMonth() + 1) +\n    '-' +\n    pad(date.getDate()) +\n    'T' +\n    pad(date.getHours()) +\n    ':' +\n    pad(date.getMinutes()) +\n    ':' +\n    pad(date.getSeconds()) +\n    '.' +\n    pad(date.getMilliseconds(), 3) +\n    sign +\n    pad(tzo / 60) +\n    ':' +\n    pad(tzo % 60)\n  );\n}\n\nexport function getLogSink(config: LogConfig): LogSink {\n  return config.format === 'json' ? consoleJsonLogSink : consoleSink;\n}\n\nexport function createLogContext(\n  {log}: {log: LogConfig},\n  context = {},\n  sink = getLogSink(log),\n): LogContext {\n  const ctx = {pid, ...context};\n  const lc = new LogContext(log.level, ctx, sink);\n  // Emit a blank line to absorb random ANSI control code garbage that\n  // for some reason gets prepended to the first log line in CloudWatch.\n  lc.info?.('');\n  return lc;\n}\n\nconst consoleJsonLogSink: LogSink = {\n  log(level: LogLevel, context: Context | undefined, ...args: unknown[]): void {\n    // If the last arg is an object or an Error, combine those fields into the message.\n    const lastObj = errorOrObject(args.at(-1));\n    if (lastObj) {\n      args.pop();\n    }\n    const message = args.length\n      ? {\n          message: args.map(stringifyValue).join(' '),\n        }\n      : undefined;\n\n    console[level](\n      stringify({\n        level: level.toUpperCase(),\n        ...context,\n        ...lastObj,\n        ...message,\n      }),\n    );\n  },\n};\n\nexport function errorOrObject(v: unknown): object | undefined {\n  if (v instanceof Error) {\n    return toErrorLogObject(v);\n  }\n  if (v && typeof v === 'object') {\n    return v;\n  }\n  return undefined;\n}\n\nfunction toErrorLogObject(v: Error) {\n  return {\n    ...v, // some properties of Error subclasses may be enumerable\n    name: v.name,\n    errorMsg: v.message,\n    stack: v.stack,\n    ...('cause' in v ? {cause: errorOrObject(v.cause)} : null),\n  };\n}\n\nfunction stringifyContext(context: Context | undefined): unknown[] {\n  const args = [];\n  for (const [k, v] of Object.entries(context ?? {})) {\n    const arg = v === undefined ? k : `${k}=${v}`;\n    args.push(arg);\n  }\n  return args;\n}\n\nfunction stringifyValue(v: unknown) {\n  if (typeof v === 'string') {\n    return v;\n  }\n  if (v instanceof Error) {\n    return stringify(toErrorLogObject(v));\n  }\n  return stringify(v);\n}\n"],"mappings":"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"}

package/out/shared/src/must.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"must.js","names":[],"sources":["../../../../shared/src/must.ts"],"sourcesContent":["export function must<T>(v: T | undefined | null, msg?: string): T {\n  // oxlint-disable-next-line eqeqeq\n  if (v == null) {\n    throw new Error(msg ?? `Unexpected ${v} value`);\n  }\n  return v;\n}\n"],"mappings":";AAAA,SAAgB,KAAQ,GAAyB,KAAiB;AAEhE,KAAI,KAAK,KACP,OAAM,IAAI,MAAM,OAAO,cAAc,EAAE,QAAQ;AAEjD,QAAO"}

package/out/shared/src/navigator.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"navigator.js","names":[],"sources":["../../../../shared/src/navigator.ts"],"sourcesContent":["type Navigator = {\n  onLine: boolean;\n  userAgent: string;\n  // add more as needed\n};\n\nconst localNavigator: Navigator | undefined =\n  typeof navigator !== 'undefined' ? navigator : undefined;\n\nexport {localNavigator as navigator};\n"],"mappings":";AAMA,IAAM,iBACJ,OAAO,cAAc,cAAc,YAAY,KAAA"}

package/out/shared/src/object-traversal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"object-traversal.js","names":[],"sources":["../../../../shared/src/object-traversal.ts"],"sourcesContent":["type Split<\n  S extends string,\n  Sep extends string,\n> = S extends `${infer Head}${Sep}${infer Tail}`\n  ? [Head, ...Split<Tail, Sep>]\n  : S extends ''\n    ? []\n    : [S];\n\ntype GetAtPath<T, Parts extends readonly string[]> = Parts extends readonly [\n  infer Head extends string,\n  ...infer Tail extends readonly string[],\n]\n  ? Head extends keyof T\n    ? GetAtPath<T[Head], Tail>\n    : undefined\n  : T;\n\ntype ValueAtPath<Path extends string, T, Sep extends string> = GetAtPath<\n  T,\n  Split<Path, Sep>\n>;\n\nexport function getValueAtPath(obj: object, path: string, sep: RegExp): unknown;\nexport function getValueAtPath<\n  const Path extends string,\n  const T extends object,\n  const Sep extends string,\n>(obj: T, path: Path, sep: Sep): ValueAtPath<Path, T, Sep>;\nexport function getValueAtPath(\n  obj: object,\n  path: string,\n  sep: string | RegExp,\n): unknown {\n  const parts = path.split(sep);\n  let current: unknown = obj;\n  for (const part of parts) {\n    if (current && typeof current === 'object' && part in current) {\n      current = (current as Record<string, unknown>)[part];\n    } else {\n      return undefined;\n    }\n  }\n  return current;\n}\n\n/**\n * Recursively iterates over all leaf values in a nested object tree.\n * A value is considered a leaf if `isLeaf(value)` returns true,\n * or if it's not a plain object.\n *\n * @param obj - The object to iterate over\n * @param isLeaf - A function that returns true if a value should be yielded as a leaf\n */\nexport function* iterateLeaves<T>(\n  obj: object,\n  isLeaf: (value: unknown) => value is T,\n): Iterable<T> {\n  for (const key of Object.keys(obj)) {\n    const value = (obj as Record<string, unknown>)[key];\n    if (isLeaf(value)) {\n      yield value;\n    } else if (value && typeof value === 'object') {\n      yield* iterateLeaves(value, isLeaf);\n    }\n  }\n}\n"],"mappings":";AA6BA,SAAgB,eACd,KACA,MACA,KACS;CACT,MAAM,QAAQ,KAAK,MAAM,IAAI;CAC7B,IAAI,UAAmB;AACvB,MAAK,MAAM,QAAQ,MACjB,KAAI,WAAW,OAAO,YAAY,YAAY,QAAQ,QACpD,WAAW,QAAoC;KAE/C;AAGJ,QAAO;;;;;;;;;;AAWT,UAAiB,cACf,KACA,QACa;AACb,MAAK,MAAM,OAAO,OAAO,KAAK,IAAI,EAAE;EAClC,MAAM,QAAS,IAAgC;AAC/C,MAAI,OAAO,MAAM,CACf,OAAM;WACG,SAAS,OAAO,UAAU,SACnC,QAAO,cAAc,OAAO,OAAO"}

package/out/shared/src/objects.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"objects.js","names":[],"sources":["../../../../shared/src/objects.ts"],"sourcesContent":["export function mapValues<T extends Record<string, unknown>, U>(\n  input: T,\n  mapper: (value: T[keyof T]) => U,\n): {[K in keyof T]: U} {\n  return mapEntries(input, (k, v) => [k, mapper(v as T[keyof T])]) as {\n    [K in keyof T]: U;\n  };\n}\n\nexport function mapEntries<T, U>(\n  input: Record<string, T>,\n  mapper: (key: string, val: T) => [key: string, val: U],\n): Record<string, U> {\n  // Direct assignment is faster than Object.fromEntries()\n  // https://github.com/rocicorp/mono/pull/3927#issuecomment-2706059475\n  const output: Record<string, U> = {};\n\n  // In chrome Object.entries is faster than for-in (13x) or Object.keys (15x)\n  // https://gist.github.com/arv/1b4e113724f6a14e2d4742bcc760d1fa\n  for (const entry of Object.entries(input)) {\n    const mapped = mapper(entry[0], entry[1]);\n    output[mapped[0]] = mapped[1];\n  }\n  return output;\n}\n\nexport function mapAllEntries<T, U>(\n  input: Record<string, T>,\n  mapper: (entries: [key: string, val: T][]) => [key: string, val: U][],\n): Record<string, U> {\n  // Direct assignment is faster than Object.fromEntries()\n  // https://github.com/rocicorp/mono/pull/3927#issuecomment-2706059475\n  const output: Record<string, U> = {};\n  for (const mapped of mapper(Object.entries(input))) {\n    output[mapped[0]] = mapped[1];\n  }\n  return output;\n}\n"],"mappings":";AAAA,SAAgB,UACd,OACA,QACqB;AACrB,QAAO,WAAW,QAAQ,GAAG,MAAM,CAAC,GAAG,OAAO,EAAgB,CAAC,CAAC;;AAKlE,SAAgB,WACd,OACA,QACmB;CAGnB,MAAM,SAA4B,EAAE;AAIpC,MAAK,MAAM,SAAS,OAAO,QAAQ,MAAM,EAAE;EACzC,MAAM,SAAS,OAAO,MAAM,IAAI,MAAM,GAAG;AACzC,SAAO,OAAO,MAAM,OAAO;;AAE7B,QAAO;;AAGT,SAAgB,cACd,OACA,QACmB;CAGnB,MAAM,SAA4B,EAAE;AACpC,MAAK,MAAM,UAAU,OAAO,OAAO,QAAQ,MAAM,CAAC,CAChD,QAAO,OAAO,MAAM,OAAO;AAE7B,QAAO"}

package/out/shared/src/options.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"options.js","names":[],"sources":["../../../../shared/src/options.ts"],"sourcesContent":["import {stripVTControlCharacters as stripAnsi} from 'node:util';\nimport type {OptionalLogger} from '@rocicorp/logger';\nimport {template} from 'chalk-template';\nimport type {OptionDefinition} from 'command-line-args';\nimport commandLineArgs from 'command-line-args';\nimport commandLineUsage, {type Section} from 'command-line-usage';\nimport {createDefu} from 'defu';\nimport {toKebabCase, toSnakeCase} from 'kasi';\nimport {assert} from './asserts.ts';\nimport {must} from './must.ts';\nimport type {\n  Config,\n  Group,\n  Option,\n  Options,\n  WrappedOptionType,\n} from './options-types.ts';\nimport * as v from './valita.ts';\n\nexport type {Config, Group, Option, Options, WrappedOptionType};\n\ntype Primitive = number | string | boolean;\ntype Value = Primitive | Array<Primitive>;\n\ntype RequiredOptionType =\n  | v.Type<string>\n  | v.Type<number>\n  | v.Type<boolean>\n  | v.Type<string[]>\n  | v.Type<number[]>\n  | v.Type<boolean[]>;\n\ntype OptionalOptionType =\n  | v.Optional<string>\n  | v.Optional<number>\n  | v.Optional<boolean>\n  | v.Optional<string[]>\n  | v.Optional<number[]>\n  | v.Optional<boolean[]>;\n\ntype OptionType = RequiredOptionType | OptionalOptionType;\n\n/**\n * Creates a defu instance that overrides arrays instead of merging them.\n */\nconst defu = createDefu((obj, key, value) => {\n  if (!Array.isArray(value)) return;\n\n  obj[key] = value;\n  return true;\n});\n\n/**\n * Converts an Options instance into its corresponding {@link Config} schema.\n */\nfunction configSchema<T extends Options>(\n  options: T,\n  envNamePrefix: string,\n): v.Type<Config<T>> {\n  function makeObjectType(options: Options | Group, group?: string) {\n    return v.object(\n      Object.fromEntries(\n        Object.entries(options).map(\n          ([name, value]): [string, OptionType | v.Type] => {\n            const addErrorMessage = (t: OptionType) => {\n              const {required} = getRequiredOrDefault(t);\n              if (required) {\n                // Adds an error message for required options that includes the\n                // actual name of the option.\n                const optionName = toSnakeCase(\n                  `${envNamePrefix}${group ? group + '_' : ''}${name}`,\n                ).toUpperCase();\n                return (t as v.Type<string>)\n                  .optional()\n                  .assert(\n                    val => val !== undefined,\n                    `Missing required option ${optionName}`,\n                  );\n              }\n              return t;\n            };\n            // OptionType\n            if (v.instanceOfAbstractType(value)) {\n              return [name, addErrorMessage(value)];\n            }\n            // WrappedOptionType\n            const {type} = value;\n            if (v.instanceOfAbstractType(type)) {\n              return [name, addErrorMessage(type)];\n            }\n            // OptionGroup\n            return [name, makeObjectType(value as Group, name)];\n          },\n        ),\n      ),\n    );\n  }\n  return makeObjectType(options) as v.Type<Config<T>>;\n}\n\n/**\n * Converts an Options instance into an \"env schema\", which is an object with\n * ENV names as its keys, mapped to optional or required string values\n * (corresponding to the optionality of the corresponding options).\n *\n * This is used as a format for encoding options for a multi-tenant version\n * of an app, with an envSchema for each tenant.\n */\nexport function envSchema<T extends Options>(options: T, envNamePrefix = '') {\n  const fields: [string, v.Type<string> | v.Optional<string>][] = [];\n\n  function addField(name: string, type: OptionType, group?: string) {\n    const flag = group ? `${group}_${name}` : name;\n    const env = toSnakeCase(`${envNamePrefix}${flag}`).toUpperCase();\n\n    const {required} = getRequiredOrDefault(type);\n    fields.push([env, required ? v.string() : v.string().optional()]);\n  }\n\n  function addFields(o: Options | Group, group?: string) {\n    Object.entries(o).forEach(([name, value]) => {\n      // OptionType\n      if (v.instanceOfAbstractType(value)) {\n        addField(name, value, group);\n        return;\n      }\n      // WrappedOptionType\n      const {type} = value;\n      if (v.instanceOfAbstractType(type)) {\n        addField(name, type, group);\n        return;\n      }\n      // OptionGroup\n      addFields(value as Group, name);\n    });\n  }\n\n  addFields(options);\n\n  return v.object(Object.fromEntries(fields));\n}\n\n// type TerminalType is not exported from badrap/valita\ntype TerminalType = Parameters<\n  Parameters<v.Type<unknown>['toTerminals']>[0]\n>[0];\n\nfunction getRequiredOrDefault(type: OptionType) {\n  const defaultResult = v.testOptional<Value>(undefined, type);\n  return {\n    required: !defaultResult.ok,\n    defaultValue: defaultResult.ok ? defaultResult.value : undefined,\n  };\n}\n\nexport type ParseOptions = {\n  /** Defaults to process.argv.slice(2) */\n  argv?: string[];\n\n  envNamePrefix?: string;\n\n  description?: {header: string; content: string}[];\n\n  /** Defaults to `false` */\n  allowUnknown?: boolean;\n\n  /** Defaults to `false` */\n  allowPartial?: boolean;\n\n  /** Defaults to `process.env`. */\n  env?: NodeJS.ProcessEnv;\n\n  /** Defaults to `true`. */\n  emitDeprecationWarnings?: boolean;\n\n  /** Defaults to `true`. When false, excludes default values from both config and env return values. */\n  includeDefaults?: boolean;\n\n  /** Defaults to `console` */\n  logger?: OptionalLogger;\n\n  /** Defaults to `process.exit` */\n  exit?: (code?: number | string | null) => never;\n};\n\nexport function parseOptions<T extends Options>(\n  appOptions: T,\n  opts: ParseOptions = {},\n): Config<T> {\n  return parseOptionsAdvanced(appOptions, opts).config;\n}\n\nexport function parseOptionsAdvanced<T extends Options>(\n  appOptions: T,\n  opts: ParseOptions = {},\n): {config: Config<T>; env: Record<string, string>; unknown?: string[]} {\n  const {\n    argv = process.argv.slice(2),\n    envNamePrefix = '',\n    description = [],\n    allowUnknown = false,\n    allowPartial = false,\n    env: processEnv = process.env,\n    emitDeprecationWarnings = true,\n    includeDefaults = true,\n    logger = console,\n    exit = process.exit,\n  } = opts;\n  // The main logic for converting a valita Type spec to an Option (i.e. flag) spec.\n  function addOption(field: string, option: WrappedOptionType, group?: string) {\n    const {type, desc = [], deprecated, alias, hidden} = option;\n\n    // The group name is prepended to the flag name.\n    const flag = group ? toKebabCase(`${group}-${field}`) : toKebabCase(field);\n\n    const {required, defaultValue} = getRequiredOrDefault(type);\n    let multiple = type.name === 'array';\n    const literals = new Set<string>();\n    const terminalTypes = new Set<string>();\n\n    type.toTerminals(getTerminalTypes);\n\n    function getTerminalTypes(t: TerminalType) {\n      switch (t.name) {\n        case 'undefined':\n        case 'optional':\n          break;\n        case 'array': {\n          multiple = true;\n          t.prefix.forEach(t => t.toTerminals(getTerminalTypes));\n          t.rest?.toTerminals(getTerminalTypes);\n          t.suffix.forEach(t => t.toTerminals(getTerminalTypes));\n          break;\n        }\n        case 'literal':\n          literals.add(String(t.value));\n          terminalTypes.add(typeof t.value);\n          break;\n        default:\n          terminalTypes.add(t.name);\n          break;\n      }\n    }\n    const env = toSnakeCase(`${envNamePrefix}${flag}`).toUpperCase();\n    if (terminalTypes.size > 1) {\n      throw new TypeError(`${env} has mixed types ${[...terminalTypes]}`);\n    }\n    assert(terminalTypes.size === 1, 'Expected exactly one terminal type');\n    const terminalType = [...terminalTypes][0];\n\n    if (processEnv[env]) {\n      if (multiple) {\n        // Technically not water-tight; assumes values for the string[] flag don't contain commas.\n        envArgv.push(`--${flag}`, ...processEnv[env].split(','));\n      } else {\n        envArgv.push(`--${flag}`, processEnv[env]);\n      }\n    }\n    names.set(flag, {field, env});\n\n    const spec = [\n      (required\n        ? '{italic required}'\n        : defaultValue !== undefined\n          ? `default: ${JSON.stringify(defaultValue)}`\n          : 'optional') + '\\n',\n    ];\n    if (desc) {\n      spec.push(...desc);\n    }\n\n    const typeLabel = [\n      literals.size\n        ? String(Array.from(literals, l => `{underline ${l}}`))\n        : multiple\n          ? `{underline ${terminalType}[]}`\n          : `{underline ${terminalType}}`,\n      `  ${env} env`,\n    ];\n\n    const opt = {\n      name: flag,\n      alias,\n      type: valueParser(\n        env,\n        terminalType,\n        logger,\n        emitDeprecationWarnings ? deprecated : undefined,\n      ),\n      multiple,\n      group,\n      description: spec.join('\\n') + '\\n',\n      typeLabel: typeLabel.join('\\n') + '\\n',\n      hidden: hidden === undefined ? deprecated !== undefined : hidden,\n    };\n    optsWithoutDefaults.push(opt);\n    optsWithDefaults.push({...opt, defaultValue});\n  }\n\n  const names = new Map<string, {field: string; env: string}>();\n  const optsWithDefaults: DescribedOptionDefinition[] = [];\n  const optsWithoutDefaults: DescribedOptionDefinition[] = [];\n  const envArgv: string[] = [];\n\n  try {\n    for (const [name, val] of Object.entries(appOptions)) {\n      const {type} = val as {type: unknown};\n      if (v.instanceOfAbstractType(val)) {\n        addOption(name, {type: val});\n      } else if (v.instanceOfAbstractType(type)) {\n        addOption(name, val as WrappedOptionType);\n      } else {\n        const group = name;\n        for (const [name, option] of Object.entries(val as Group)) {\n          const wrapped = v.instanceOfAbstractType(option)\n            ? {type: option}\n            : option;\n          addOption(name, wrapped, group);\n        }\n      }\n    }\n\n    const [defaults, env1, unknown] = parseArgs(optsWithDefaults, argv, names);\n    const [fromEnv, env2] = parseArgs(optsWithoutDefaults, envArgv, names);\n    const [withoutDefaults, env3] = parseArgs(optsWithoutDefaults, argv, names);\n\n    switch (unknown?.[0]) {\n      case undefined:\n        break;\n      case '--help':\n      case '-h':\n        showUsage(optsWithDefaults, description, logger);\n        exit(0);\n        break;\n      default:\n        if (!allowUnknown) {\n          logger.error?.('Invalid arguments:', unknown);\n          showUsage(optsWithDefaults, description, logger);\n          exit(0);\n        }\n        break;\n    }\n\n    const parsedArgs = includeDefaults\n      ? defu(withoutDefaults, fromEnv, defaults)\n      : defu(withoutDefaults, fromEnv);\n    const env = includeDefaults\n      ? {...env1, ...env2, ...env3}\n      : {...env2, ...env3};\n\n    let schema = configSchema(appOptions, envNamePrefix);\n    if (allowPartial || !includeDefaults) {\n      // TODO: Type configSchema() to return a v.ObjectType<...>\n      schema = v.deepPartial(schema as v.ObjectType) as v.Type<Config<T>>;\n    }\n    return {\n      config: v.parse(parsedArgs, schema),\n      env,\n      ...(unknown ? {unknown} : {}),\n    };\n  } catch (e) {\n    logger.error?.(String(e));\n    showUsage(optsWithDefaults, description, logger);\n    throw e;\n  }\n}\n\nfunction valueParser(\n  optionName: string,\n  typeName: string,\n  logger: OptionalLogger,\n  deprecated: string[] | undefined,\n) {\n  return (input: string) => {\n    if (deprecated) {\n      logger.warn?.(\n        template(\n          `\\n${optionName} is deprecated:\\n` + deprecated.join('\\n') + '\\n',\n        ),\n      );\n    }\n    switch (typeName) {\n      case 'string':\n        return input;\n      case 'boolean':\n        return parseBoolean(optionName, input);\n      case 'number': {\n        const val = Number(input);\n        if (Number.isNaN(val)) {\n          throw new TypeError(`Invalid input for ${optionName}: \"${input}\"`);\n        }\n        return val;\n      }\n      default:\n        // Should be impossible given the constraints of `Option`\n        throw new TypeError(\n          `${optionName} option has unsupported type ${typeName}`,\n        );\n    }\n  };\n}\n\nfunction parseArgs(\n  optionDefs: DescribedOptionDefinition[],\n  argv: string[],\n  names: Map<string, {field: string; env: string}>,\n) {\n  function normalizeFlagValue(value: unknown) {\n    // A --flag without value is parsed by commandLineArgs() to `null`,\n    // but this is a common convention to set a boolean flag to true.\n    return value === null ? true : value;\n  }\n\n  const {\n    _all,\n    _none: ungrouped,\n    _unknown: unknown,\n    ...config\n  } = commandLineArgs(optionDefs, {\n    argv,\n    partial: true,\n  });\n\n  // oxlint-disable-next-line @typescript-eslint/no-explicit-any\n  const result: Record<string, any> = {};\n  const envObj: Record<string, string> = {};\n\n  function addFlag(flagName: string, value: unknown, group?: string) {\n    const {field, env} = must(names.get(flagName));\n    const normalized = normalizeFlagValue(value);\n    if (group) {\n      result[group][field] = normalized;\n    } else {\n      result[field] = normalized;\n    }\n    envObj[env] = String(normalized);\n  }\n\n  for (const [flagName, value] of Object.entries(ungrouped ?? {})) {\n    addFlag(flagName, value);\n  }\n\n  // Then handle (potentially) grouped flags\n  for (const [name, value] of Object.entries(config)) {\n    if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n      addFlag(name, value); // Flag, not a group\n    } else {\n      const group = name;\n      result[group] = {};\n      for (const [flagName, flagValue] of Object.entries(value)) {\n        addFlag(flagName, flagValue, group);\n      }\n    }\n  }\n\n  return [result, envObj, unknown] as const;\n}\n\nexport function flagToEnv(prefix: string, flag: string): string {\n  return toSnakeCase(prefix + flag).toUpperCase();\n}\n\nexport function parseBoolean(optionName: string, input: string) {\n  const bool = input.toLowerCase();\n  if (['true', '1'].includes(bool)) {\n    return true;\n  } else if (['false', '0'].includes(bool)) {\n    return false;\n  }\n  throw new TypeError(`Invalid input for ${optionName}: \"${input}\"`);\n}\n\nfunction showUsage(\n  optionList: DescribedOptionDefinition[],\n  description: {header: string; content: string}[] = [],\n  logger: OptionalLogger = console,\n) {\n  const hide: string[] = [];\n  let leftWidth = 35;\n  let rightWidth = 70;\n  optionList.forEach(({name, typeLabel, description, hidden}) => {\n    if (hidden) {\n      hide.push(name);\n    }\n    const text = template(`${name} ${typeLabel ?? ''}`);\n    const lines = stripAnsi(text).split('\\n');\n    for (const l of lines) {\n      leftWidth = Math.max(leftWidth, l.length + 2);\n    }\n    const desc = stripAnsi(template(description ?? '')).split('\\n');\n    for (const l of desc) {\n      rightWidth = Math.max(rightWidth, l.length + 2);\n    }\n  });\n\n  const sections: Section[] = [\n    {\n      optionList,\n      reverseNameOrder: true, // Display --flag-name before -alias\n      hide,\n      tableOptions: {\n        columns: [\n          {name: 'option', width: leftWidth},\n          {name: 'description', width: rightWidth},\n        ],\n        noTrim: true,\n      },\n    },\n  ];\n\n  if (description) {\n    sections.unshift(...description);\n  }\n\n  logger.info?.(commandLineUsage(sections));\n}\n\ntype DescribedOptionDefinition = OptionDefinition & {\n  // Additional fields recognized by command-line-usage\n  description?: string;\n  typeLabel?: string | undefined;\n  hidden?: boolean | undefined;\n};\n"],"mappings":"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"}

package/out/shared/src/parse-big-int.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-big-int.js","names":[],"sources":["../../../../shared/src/parse-big-int.ts"],"sourcesContent":["// Until there's BigInt.fromString(val, radix) ... https://github.com/tc39/proposal-number-fromstring\nexport function parseBigInt(val: string, radix: number): bigint {\n  const base = BigInt(radix);\n  let result = 0n;\n  for (let i = 0; i < val.length; i++) {\n    result *= base;\n    result += BigInt(parseInt(val[i], radix));\n  }\n  return result;\n}\n"],"mappings":";AACA,SAAgB,YAAY,KAAa,OAAuB;CAC9D,MAAM,OAAO,OAAO,MAAM;CAC1B,IAAI,SAAS;AACb,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,QAAQ,KAAK;AACnC,YAAU;AACV,YAAU,OAAO,SAAS,IAAI,IAAI,MAAM,CAAC;;AAE3C,QAAO"}

package/out/shared/src/promise-race.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"promise-race.js","names":[],"sources":["../../../../shared/src/promise-race.ts"],"sourcesContent":["type PromiseRaceResult<T extends Record<string, PromiseLike<unknown>>> = {\n  [K in Extract<keyof T, string>]: {\n    key: K;\n    status: 'fulfilled';\n    result: Awaited<T[K]>;\n  };\n}[Extract<keyof T, string>];\n\nconst NO_PROMISES_MESSAGE = 'No promises to race';\n\nconst wrapPromise = <K extends string, V>(\n  key: K,\n  promise: PromiseLike<V>,\n): Promise<{key: K; status: 'fulfilled'; result: V}> =>\n  Promise.resolve(promise).then(result => ({\n    key,\n    status: 'fulfilled' as const,\n    result,\n  }));\n\n/**\n * Race a record of promises and resolve with the first resolved entry.\n *\n * @param promises Record of promises to race.\n * @returns Promise resolving to a discriminated union of key/result pairs.\n * @throws An error if the record is empty or if a promise is rejected.\n */\nexport async function promiseRace<\n  T extends Record<string, PromiseLike<unknown>>,\n>(promises: T): Promise<PromiseRaceResult<T> & {}> {\n  const keys = Object.keys(promises) as Array<Extract<keyof T, string>>;\n\n  if (keys.length === 0) {\n    throw new Error(NO_PROMISES_MESSAGE);\n  }\n\n  const wrapped = keys.map(key =>\n    wrapPromise(key, promises[key] as PromiseLike<Awaited<T[typeof key]>>),\n  );\n\n  return await Promise.race(wrapped);\n}\n"],"mappings":";AAQA,IAAM,sBAAsB;AAE5B,IAAM,eACJ,KACA,YAEA,QAAQ,QAAQ,QAAQ,CAAC,MAAK,YAAW;CACvC;CACA,QAAQ;CACR;CACD,EAAE;;;;;;;;AASL,eAAsB,YAEpB,UAAiD;CACjD,MAAM,OAAO,OAAO,KAAK,SAAS;AAElC,KAAI,KAAK,WAAW,EAClB,OAAM,IAAI,MAAM,oBAAoB;CAGtC,MAAM,UAAU,KAAK,KAAI,QACvB,YAAY,KAAK,SAAS,KAA4C,CACvE;AAED,QAAO,MAAM,QAAQ,KAAK,QAAQ"}

package/out/shared/src/queue.js

@@ -1,126 +0,0 @@
-import { assert } from "./asserts.js";
-import { resolver } from "@rocicorp/resolver";
-//#region ../shared/src/queue.ts
-/**
-* A Queue allows the consumers to await (possibly future) values,
-* and producers to await the consumption of their values.
-*/
-var Queue = class {
-	#consumers = [];
-	#produced = [];
-	enqueue(value) {
-		const consumer = this.#consumers.shift();
-		if (consumer) {
-			consumer.resolver.resolve(value);
-			clearTimeout(consumer.timeoutID);
-			return;
-		}
-		this.#produced.push({ value });
-	}
-	enqueueRejection(reason) {
-		const consumer = this.#consumers.shift();
-		if (consumer) {
-			consumer.resolver.reject(reason);
-			clearTimeout(consumer.timeoutID);
-			return;
-		}
-		this.#produced.push({ rejection: reason });
-	}
-	/**
-	* Deletes all unconsumed entries matching the specified `value` based on identity equality.
-	* The consumed callback(s) are resolved as if the values were dequeued.
-	*
-	* Note: deletion of `undefined` values is not supported. This method will assert
-	* if `value` is undefined.
-	*
-	* @returns The number of entries deleted.
-	*/
-	delete(value) {
-		assert(value !== void 0, "Queue delete value must not be undefined");
-		let count = 0;
-		for (let i = this.#produced.length - 1; i >= 0; i--) if (this.#produced[i].value === value) {
-			this.#produced.splice(i, 1);
-			count++;
-		}
-		return count;
-	}
-	/**
-	* @param timeoutValue An optional value to resolve if `timeoutMs` is reached.
-	* @param timeoutMs The milliseconds after which the `timeoutValue` is resolved
-	*                  if nothing is produced for the consumer.
-	* @returns A Promise that resolves to the next enqueued value.
-	*/
-	dequeue(timeoutValue, timeoutMs = 0) {
-		const produced = this.#produced.shift();
-		if (produced) return produced.value ?? Promise.reject(produced.rejection);
-		const r = resolver();
-		const timeoutID = timeoutValue === void 0 ? void 0 : setTimeout(() => {
-			const i = this.#consumers.findIndex((c) => c.resolver === r);
-			if (i >= 0) {
-				const [consumer] = this.#consumers.splice(i, 1);
-				consumer.resolver.resolve(timeoutValue);
-			}
-		}, timeoutMs);
-		this.#consumers.push({
-			resolver: r,
-			timeoutID
-		});
-		return r.promise;
-	}
-	/**
-	* Drains the entire queue.
-	*
-	* Usage example:
-	* ```ts
-	* // A consumer that, when awoken, drains
-	* // all entries in the queue in order to
-	* // process them in a batch.
-	* for (;;) {
-	*   const value = await queue.dequeue();
-	*   const rest = queue.drain();
-	* }
-	* ```
-	*/
-	drain() {
-		const ret = [];
-		for (const p of this.#produced) ret.push(p.value);
-		this.#produced.length = 0;
-		return ret;
-	}
-	/**
-	* @returns The instantaneous number of outstanding values waiting to be
-	*          dequeued. Note that if a value was enqueued while a consumer
-	*          was waiting (with `await dequeue()`), the value is immediately
-	*          handed to the consumer and the Queue's size remains 0.
-	*/
-	size() {
-		return this.#produced.length;
-	}
-	asAsyncIterable(cleanup = NOOP) {
-		return { [Symbol.asyncIterator]: () => this.asAsyncIterator(cleanup) };
-	}
-	asAsyncIterator(cleanup = NOOP) {
-		return {
-			next: async () => {
-				try {
-					return { value: await this.dequeue() };
-				} catch (e) {
-					cleanup();
-					throw e;
-				}
-			},
-			return: (value) => {
-				cleanup();
-				return Promise.resolve({
-					value,
-					done: true
-				});
-			}
-		};
-	}
-};
-var NOOP = () => {};
-//#endregion
-export { Queue };
-
-//# sourceMappingURL=queue.js.map

package/out/shared/src/queue.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue.js","names":["#consumers","#produced"],"sources":["../../../../shared/src/queue.ts"],"sourcesContent":["import {resolver, type Resolver} from '@rocicorp/resolver';\nimport {assert} from './asserts.ts';\n\n/**\n * A Queue allows the consumers to await (possibly future) values,\n * and producers to await the consumption of their values.\n */\nexport class Queue<T> {\n  // Consumers waiting for entries to be produced.\n  readonly #consumers: Consumer<T>[] = [];\n  // Produced entries waiting to be consumed.\n  readonly #produced: Produced<T>[] = [];\n\n  enqueue(value: T): void {\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolver.resolve(value);\n      clearTimeout(consumer.timeoutID);\n      return;\n    }\n    this.#produced.push({value});\n  }\n\n  enqueueRejection(reason?: unknown): void {\n    const consumer = this.#consumers.shift();\n    if (consumer) {\n      consumer.resolver.reject(reason);\n      clearTimeout(consumer.timeoutID);\n      return;\n    }\n    this.#produced.push({rejection: reason});\n  }\n\n  /**\n   * Deletes all unconsumed entries matching the specified `value` based on identity equality.\n   * The consumed callback(s) are resolved as if the values were dequeued.\n   *\n   * Note: deletion of `undefined` values is not supported. This method will assert\n   * if `value` is undefined.\n   *\n   * @returns The number of entries deleted.\n   */\n  delete(value: T): number {\n    assert(value !== undefined, 'Queue delete value must not be undefined');\n\n    let count = 0;\n    for (let i = this.#produced.length - 1; i >= 0; i--) {\n      const p = this.#produced[i];\n      if (p.value === value) {\n        this.#produced.splice(i, 1);\n        count++;\n      }\n    }\n    return count;\n  }\n\n  /**\n   * @param timeoutValue An optional value to resolve if `timeoutMs` is reached.\n   * @param timeoutMs The milliseconds after which the `timeoutValue` is resolved\n   *                  if nothing is produced for the consumer.\n   * @returns A Promise that resolves to the next enqueued value.\n   */\n  dequeue(timeoutValue?: T, timeoutMs: number = 0): Promise<T> | T {\n    const produced = this.#produced.shift();\n    if (produced) {\n      return produced.value ?? Promise.reject(produced.rejection);\n    }\n    const r = resolver<T>();\n    const timeoutID =\n      timeoutValue === undefined\n        ? undefined\n        : setTimeout(() => {\n            const i = this.#consumers.findIndex(c => c.resolver === r);\n            if (i >= 0) {\n              const [consumer] = this.#consumers.splice(i, 1);\n              consumer.resolver.resolve(timeoutValue);\n            }\n          }, timeoutMs);\n    this.#consumers.push({resolver: r, timeoutID});\n    return r.promise;\n  }\n\n  /**\n   * Drains the entire queue.\n   *\n   * Usage example:\n   * ```ts\n   * // A consumer that, when awoken, drains\n   * // all entries in the queue in order to\n   * // process them in a batch.\n   * for (;;) {\n   *   const value = await queue.dequeue();\n   *   const rest = queue.drain();\n   * }\n   * ```\n   */\n  drain(): (T | undefined)[] {\n    const ret: (T | undefined)[] = [];\n    for (const p of this.#produced) {\n      ret.push(p.value);\n    }\n    this.#produced.length = 0;\n\n    return ret;\n  }\n\n  /**\n   * @returns The instantaneous number of outstanding values waiting to be\n   *          dequeued. Note that if a value was enqueued while a consumer\n   *          was waiting (with `await dequeue()`), the value is immediately\n   *          handed to the consumer and the Queue's size remains 0.\n   */\n  size(): number {\n    return this.#produced.length;\n  }\n\n  asAsyncIterable(cleanup = NOOP): AsyncIterable<T> {\n    return {[Symbol.asyncIterator]: () => this.asAsyncIterator(cleanup)};\n  }\n\n  asAsyncIterator(cleanup = NOOP): AsyncIterator<T> {\n    return {\n      next: async () => {\n        try {\n          const value = await this.dequeue();\n          return {value};\n        } catch (e) {\n          cleanup();\n          throw e;\n        }\n      },\n      return: value => {\n        cleanup();\n        return Promise.resolve({value, done: true});\n      },\n    };\n  }\n}\n\nconst NOOP = () => {};\n\ntype Consumer<T> = {\n  resolver: Resolver<T>;\n  timeoutID: ReturnType<typeof setTimeout> | undefined;\n};\n\ntype Produced<T> =\n  | {value: T; rejection?: undefined}\n  | {value?: undefined; rejection: unknown};\n"],"mappings":";;;;;;;AAOA,IAAa,QAAb,MAAsB;CAEpB,aAAqC,EAAE;CAEvC,YAAoC,EAAE;CAEtC,QAAQ,OAAgB;EACtB,MAAM,WAAW,MAAA,UAAgB,OAAO;AACxC,MAAI,UAAU;AACZ,YAAS,SAAS,QAAQ,MAAM;AAChC,gBAAa,SAAS,UAAU;AAChC;;AAEF,QAAA,SAAe,KAAK,EAAC,OAAM,CAAC;;CAG9B,iBAAiB,QAAwB;EACvC,MAAM,WAAW,MAAA,UAAgB,OAAO;AACxC,MAAI,UAAU;AACZ,YAAS,SAAS,OAAO,OAAO;AAChC,gBAAa,SAAS,UAAU;AAChC;;AAEF,QAAA,SAAe,KAAK,EAAC,WAAW,QAAO,CAAC;;;;;;;;;;;CAY1C,OAAO,OAAkB;AACvB,SAAO,UAAU,KAAA,GAAW,2CAA2C;EAEvE,IAAI,QAAQ;AACZ,OAAK,IAAI,IAAI,MAAA,SAAe,SAAS,GAAG,KAAK,GAAG,IAE9C,KADU,MAAA,SAAe,GACnB,UAAU,OAAO;AACrB,SAAA,SAAe,OAAO,GAAG,EAAE;AAC3B;;AAGJ,SAAO;;;;;;;;CAST,QAAQ,cAAkB,YAAoB,GAAmB;EAC/D,MAAM,WAAW,MAAA,SAAe,OAAO;AACvC,MAAI,SACF,QAAO,SAAS,SAAS,QAAQ,OAAO,SAAS,UAAU;EAE7D,MAAM,IAAI,UAAa;EACvB,MAAM,YACJ,iBAAiB,KAAA,IACb,KAAA,IACA,iBAAiB;GACf,MAAM,IAAI,MAAA,UAAgB,WAAU,MAAK,EAAE,aAAa,EAAE;AAC1D,OAAI,KAAK,GAAG;IACV,MAAM,CAAC,YAAY,MAAA,UAAgB,OAAO,GAAG,EAAE;AAC/C,aAAS,SAAS,QAAQ,aAAa;;KAExC,UAAU;AACnB,QAAA,UAAgB,KAAK;GAAC,UAAU;GAAG;GAAU,CAAC;AAC9C,SAAO,EAAE;;;;;;;;;;;;;;;;CAiBX,QAA2B;EACzB,MAAM,MAAyB,EAAE;AACjC,OAAK,MAAM,KAAK,MAAA,SACd,KAAI,KAAK,EAAE,MAAM;AAEnB,QAAA,SAAe,SAAS;AAExB,SAAO;;;;;;;;CAST,OAAe;AACb,SAAO,MAAA,SAAe;;CAGxB,gBAAgB,UAAU,MAAwB;AAChD,SAAO,GAAE,OAAO,sBAAsB,KAAK,gBAAgB,QAAQ,EAAC;;CAGtE,gBAAgB,UAAU,MAAwB;AAChD,SAAO;GACL,MAAM,YAAY;AAChB,QAAI;AAEF,YAAO,EAAC,OADM,MAAM,KAAK,SAAS,EACpB;aACP,GAAG;AACV,cAAS;AACT,WAAM;;;GAGV,SAAQ,UAAS;AACf,aAAS;AACT,WAAO,QAAQ,QAAQ;KAAC;KAAO,MAAM;KAAK,CAAC;;GAE9C;;;AAIL,IAAM,aAAa"}

package/out/shared/src/rand.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"rand.js","names":[],"sources":["../../../../shared/src/rand.ts"],"sourcesContent":["/**\n * @param min Inclusive minimum of the result.\n * @param max Inclusive maximum of the result.\n * @returns A random integer in the (inclusive) range of [`min`, `max`].\n */\nexport function randInt(min: number, max: number) {\n  min = Math.ceil(min);\n  max = Math.floor(max);\n  return Math.floor(Math.random() * (max - min + 1) + min);\n}\n"],"mappings":";;;;;;AAKA,SAAgB,QAAQ,KAAa,KAAa;AAChD,OAAM,KAAK,KAAK,IAAI;AACpB,OAAM,KAAK,MAAM,IAAI;AACrB,QAAO,KAAK,MAAM,KAAK,QAAQ,IAAI,MAAM,MAAM,KAAK,IAAI"}

package/out/shared/src/random-uint64.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"random-uint64.js","names":[],"sources":["../../../../shared/src/random-uint64.ts"],"sourcesContent":["export function randomUint64(): bigint {\n  // Generate two random 32-bit unsigned integers using Math.random()\n  const high = Math.floor(Math.random() * 0xffffffff); // High 32 bits\n  const low = Math.floor(Math.random() * 0xffffffff); // Low 32 bits\n\n  // Combine the high and low parts to form a 64-bit unsigned integer\n  return (BigInt(high) << 32n) | BigInt(low);\n}\n"],"mappings":";AAAA,SAAgB,eAAuB;CAErC,MAAM,OAAO,KAAK,MAAM,KAAK,QAAQ,GAAG,WAAW;CACnD,MAAM,MAAM,KAAK,MAAM,KAAK,QAAQ,GAAG,WAAW;AAGlD,QAAQ,OAAO,KAAK,IAAI,MAAO,OAAO,IAAI"}