@rocicorp/zero 0.26.1-canary.9 → 0.26.2-canary.1

package/out/replicache/src/btree/node.js.map

@@ -1 +1 @@
-{"version":3,"file":"node.js","sources":["../../../../../replicache/src/btree/node.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {\n  assert,\n  assertArray,\n  assertNumber,\n  assertString,\n} from '../../../shared/src/asserts.ts';\nimport {binarySearch as binarySearchWithFunc} from '../../../shared/src/binary-search.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {\n  type JSONValue,\n  type ReadonlyJSONValue,\n  assertJSONValue,\n} from '../../../shared/src/json.ts';\nimport {skipBTreeNodeAsserts} from '../config.ts';\nimport type {IndexKey} from '../db/index.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport type {BTreeRead} from './read.ts';\nimport type {BTreeWrite} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport type Entry<V> = readonly [key: string, value: V, sizeOfEntry: number];\n\nexport const NODE_LEVEL = 0;\nexport const NODE_ENTRIES = 1;\n\n/**\n * The type of B+Tree node chunk data\n */\ntype BaseNode<V> = FrozenTag<\n  readonly [level: number, entries: ReadonlyArray<Entry<V>>]\n>;\nexport type InternalNode = BaseNode<Hash>;\n\nexport type DataNode = BaseNode<FrozenJSONValue>;\n\nexport function makeNodeChunkData<V>(\n  level: number,\n  entries: ReadonlyArray<Entry<V>>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return deepFreeze([\n    level,\n    (formatVersion >= FormatVersion.V7\n      ? entries\n      : entries.map(e => e.slice(0, 2))) as readonly ReadonlyJSONValue[],\n  ]) as BaseNode<V>;\n}\n\nexport type Node = DataNode | InternalNode;\n\n/**\n * Describes the changes that happened to Replicache after a\n * {@link WriteTransaction} was committed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type Diff = IndexDiff | NoIndexDiff;\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type IndexDiff = readonly DiffOperation<IndexKey>[];\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type NoIndexDiff = readonly DiffOperation<string>[];\n\n/**\n * InternalDiff uses string keys even for the secondary index maps.\n */\nexport type InternalDiff = readonly InternalDiffOperation[];\n\nexport type DiffOperationAdd<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'add';\n  readonly key: Key;\n  readonly newValue: Value;\n};\n\nexport type DiffOperationDel<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'del';\n  readonly key: Key;\n  readonly oldValue: Value;\n};\n\nexport type DiffOperationChange<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'change';\n  readonly key: Key;\n  readonly oldValue: Value;\n  readonly newValue: Value;\n};\n\n/**\n * The individual parts describing the changes that happened to the Replicache\n * data. There are three different kinds of operations:\n * - `add`: A new entry was added.\n * - `del`: An entry was deleted.\n * - `change`: An entry was changed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type DiffOperation<Key> =\n  | DiffOperationAdd<Key>\n  | DiffOperationDel<Key>\n  | DiffOperationChange<Key>;\n\n// Duplicated with DiffOperation to make the docs less confusing.\nexport type InternalDiffOperation<Key = string, Value = FrozenJSONValue> =\n  | DiffOperationAdd<Key, Value>\n  | DiffOperationDel<Key, Value>\n  | DiffOperationChange<Key, Value>;\n\n/**\n * Finds the leaf where a key is (if present) or where it should go if not\n * present.\n */\nexport async function findLeaf(\n  key: string,\n  hash: Hash,\n  source: BTreeRead,\n  expectedRootHash: Hash,\n): Promise<DataNodeImpl> {\n  const node = await source.getNode(hash);\n  // The root changed. Try again\n  if (expectedRootHash !== source.rootHash) {\n    return findLeaf(key, source.rootHash, source, source.rootHash);\n  }\n  if (isDataNodeImpl(node)) {\n    return node;\n  }\n  const {entries} = node;\n  let i = binarySearch(key, entries);\n  if (i === entries.length) {\n    i--;\n  }\n  const entry = entries[i];\n  return findLeaf(key, entry[1], source, expectedRootHash);\n}\n\ntype BinarySearchEntries = readonly Entry<unknown>[];\n\n/**\n * Does a binary search over entries\n *\n * If the key found then the return value is the index it was found at.\n *\n * If the key was *not* found then the return value is the index where it should\n * be inserted at\n */\nexport function binarySearch(\n  key: string,\n  entries: BinarySearchEntries,\n): number {\n  return binarySearchWithFunc(entries.length, i =>\n    compareUTF8(key, entries[i][0]),\n  );\n}\n\nexport function binarySearchFound(\n  i: number,\n  entries: BinarySearchEntries,\n  key: string,\n): boolean {\n  return i !== entries.length && entries[i][0] === key;\n}\n\nexport function parseBTreeNode(\n  v: unknown,\n  formatVersion: FormatVersion,\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): InternalNode | DataNode {\n  if (skipBTreeNodeAsserts && formatVersion >= FormatVersion.V7) {\n    return v as InternalNode | DataNode;\n  }\n\n  assertArray(v);\n  assertDeepFrozen(v);\n  // Be relaxed about what we accept.\n  assert(v.length >= 2, 'Expected node array to have at least 2 elements');\n  const [level, entries] = v;\n  assertNumber(level);\n  assertArray(entries);\n\n  const f = level > 0 ? assertString : assertJSONValue;\n\n  // For V7 we do not need to change the entries. Just assert that they are correct.\n  if (formatVersion >= FormatVersion.V7) {\n    for (const e of entries) {\n      assertEntry(e, f);\n    }\n    return v as unknown as InternalNode | DataNode;\n  }\n\n  const newEntries = entries.map(e => convertNonV7Entry(e, f, getSizeOfEntry));\n  return [level, newEntries] as unknown as InternalNode | DataNode;\n}\n\nfunction assertEntry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n): asserts entry is Entry<Hash | JSONValue> {\n  assertArray(entry);\n  // Be relaxed about what we accept.\n  assert(entry.length >= 3, 'Expected entry array to have at least 3 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  assertNumber(entry[2]);\n}\n\n/**\n * Converts an entry that was from a format version before V7 to the format\n * wanted by V7.\n */\nfunction convertNonV7Entry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): Entry<Hash | JSONValue> {\n  assertArray(entry);\n  assert(entry.length >= 2, 'Expected entry array to have at least 2 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  const entrySize = getSizeOfEntry(entry[0], entry[1]);\n  return [entry[0], entry[1], entrySize] as Entry<Hash | JSONValue>;\n}\n\nexport function isInternalNode(node: Node): node is InternalNode {\n  return node[NODE_LEVEL] > 0;\n}\n\nabstract class NodeImpl<Value> {\n  entries: Array<Entry<Value>>;\n  hash: Hash;\n  abstract readonly level: number;\n  readonly isMutable: boolean;\n\n  #childNodeSize = -1;\n\n  constructor(entries: Array<Entry<Value>>, hash: Hash, isMutable: boolean) {\n    this.entries = entries;\n    this.hash = hash;\n    this.isMutable = isMutable;\n  }\n\n  abstract set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value>>;\n\n  abstract del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value> | DataNodeImpl>;\n\n  maxKey(): string {\n    return this.entries[this.entries.length - 1][0];\n  }\n\n  getChildNodeSize(tree: BTreeRead): number {\n    if (this.#childNodeSize !== -1) {\n      return this.#childNodeSize;\n    }\n\n    let sum = tree.chunkHeaderSize;\n    for (const entry of this.entries) {\n      sum += entry[2];\n    }\n    return (this.#childNodeSize = sum);\n  }\n\n  protected _updateNode(tree: BTreeWrite) {\n    this.#childNodeSize = -1;\n    tree.updateNode(\n      this as NodeImpl<unknown> as DataNodeImpl | InternalNodeImpl,\n    );\n  }\n}\n\nexport function toChunkData<V>(\n  node: NodeImpl<V>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return makeNodeChunkData(node.level, node.entries, formatVersion);\n}\n\nexport class DataNodeImpl extends NodeImpl<FrozenJSONValue> {\n  readonly level = 0;\n\n  set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<DataNodeImpl> {\n    let deleteCount: number;\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found, insert.\n      deleteCount = 0;\n    } else {\n      deleteCount = 1;\n    }\n\n    return Promise.resolve(\n      this.#splice(tree, i, deleteCount, [key, value, entrySize]),\n    );\n  }\n\n  #splice(\n    tree: BTreeWrite,\n    start: number,\n    deleteCount: number,\n    ...items: Entry<FrozenJSONValue>[]\n  ): DataNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(start, deleteCount, ...items);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(this.entries, start, deleteCount, ...items);\n    return tree.newDataNodeImpl(entries);\n  }\n\n  del(key: string, tree: BTreeWrite): Promise<DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found. Return this without changes.\n      return Promise.resolve(this);\n    }\n\n    // Found. Create new node or mutate existing one.\n    return Promise.resolve(this.#splice(tree, i, 1));\n  }\n\n  async *keys(_tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      yield entry[0];\n    }\n  }\n\n  async *entriesIter(\n    _tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      yield entry;\n    }\n  }\n}\n\nfunction readonlySplice<T>(\n  array: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  ...items: T[]\n): T[] {\n  const arr = array.slice(0, start);\n  for (let i = 0; i < items.length; i++) {\n    arr.push(items[i]);\n  }\n  for (let i = start + deleteCount; i < array.length; i++) {\n    arr.push(array[i]);\n  }\n  return arr;\n}\n\nexport class InternalNodeImpl extends NodeImpl<Hash> {\n  readonly level: number;\n\n  constructor(\n    entries: Array<Entry<Hash>>,\n    hash: Hash,\n    level: number,\n    isMutable: boolean,\n  ) {\n    super(entries, hash, isMutable);\n    this.level = level;\n  }\n\n  async set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl> {\n    let i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // We are going to insert into last (right most) leaf.\n      i--;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n\n    const childNode = await oldChildNode.set(key, value, entrySize, tree);\n\n    const childNodeSize = childNode.getChildNodeSize(tree);\n    if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) {\n      return this.#mergeAndPartition(tree, i, childNode);\n    }\n\n    const newEntry = createNewInternalEntryForNode(\n      childNode,\n      tree.getEntrySize,\n    );\n    return this.#replaceChild(tree, i, newEntry);\n  }\n\n  /**\n   * This merges the child node entries with previous or next sibling and then\n   * partitions the merged entries.\n   */\n  async #mergeAndPartition(\n    tree: BTreeWrite,\n    i: number,\n    childNode: DataNodeImpl | InternalNodeImpl,\n  ): Promise<InternalNodeImpl> {\n    const level = this.level - 1;\n    const thisEntries = this.entries;\n\n    type IterableHashEntries = Iterable<Entry<Hash>>;\n\n    let values: IterableHashEntries;\n    let startIndex: number;\n    let removeCount: number;\n    if (i > 0) {\n      const hash = thisEntries[i - 1][1];\n      const previousSibling = await tree.getNode(hash);\n      values = joinIterables(\n        previousSibling.entries as IterableHashEntries,\n        childNode.entries as IterableHashEntries,\n      );\n      startIndex = i - 1;\n      removeCount = 2;\n    } else if (i < thisEntries.length - 1) {\n      const hash = thisEntries[i + 1][1];\n      const nextSibling = await tree.getNode(hash);\n      values = joinIterables(\n        childNode.entries as IterableHashEntries,\n        nextSibling.entries as IterableHashEntries,\n      );\n      startIndex = i;\n      removeCount = 2;\n    } else {\n      values = childNode.entries as IterableHashEntries;\n      startIndex = i;\n      removeCount = 1;\n    }\n\n    const partitions = partition(\n      values,\n      value => value[2],\n      tree.minSize - tree.chunkHeaderSize,\n      tree.maxSize - tree.chunkHeaderSize,\n    );\n\n    // TODO: There are cases where we can reuse the old nodes. Creating new ones\n    // means more memory churn but also more writes to the underlying KV store.\n    const newEntries: Entry<Hash>[] = [];\n    for (const entries of partitions) {\n      const node = tree.newNodeImpl(entries, level);\n      const newHashEntry = createNewInternalEntryForNode(\n        node,\n        tree.getEntrySize,\n      );\n      newEntries.push(newHashEntry);\n    }\n\n    if (this.isMutable) {\n      this.entries.splice(startIndex, removeCount, ...newEntries);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(\n      thisEntries,\n      startIndex,\n      removeCount,\n      ...newEntries,\n    );\n\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  #replaceChild(\n    tree: BTreeWrite,\n    index: number,\n    newEntry: Entry<Hash>,\n  ): InternalNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(index, 1, newEntry);\n      this._updateNode(tree);\n      return this;\n    }\n    const entries = readonlySplice(this.entries, index, 1, newEntry);\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  async del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // Key is larger than maxKey of rightmost entry so it is not present.\n      return this;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n    const oldHash = oldChildNode.hash;\n\n    const childNode = await oldChildNode.del(key, tree);\n    if (childNode.hash === oldHash) {\n      // Not changed so not found.\n      return this;\n    }\n\n    if (childNode.entries.length === 0) {\n      // Subtree is now empty. Remove internal node.\n      const entries = readonlySplice(this.entries, i, 1);\n      return tree.newInternalNodeImpl(entries, this.level);\n    }\n\n    if (i === 0 && this.entries.length === 1) {\n      // There was only one node at this level and it was removed. We can return\n      // the modified subtree.\n      return childNode;\n    }\n\n    // The child node is still a good size.\n    if (childNode.getChildNodeSize(tree) > tree.minSize) {\n      // No merging needed.\n      const entry = createNewInternalEntryForNode(childNode, tree.getEntrySize);\n      return this.#replaceChild(tree, i, entry);\n    }\n\n    // Child node size is too small.\n    return this.#mergeAndPartition(tree, i, childNode);\n  }\n\n  async *keys(tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.keys(tree);\n    }\n  }\n\n  async *entriesIter(\n    tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.entriesIter(tree);\n    }\n  }\n\n  getChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<Array<InternalNodeImpl | DataNodeImpl>> {\n    const ps: Promise<DataNodeImpl | InternalNodeImpl>[] = [];\n    for (let i = start; i < length && i < this.entries.length; i++) {\n      ps.push(tree.getNode(this.entries[i][1]));\n    }\n    return Promise.all(ps);\n  }\n\n  async getCompositeChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const {level} = this;\n\n    if (length === 0) {\n      return new InternalNodeImpl([], newRandomHash(), level - 1, true);\n    }\n\n    const output = await this.getChildren(start, start + length, tree);\n\n    if (level > 1) {\n      const entries: Entry<Hash>[] = [];\n      for (const child of output as InternalNodeImpl[]) {\n        entries.push(...child.entries);\n      }\n      return new InternalNodeImpl(entries, newRandomHash(), level - 1, true);\n    }\n\n    assert(level === 1, 'Expected level to be 1');\n    const entries: Entry<FrozenJSONValue>[] = [];\n    for (const child of output as DataNodeImpl[]) {\n      entries.push(...child.entries);\n    }\n    return new DataNodeImpl(entries, newRandomHash(), true);\n  }\n}\n\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl {\n  if (level === 0) {\n    return new DataNodeImpl(\n      entries as Entry<FrozenJSONValue>[],\n      hash,\n      isMutable,\n    );\n  }\n  return new InternalNodeImpl(entries as Entry<Hash>[], hash, level, isMutable);\n}\n\nexport function isDataNodeImpl(\n  node: DataNodeImpl | InternalNodeImpl,\n): node is DataNodeImpl {\n  return node.level === 0;\n}\n\nexport function partition<T>(\n  values: Iterable<T>,\n  // This is the size of each Entry\n  getSizeOfEntry: (v: T) => number,\n  min: number,\n  max: number,\n): T[][] {\n  const partitions: T[][] = [];\n  const sizes: number[] = [];\n  let sum = 0;\n  let accum: T[] = [];\n  for (const value of values) {\n    const size = getSizeOfEntry(value);\n    if (size >= max) {\n      if (accum.length > 0) {\n        partitions.push(accum);\n        sizes.push(sum);\n      }\n      partitions.push([value]);\n      sizes.push(size);\n      sum = 0;\n      accum = [];\n    } else if (sum + size >= min) {\n      accum.push(value);\n      partitions.push(accum);\n      sizes.push(sum + size);\n      sum = 0;\n      accum = [];\n    } else {\n      sum += size;\n      accum.push(value);\n    }\n  }\n\n  if (sum > 0) {\n    if (sizes.length > 0 && sum + sizes[sizes.length - 1] <= max) {\n      partitions[partitions.length - 1].push(...accum);\n    } else {\n      partitions.push(accum);\n    }\n  }\n\n  return partitions;\n}\n\nexport const emptyDataNode = makeNodeChunkData<ReadonlyJSONValue>(\n  0,\n  [],\n  FormatVersion.Latest,\n);\nexport const emptyDataNodeImpl = new DataNodeImpl([], emptyHash, false);\n\nexport function createNewInternalEntryForNode(\n  node: NodeImpl<unknown>,\n  getSizeOfEntry: <K, V>(k: K, v: V) => number,\n): [string, Hash, number] {\n  const key = node.maxKey();\n  const value = node.hash;\n  const size = getSizeOfEntry(key, value);\n  return [key, value, size];\n}\n"],"names":["FormatVersion.V7","binarySearchWithFunc","skipBTreeNodeAsserts","entries","FormatVersion.Latest"],"mappings":"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"}
+{"version":3,"file":"node.js","names":["#childNodeSize","#splice","#mergeAndPartition","#replaceChild"],"sources":["../../../../../replicache/src/btree/node.ts"],"sourcesContent":["import {compareUTF8} from 'compare-utf8';\nimport {\n  assert,\n  assertArray,\n  assertNumber,\n  assertString,\n} from '../../../shared/src/asserts.ts';\nimport {binarySearch as binarySearchWithFunc} from '../../../shared/src/binary-search.ts';\nimport type {Enum} from '../../../shared/src/enum.ts';\nimport {joinIterables} from '../../../shared/src/iterables.ts';\nimport {\n  type JSONValue,\n  type ReadonlyJSONValue,\n  assertJSONValue,\n} from '../../../shared/src/json.ts';\nimport {skipBTreeNodeAsserts} from '../config.ts';\nimport type {IndexKey} from '../db/index.ts';\nimport * as FormatVersion from '../format-version-enum.ts';\nimport {\n  type FrozenJSONValue,\n  type FrozenTag,\n  assertDeepFrozen,\n  deepFreeze,\n} from '../frozen-json.ts';\nimport {type Hash, emptyHash, newRandomHash} from '../hash.ts';\nimport type {BTreeRead} from './read.ts';\nimport type {BTreeWrite} from './write.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\nexport type Entry<V> = readonly [key: string, value: V, sizeOfEntry: number];\n\nexport const NODE_LEVEL = 0;\nexport const NODE_ENTRIES = 1;\n\n/**\n * The type of B+Tree node chunk data\n */\ntype BaseNode<V> = FrozenTag<\n  readonly [level: number, entries: ReadonlyArray<Entry<V>>]\n>;\nexport type InternalNode = BaseNode<Hash>;\n\nexport type DataNode = BaseNode<FrozenJSONValue>;\n\nexport function makeNodeChunkData<V>(\n  level: number,\n  entries: ReadonlyArray<Entry<V>>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return deepFreeze([\n    level,\n    (formatVersion >= FormatVersion.V7\n      ? entries\n      : entries.map(e => e.slice(0, 2))) as readonly ReadonlyJSONValue[],\n  ]) as BaseNode<V>;\n}\n\nexport type Node = DataNode | InternalNode;\n\n/**\n * Describes the changes that happened to Replicache after a\n * {@link WriteTransaction} was committed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type Diff = IndexDiff | NoIndexDiff;\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type IndexDiff = readonly DiffOperation<IndexKey>[];\n\n/**\n * @experimental This type is experimental and may change in the future.\n */\nexport type NoIndexDiff = readonly DiffOperation<string>[];\n\n/**\n * InternalDiff uses string keys even for the secondary index maps.\n */\nexport type InternalDiff = readonly InternalDiffOperation[];\n\nexport type DiffOperationAdd<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'add';\n  readonly key: Key;\n  readonly newValue: Value;\n};\n\nexport type DiffOperationDel<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'del';\n  readonly key: Key;\n  readonly oldValue: Value;\n};\n\nexport type DiffOperationChange<Key, Value = ReadonlyJSONValue> = {\n  readonly op: 'change';\n  readonly key: Key;\n  readonly oldValue: Value;\n  readonly newValue: Value;\n};\n\n/**\n * The individual parts describing the changes that happened to the Replicache\n * data. There are three different kinds of operations:\n * - `add`: A new entry was added.\n * - `del`: An entry was deleted.\n * - `change`: An entry was changed.\n *\n * @experimental This type is experimental and may change in the future.\n */\nexport type DiffOperation<Key> =\n  | DiffOperationAdd<Key>\n  | DiffOperationDel<Key>\n  | DiffOperationChange<Key>;\n\n// Duplicated with DiffOperation to make the docs less confusing.\nexport type InternalDiffOperation<Key = string, Value = FrozenJSONValue> =\n  | DiffOperationAdd<Key, Value>\n  | DiffOperationDel<Key, Value>\n  | DiffOperationChange<Key, Value>;\n\n/**\n * Finds the leaf where a key is (if present) or where it should go if not\n * present.\n */\nexport async function findLeaf(\n  key: string,\n  hash: Hash,\n  source: BTreeRead,\n  expectedRootHash: Hash,\n): Promise<DataNodeImpl> {\n  const node = await source.getNode(hash);\n  // The root changed. Try again\n  if (expectedRootHash !== source.rootHash) {\n    return findLeaf(key, source.rootHash, source, source.rootHash);\n  }\n  if (isDataNodeImpl(node)) {\n    return node;\n  }\n  const {entries} = node;\n  let i = binarySearch(key, entries);\n  if (i === entries.length) {\n    i--;\n  }\n  const entry = entries[i];\n  return findLeaf(key, entry[1], source, expectedRootHash);\n}\n\ntype BinarySearchEntries = readonly Entry<unknown>[];\n\n/**\n * Does a binary search over entries\n *\n * If the key found then the return value is the index it was found at.\n *\n * If the key was *not* found then the return value is the index where it should\n * be inserted at\n */\nexport function binarySearch(\n  key: string,\n  entries: BinarySearchEntries,\n): number {\n  return binarySearchWithFunc(entries.length, i =>\n    compareUTF8(key, entries[i][0]),\n  );\n}\n\nexport function binarySearchFound(\n  i: number,\n  entries: BinarySearchEntries,\n  key: string,\n): boolean {\n  return i !== entries.length && entries[i][0] === key;\n}\n\nexport function parseBTreeNode(\n  v: unknown,\n  formatVersion: FormatVersion,\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): InternalNode | DataNode {\n  if (skipBTreeNodeAsserts && formatVersion >= FormatVersion.V7) {\n    return v as InternalNode | DataNode;\n  }\n\n  assertArray(v);\n  assertDeepFrozen(v);\n  // Be relaxed about what we accept.\n  assert(v.length >= 2, 'Expected node array to have at least 2 elements');\n  const [level, entries] = v;\n  assertNumber(level);\n  assertArray(entries);\n\n  const f = level > 0 ? assertString : assertJSONValue;\n\n  // For V7 we do not need to change the entries. Just assert that they are correct.\n  if (formatVersion >= FormatVersion.V7) {\n    for (const e of entries) {\n      assertEntry(e, f);\n    }\n    return v as unknown as InternalNode | DataNode;\n  }\n\n  const newEntries = entries.map(e => convertNonV7Entry(e, f, getSizeOfEntry));\n  return [level, newEntries] as unknown as InternalNode | DataNode;\n}\n\nfunction assertEntry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n): asserts entry is Entry<Hash | JSONValue> {\n  assertArray(entry);\n  // Be relaxed about what we accept.\n  assert(entry.length >= 3, 'Expected entry array to have at least 3 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  assertNumber(entry[2]);\n}\n\n/**\n * Converts an entry that was from a format version before V7 to the format\n * wanted by V7.\n */\nfunction convertNonV7Entry(\n  entry: unknown,\n  f:\n    | ((v: unknown) => asserts v is Hash)\n    | ((v: unknown) => asserts v is JSONValue),\n  getSizeOfEntry: <K, V>(key: K, value: V) => number,\n): Entry<Hash | JSONValue> {\n  assertArray(entry);\n  assert(entry.length >= 2, 'Expected entry array to have at least 2 elements');\n  assertString(entry[0]);\n  f(entry[1]);\n  const entrySize = getSizeOfEntry(entry[0], entry[1]);\n  return [entry[0], entry[1], entrySize] as Entry<Hash | JSONValue>;\n}\n\nexport function isInternalNode(node: Node): node is InternalNode {\n  return node[NODE_LEVEL] > 0;\n}\n\nabstract class NodeImpl<Value> {\n  entries: Array<Entry<Value>>;\n  hash: Hash;\n  abstract readonly level: number;\n  readonly isMutable: boolean;\n\n  #childNodeSize = -1;\n\n  constructor(entries: Array<Entry<Value>>, hash: Hash, isMutable: boolean) {\n    this.entries = entries;\n    this.hash = hash;\n    this.isMutable = isMutable;\n  }\n\n  abstract set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value>>;\n\n  abstract del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<NodeImpl<Value> | DataNodeImpl>;\n\n  maxKey(): string {\n    return this.entries[this.entries.length - 1][0];\n  }\n\n  getChildNodeSize(tree: BTreeRead): number {\n    if (this.#childNodeSize !== -1) {\n      return this.#childNodeSize;\n    }\n\n    let sum = tree.chunkHeaderSize;\n    for (const entry of this.entries) {\n      sum += entry[2];\n    }\n    return (this.#childNodeSize = sum);\n  }\n\n  protected _updateNode(tree: BTreeWrite) {\n    this.#childNodeSize = -1;\n    tree.updateNode(\n      this as NodeImpl<unknown> as DataNodeImpl | InternalNodeImpl,\n    );\n  }\n}\n\nexport function toChunkData<V>(\n  node: NodeImpl<V>,\n  formatVersion: FormatVersion,\n): BaseNode<V> {\n  return makeNodeChunkData(node.level, node.entries, formatVersion);\n}\n\nexport class DataNodeImpl extends NodeImpl<FrozenJSONValue> {\n  readonly level = 0;\n\n  set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<DataNodeImpl> {\n    let deleteCount: number;\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found, insert.\n      deleteCount = 0;\n    } else {\n      deleteCount = 1;\n    }\n\n    return Promise.resolve(\n      this.#splice(tree, i, deleteCount, [key, value, entrySize]),\n    );\n  }\n\n  #splice(\n    tree: BTreeWrite,\n    start: number,\n    deleteCount: number,\n    ...items: Entry<FrozenJSONValue>[]\n  ): DataNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(start, deleteCount, ...items);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(this.entries, start, deleteCount, ...items);\n    return tree.newDataNodeImpl(entries);\n  }\n\n  del(key: string, tree: BTreeWrite): Promise<DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (!binarySearchFound(i, this.entries, key)) {\n      // Not found. Return this without changes.\n      return Promise.resolve(this);\n    }\n\n    // Found. Create new node or mutate existing one.\n    return Promise.resolve(this.#splice(tree, i, 1));\n  }\n\n  async *keys(_tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      yield entry[0];\n    }\n  }\n\n  async *entriesIter(\n    _tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      yield entry;\n    }\n  }\n}\n\nfunction readonlySplice<T>(\n  array: ReadonlyArray<T>,\n  start: number,\n  deleteCount: number,\n  ...items: T[]\n): T[] {\n  const arr = array.slice(0, start);\n  for (let i = 0; i < items.length; i++) {\n    arr.push(items[i]);\n  }\n  for (let i = start + deleteCount; i < array.length; i++) {\n    arr.push(array[i]);\n  }\n  return arr;\n}\n\nexport class InternalNodeImpl extends NodeImpl<Hash> {\n  readonly level: number;\n\n  constructor(\n    entries: Array<Entry<Hash>>,\n    hash: Hash,\n    level: number,\n    isMutable: boolean,\n  ) {\n    super(entries, hash, isMutable);\n    this.level = level;\n  }\n\n  async set(\n    key: string,\n    value: FrozenJSONValue,\n    entrySize: number,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl> {\n    let i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // We are going to insert into last (right most) leaf.\n      i--;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n\n    const childNode = await oldChildNode.set(key, value, entrySize, tree);\n\n    const childNodeSize = childNode.getChildNodeSize(tree);\n    if (childNodeSize > tree.maxSize || childNodeSize < tree.minSize) {\n      return this.#mergeAndPartition(tree, i, childNode);\n    }\n\n    const newEntry = createNewInternalEntryForNode(\n      childNode,\n      tree.getEntrySize,\n    );\n    return this.#replaceChild(tree, i, newEntry);\n  }\n\n  /**\n   * This merges the child node entries with previous or next sibling and then\n   * partitions the merged entries.\n   */\n  async #mergeAndPartition(\n    tree: BTreeWrite,\n    i: number,\n    childNode: DataNodeImpl | InternalNodeImpl,\n  ): Promise<InternalNodeImpl> {\n    const level = this.level - 1;\n    const thisEntries = this.entries;\n\n    type IterableHashEntries = Iterable<Entry<Hash>>;\n\n    let values: IterableHashEntries;\n    let startIndex: number;\n    let removeCount: number;\n    if (i > 0) {\n      const hash = thisEntries[i - 1][1];\n      const previousSibling = await tree.getNode(hash);\n      values = joinIterables(\n        previousSibling.entries as IterableHashEntries,\n        childNode.entries as IterableHashEntries,\n      );\n      startIndex = i - 1;\n      removeCount = 2;\n    } else if (i < thisEntries.length - 1) {\n      const hash = thisEntries[i + 1][1];\n      const nextSibling = await tree.getNode(hash);\n      values = joinIterables(\n        childNode.entries as IterableHashEntries,\n        nextSibling.entries as IterableHashEntries,\n      );\n      startIndex = i;\n      removeCount = 2;\n    } else {\n      values = childNode.entries as IterableHashEntries;\n      startIndex = i;\n      removeCount = 1;\n    }\n\n    const partitions = partition(\n      values,\n      value => value[2],\n      tree.minSize - tree.chunkHeaderSize,\n      tree.maxSize - tree.chunkHeaderSize,\n    );\n\n    // TODO: There are cases where we can reuse the old nodes. Creating new ones\n    // means more memory churn but also more writes to the underlying KV store.\n    const newEntries: Entry<Hash>[] = [];\n    for (const entries of partitions) {\n      const node = tree.newNodeImpl(entries, level);\n      const newHashEntry = createNewInternalEntryForNode(\n        node,\n        tree.getEntrySize,\n      );\n      newEntries.push(newHashEntry);\n    }\n\n    if (this.isMutable) {\n      this.entries.splice(startIndex, removeCount, ...newEntries);\n      this._updateNode(tree);\n      return this;\n    }\n\n    const entries = readonlySplice(\n      thisEntries,\n      startIndex,\n      removeCount,\n      ...newEntries,\n    );\n\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  #replaceChild(\n    tree: BTreeWrite,\n    index: number,\n    newEntry: Entry<Hash>,\n  ): InternalNodeImpl {\n    if (this.isMutable) {\n      this.entries.splice(index, 1, newEntry);\n      this._updateNode(tree);\n      return this;\n    }\n    const entries = readonlySplice(this.entries, index, 1, newEntry);\n    return tree.newInternalNodeImpl(entries, this.level);\n  }\n\n  async del(\n    key: string,\n    tree: BTreeWrite,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const i = binarySearch(key, this.entries);\n    if (i === this.entries.length) {\n      // Key is larger than maxKey of rightmost entry so it is not present.\n      return this;\n    }\n\n    const childHash = this.entries[i][1];\n    const oldChildNode = await tree.getNode(childHash);\n    const oldHash = oldChildNode.hash;\n\n    const childNode = await oldChildNode.del(key, tree);\n    if (childNode.hash === oldHash) {\n      // Not changed so not found.\n      return this;\n    }\n\n    if (childNode.entries.length === 0) {\n      // Subtree is now empty. Remove internal node.\n      const entries = readonlySplice(this.entries, i, 1);\n      return tree.newInternalNodeImpl(entries, this.level);\n    }\n\n    if (i === 0 && this.entries.length === 1) {\n      // There was only one node at this level and it was removed. We can return\n      // the modified subtree.\n      return childNode;\n    }\n\n    // The child node is still a good size.\n    if (childNode.getChildNodeSize(tree) > tree.minSize) {\n      // No merging needed.\n      const entry = createNewInternalEntryForNode(childNode, tree.getEntrySize);\n      return this.#replaceChild(tree, i, entry);\n    }\n\n    // Child node size is too small.\n    return this.#mergeAndPartition(tree, i, childNode);\n  }\n\n  async *keys(tree: BTreeRead): AsyncGenerator<string, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.keys(tree);\n    }\n  }\n\n  async *entriesIter(\n    tree: BTreeRead,\n  ): AsyncGenerator<Entry<FrozenJSONValue>, void> {\n    for (const entry of this.entries) {\n      const childNode = await tree.getNode(entry[1]);\n      yield* childNode.entriesIter(tree);\n    }\n  }\n\n  getChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<Array<InternalNodeImpl | DataNodeImpl>> {\n    const ps: Promise<DataNodeImpl | InternalNodeImpl>[] = [];\n    for (let i = start; i < length && i < this.entries.length; i++) {\n      ps.push(tree.getNode(this.entries[i][1]));\n    }\n    return Promise.all(ps);\n  }\n\n  async getCompositeChildren(\n    start: number,\n    length: number,\n    tree: BTreeRead,\n  ): Promise<InternalNodeImpl | DataNodeImpl> {\n    const {level} = this;\n\n    if (length === 0) {\n      return new InternalNodeImpl([], newRandomHash(), level - 1, true);\n    }\n\n    const output = await this.getChildren(start, start + length, tree);\n\n    if (level > 1) {\n      const entries: Entry<Hash>[] = [];\n      for (const child of output as InternalNodeImpl[]) {\n        entries.push(...child.entries);\n      }\n      return new InternalNodeImpl(entries, newRandomHash(), level - 1, true);\n    }\n\n    assert(level === 1, 'Expected level to be 1');\n    const entries: Entry<FrozenJSONValue>[] = [];\n    for (const child of output as DataNodeImpl[]) {\n      entries.push(...child.entries);\n    }\n    return new DataNodeImpl(entries, newRandomHash(), true);\n  }\n}\n\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl;\nexport function newNodeImpl(\n  entries: Array<Entry<FrozenJSONValue>> | Array<Entry<Hash>>,\n  hash: Hash,\n  level: number,\n  isMutable: boolean,\n): DataNodeImpl | InternalNodeImpl {\n  if (level === 0) {\n    return new DataNodeImpl(\n      entries as Entry<FrozenJSONValue>[],\n      hash,\n      isMutable,\n    );\n  }\n  return new InternalNodeImpl(entries as Entry<Hash>[], hash, level, isMutable);\n}\n\nexport function isDataNodeImpl(\n  node: DataNodeImpl | InternalNodeImpl,\n): node is DataNodeImpl {\n  return node.level === 0;\n}\n\nexport function partition<T>(\n  values: Iterable<T>,\n  // This is the size of each Entry\n  getSizeOfEntry: (v: T) => number,\n  min: number,\n  max: number,\n): T[][] {\n  const partitions: T[][] = [];\n  const sizes: number[] = [];\n  let sum = 0;\n  let accum: T[] = [];\n  for (const value of values) {\n    const size = getSizeOfEntry(value);\n    if (size >= max) {\n      if (accum.length > 0) {\n        partitions.push(accum);\n        sizes.push(sum);\n      }\n      partitions.push([value]);\n      sizes.push(size);\n      sum = 0;\n      accum = [];\n    } else if (sum + size >= min) {\n      accum.push(value);\n      partitions.push(accum);\n      sizes.push(sum + size);\n      sum = 0;\n      accum = [];\n    } else {\n      sum += size;\n      accum.push(value);\n    }\n  }\n\n  if (sum > 0) {\n    if (sizes.length > 0 && sum + sizes[sizes.length - 1] <= max) {\n      partitions[partitions.length - 1].push(...accum);\n    } else {\n      partitions.push(accum);\n    }\n  }\n\n  return partitions;\n}\n\nexport const emptyDataNode = makeNodeChunkData<ReadonlyJSONValue>(\n  0,\n  [],\n  FormatVersion.Latest,\n);\nexport const emptyDataNodeImpl = new DataNodeImpl([], emptyHash, false);\n\nexport function createNewInternalEntryForNode(\n  node: NodeImpl<unknown>,\n  getSizeOfEntry: <K, V>(k: K, v: V) => number,\n): [string, Hash, number] {\n  const key = node.maxKey();\n  const value = node.hash;\n  const size = getSizeOfEntry(key, value);\n  return [key, value, size];\n}\n"],"mappings":"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"}

package/out/replicache/src/btree/read.js

@@ -1,266 +1,165 @@
 import { deepEqual } from "../../../shared/src/json.js";
-import { getSizeOfEntry } from "../../../shared/src/size-of-value.js";
 import { emptyHash } from "../hash.js";
-import { emptyDataNodeImpl, parseBTreeNode, newNodeImpl, NODE_LEVEL, NODE_ENTRIES, findLeaf, binarySearch, binarySearchFound, isDataNodeImpl } from "./node.js";
-import { computeSplices, SPLICE_AT, SPLICE_REMOVED, SPLICE_FROM, SPLICE_ADDED } from "./splice.js";
-const NODE_HEADER_SIZE = 11;
-class BTreeRead {
-  _cache = /* @__PURE__ */ new Map();
-  _dagRead;
-  _formatVersion;
-  rootHash;
-  getEntrySize;
-  chunkHeaderSize;
-  constructor(dagRead, formatVersion, root = emptyHash, getEntrySize = getSizeOfEntry, chunkHeaderSize = NODE_HEADER_SIZE) {
-    this._dagRead = dagRead;
-    this._formatVersion = formatVersion;
-    this.rootHash = root;
-    this.getEntrySize = getEntrySize;
-    this.chunkHeaderSize = chunkHeaderSize;
-  }
-  async getNode(hash) {
-    if (hash === emptyHash) {
-      return emptyDataNodeImpl;
-    }
-    const cached = this._cache.get(hash);
-    if (cached) {
-      return cached;
-    }
-    const chunk = await this._dagRead.mustGetChunk(hash);
-    const data = parseBTreeNode(
-      chunk.data,
-      this._formatVersion,
-      this.getEntrySize
-    );
-    const impl = newNodeImpl(
-      data[NODE_ENTRIES],
-      hash,
-      data[NODE_LEVEL],
-      false
-    );
-    this._cache.set(hash, impl);
-    return impl;
-  }
-  async get(key) {
-    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
-    const index = binarySearch(key, leaf.entries);
-    if (!binarySearchFound(index, leaf.entries, key)) {
-      return void 0;
-    }
-    return leaf.entries[index][1];
-  }
-  async has(key) {
-    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
-    const index = binarySearch(key, leaf.entries);
-    return binarySearchFound(index, leaf.entries, key);
-  }
-  async isEmpty() {
-    const { rootHash } = this;
-    const node = await this.getNode(this.rootHash);
-    if (this.rootHash !== rootHash) {
-      return this.isEmpty();
-    }
-    return node.entries.length === 0;
-  }
-  // We don't do any encoding of the key in the map, so we have no way of
-  // determining from an entry.key alone whether it is a regular key or an
-  // encoded IndexKey in an index map. Without encoding regular map keys the
-  // caller has to deal with encoding and decoding the keys for the index map.
-  scan(fromKey) {
-    return scanForHash(
-      this.rootHash,
-      () => this.rootHash,
-      this.rootHash,
-      fromKey,
-      async (hash) => {
-        const cached = await this.getNode(hash);
-        if (cached) {
-          return [
-            cached.level,
-            cached.isMutable ? cached.entries.slice() : cached.entries
-          ];
-        }
-        const chunk = await this._dagRead.mustGetChunk(hash);
-        return parseBTreeNode(
-          chunk.data,
-          this._formatVersion,
-          this.getEntrySize
-        );
-      }
-    );
-  }
-  async *keys() {
-    const node = await this.getNode(this.rootHash);
-    yield* node.keys(this);
-  }
-  async *entries() {
-    const node = await this.getNode(this.rootHash);
-    yield* node.entriesIter(this);
-  }
-  [Symbol.asyncIterator]() {
-    return this.entries();
-  }
-  async *diff(last) {
-    const [currentNode, lastNode] = await Promise.all([
-      this.getNode(this.rootHash),
-      last.getNode(last.rootHash)
-    ]);
-    yield* diffNodes(lastNode, currentNode, last, this);
-  }
-}
+import { binarySearch, binarySearchFound, emptyDataNodeImpl, findLeaf, isDataNodeImpl, newNodeImpl, parseBTreeNode } from "./node.js";
+import { getSizeOfEntry } from "../../../shared/src/size-of-value.js";
+import { computeSplices } from "./splice.js";
+var BTreeRead = class {
+	_cache = /* @__PURE__ */ new Map();
+	_dagRead;
+	_formatVersion;
+	rootHash;
+	getEntrySize;
+	chunkHeaderSize;
+	constructor(dagRead, formatVersion, root = emptyHash, getEntrySize = getSizeOfEntry, chunkHeaderSize = 11) {
+		this._dagRead = dagRead;
+		this._formatVersion = formatVersion;
+		this.rootHash = root;
+		this.getEntrySize = getEntrySize;
+		this.chunkHeaderSize = chunkHeaderSize;
+	}
+	async getNode(hash) {
+		if (hash === emptyHash) return emptyDataNodeImpl;
+		const cached = this._cache.get(hash);
+		if (cached) return cached;
+		const data = parseBTreeNode((await this._dagRead.mustGetChunk(hash)).data, this._formatVersion, this.getEntrySize);
+		const impl = newNodeImpl(data[1], hash, data[0], false);
+		this._cache.set(hash, impl);
+		return impl;
+	}
+	async get(key) {
+		const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
+		const index = binarySearch(key, leaf.entries);
+		if (!binarySearchFound(index, leaf.entries, key)) return;
+		return leaf.entries[index][1];
+	}
+	async has(key) {
+		const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);
+		return binarySearchFound(binarySearch(key, leaf.entries), leaf.entries, key);
+	}
+	async isEmpty() {
+		const { rootHash } = this;
+		const node = await this.getNode(this.rootHash);
+		if (this.rootHash !== rootHash) return this.isEmpty();
+		return node.entries.length === 0;
+	}
+	scan(fromKey) {
+		return scanForHash(this.rootHash, () => this.rootHash, this.rootHash, fromKey, async (hash) => {
+			const cached = await this.getNode(hash);
+			if (cached) return [cached.level, cached.isMutable ? cached.entries.slice() : cached.entries];
+			return parseBTreeNode((await this._dagRead.mustGetChunk(hash)).data, this._formatVersion, this.getEntrySize);
+		});
+	}
+	async *keys() {
+		yield* (await this.getNode(this.rootHash)).keys(this);
+	}
+	async *entries() {
+		yield* (await this.getNode(this.rootHash)).entriesIter(this);
+	}
+	[Symbol.asyncIterator]() {
+		return this.entries();
+	}
+	async *diff(last) {
+		const [currentNode, lastNode] = await Promise.all([this.getNode(this.rootHash), last.getNode(last.rootHash)]);
+		yield* diffNodes(lastNode, currentNode, last, this);
+	}
+};
 async function* diffNodes(last, current, lastTree, currentTree) {
-  if (last.level > current.level) {
-    const lastChild = await last.getCompositeChildren(
-      0,
-      last.entries.length,
-      lastTree
-    );
-    yield* diffNodes(lastChild, current, lastTree, currentTree);
-    return;
-  }
-  if (current.level > last.level) {
-    const currentChild = await current.getCompositeChildren(
-      0,
-      current.entries.length,
-      currentTree
-    );
-    yield* diffNodes(last, currentChild, lastTree, currentTree);
-    return;
-  }
-  if (isDataNodeImpl(last) && isDataNodeImpl(current)) {
-    yield* diffEntries(
-      last.entries,
-      current.entries
-    );
-    return;
-  }
-  const initialSplices = computeSplices(
-    last.entries,
-    current.entries
-  );
-  for (const splice of initialSplices) {
-    const [lastChild, currentChild] = await Promise.all([
-      last.getCompositeChildren(
-        splice[SPLICE_AT],
-        splice[SPLICE_REMOVED],
-        lastTree
-      ),
-      current.getCompositeChildren(
-        splice[SPLICE_FROM],
-        splice[SPLICE_ADDED],
-        currentTree
-      )
-    ]);
-    yield* diffNodes(lastChild, currentChild, lastTree, currentTree);
-  }
+	if (last.level > current.level) {
+		yield* diffNodes(await last.getCompositeChildren(0, last.entries.length, lastTree), current, lastTree, currentTree);
+		return;
+	}
+	if (current.level > last.level) {
+		yield* diffNodes(last, await current.getCompositeChildren(0, current.entries.length, currentTree), lastTree, currentTree);
+		return;
+	}
+	if (isDataNodeImpl(last) && isDataNodeImpl(current)) {
+		yield* diffEntries(last.entries, current.entries);
+		return;
+	}
+	const initialSplices = computeSplices(last.entries, current.entries);
+	for (const splice of initialSplices) {
+		const [lastChild, currentChild] = await Promise.all([last.getCompositeChildren(splice[0], splice[1], lastTree), current.getCompositeChildren(splice[3], splice[2], currentTree)]);
+		yield* diffNodes(lastChild, currentChild, lastTree, currentTree);
+	}
 }
 function* diffEntries(lastEntries, currentEntries) {
-  const lastLength = lastEntries.length;
-  const currentLength = currentEntries.length;
-  let i = 0;
-  let j = 0;
-  while (i < lastLength && j < currentLength) {
-    const lastKey = lastEntries[i][0];
-    const currentKey = currentEntries[j][0];
-    if (lastKey === currentKey) {
-      if (!deepEqual(lastEntries[i][1], currentEntries[j][1])) {
-        yield {
-          op: "change",
-          key: lastKey,
-          oldValue: lastEntries[i][1],
-          newValue: currentEntries[j][1]
-        };
-      }
-      i++;
-      j++;
-    } else if (lastKey < currentKey) {
-      yield {
-        op: "del",
-        key: lastKey,
-        oldValue: lastEntries[i][1]
-      };
-      i++;
-    } else {
-      yield {
-        op: "add",
-        key: currentKey,
-        newValue: currentEntries[j][1]
-      };
-      j++;
-    }
-  }
-  for (; i < lastLength; i++) {
-    yield {
-      op: "del",
-      key: lastEntries[i][0],
-      oldValue: lastEntries[i][1]
-    };
-  }
-  for (; j < currentLength; j++) {
-    yield {
-      op: "add",
-      key: currentEntries[j][0],
-      newValue: currentEntries[j][1]
-    };
-  }
+	const lastLength = lastEntries.length;
+	const currentLength = currentEntries.length;
+	let i = 0;
+	let j = 0;
+	while (i < lastLength && j < currentLength) {
+		const lastKey = lastEntries[i][0];
+		const currentKey = currentEntries[j][0];
+		if (lastKey === currentKey) {
+			if (!deepEqual(lastEntries[i][1], currentEntries[j][1])) yield {
+				op: "change",
+				key: lastKey,
+				oldValue: lastEntries[i][1],
+				newValue: currentEntries[j][1]
+			};
+			i++;
+			j++;
+		} else if (lastKey < currentKey) {
+			yield {
+				op: "del",
+				key: lastKey,
+				oldValue: lastEntries[i][1]
+			};
+			i++;
+		} else {
+			yield {
+				op: "add",
+				key: currentKey,
+				newValue: currentEntries[j][1]
+			};
+			j++;
+		}
+	}
+	for (; i < lastLength; i++) yield {
+		op: "del",
+		key: lastEntries[i][0],
+		oldValue: lastEntries[i][1]
+	};
+	for (; j < currentLength; j++) yield {
+		op: "add",
+		key: currentEntries[j][0],
+		newValue: currentEntries[j][1]
+	};
 }
 async function* scanForHash(expectedRootHash, getRootHash, hash, fromKey, readNode) {
-  if (hash === emptyHash) {
-    return;
-  }
-  const data = await readNode(hash);
-  const entries = data[NODE_ENTRIES];
-  let i = 0;
-  if (fromKey) {
-    i = binarySearch(fromKey, entries);
-  }
-  if (data[NODE_LEVEL] > 0) {
-    for (; i < entries.length; i++) {
-      yield* scanForHash(
-        expectedRootHash,
-        getRootHash,
-        entries[i][1],
-        fromKey,
-        readNode
-      );
-      fromKey = "";
-    }
-  } else {
-    for (; i < entries.length; i++) {
-      const rootHash = getRootHash();
-      if (expectedRootHash !== rootHash) {
-        yield* scanForHash(
-          rootHash,
-          getRootHash,
-          rootHash,
-          entries[i][0],
-          readNode
-        );
-        return;
-      }
-      yield entries[i];
-    }
-  }
+	if (hash === emptyHash) return;
+	const data = await readNode(hash);
+	const entries = data[1];
+	let i = 0;
+	if (fromKey) i = binarySearch(fromKey, entries);
+	if (data[0] > 0) for (; i < entries.length; i++) {
+		yield* scanForHash(expectedRootHash, getRootHash, entries[i][1], fromKey, readNode);
+		fromKey = "";
+	}
+	else for (; i < entries.length; i++) {
+		const rootHash = getRootHash();
+		if (expectedRootHash !== rootHash) {
+			yield* scanForHash(rootHash, getRootHash, rootHash, entries[i][0], readNode);
+			return;
+		}
+		yield entries[i];
+	}
 }
 async function allEntriesAsDiff(map, op) {
-  const diff = [];
-  const make = op === "add" ? (entry) => ({
-    op: "add",
-    key: entry[0],
-    newValue: entry[1]
-  }) : (entry) => ({
-    op: "del",
-    key: entry[0],
-    oldValue: entry[1]
-  });
-  for await (const entry of map.entries()) {
-    diff.push(make(entry));
-  }
-  return diff;
+	const diff = [];
+	const make = op === "add" ? (entry) => ({
+		op: "add",
+		key: entry[0],
+		newValue: entry[1]
+	}) : (entry) => ({
+		op: "del",
+		key: entry[0],
+		oldValue: entry[1]
+	});
+	for await (const entry of map.entries()) diff.push(make(entry));
+	return diff;
 }
-export {
-  BTreeRead,
-  NODE_HEADER_SIZE,
-  allEntriesAsDiff
-};
-//# sourceMappingURL=read.js.map
+//#endregion
+export { BTreeRead, allEntriesAsDiff };
+
+//# sourceMappingURL=read.js.map

package/out/replicache/src/btree/read.js.map

@@ -1 +1 @@
-{"version":3,"file":"read.js","sources":["../../../../../replicache/src/btree/read.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {deepEqual} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport type {Read} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport type {DataNodeImpl, InternalNodeImpl} from './node.ts';\nimport {\n  type Entry,\n  type InternalDiff,\n  type InternalDiffOperation,\n  NODE_ENTRIES,\n  NODE_LEVEL,\n  binarySearch,\n  binarySearchFound,\n  emptyDataNodeImpl,\n  findLeaf,\n  isDataNodeImpl,\n  newNodeImpl,\n  parseBTreeNode,\n} from './node.ts';\nimport {\n  SPLICE_ADDED,\n  SPLICE_AT,\n  SPLICE_FROM,\n  SPLICE_REMOVED,\n  computeSplices,\n} from './splice.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * The size of the header of a node. (If we had compile time\n * constants we would have used that).\n *\n * There is a test ensuring this is correct.\n */\nexport const NODE_HEADER_SIZE = 11;\n\nexport class BTreeRead implements AsyncIterable<Entry<FrozenJSONValue>> {\n  protected readonly _cache: Map<Hash, DataNodeImpl | InternalNodeImpl> =\n    new Map();\n\n  protected readonly _dagRead: Read;\n  protected readonly _formatVersion: FormatVersion;\n  rootHash: Hash;\n  readonly getEntrySize: <K, V>(k: K, v: V) => number;\n  readonly chunkHeaderSize: number;\n\n  constructor(\n    dagRead: Read,\n    formatVersion: FormatVersion,\n    root: Hash = emptyHash,\n    getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n    chunkHeaderSize = NODE_HEADER_SIZE,\n  ) {\n    this._dagRead = dagRead;\n    this._formatVersion = formatVersion;\n    this.rootHash = root;\n    this.getEntrySize = getEntrySize;\n    this.chunkHeaderSize = chunkHeaderSize;\n  }\n\n  async getNode(hash: Hash): Promise<DataNodeImpl | InternalNodeImpl> {\n    if (hash === emptyHash) {\n      return emptyDataNodeImpl;\n    }\n\n    const cached = this._cache.get(hash);\n    if (cached) {\n      return cached;\n    }\n\n    const chunk = await this._dagRead.mustGetChunk(hash);\n    const data = parseBTreeNode(\n      chunk.data,\n      this._formatVersion,\n      this.getEntrySize,\n    );\n    const impl = newNodeImpl(\n      data[NODE_ENTRIES] as Entry<FrozenJSONValue>[],\n      hash,\n      data[NODE_LEVEL],\n      false,\n    );\n    this._cache.set(hash, impl);\n    return impl;\n  }\n\n  async get(key: string): Promise<FrozenJSONValue | undefined> {\n    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);\n    const index = binarySearch(key, leaf.entries);\n    if (!binarySearchFound(index, leaf.entries, key)) {\n      return undefined;\n    }\n    return leaf.entries[index][1];\n  }\n\n  async has(key: string): Promise<boolean> {\n    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);\n    const index = binarySearch(key, leaf.entries);\n    return binarySearchFound(index, leaf.entries, key);\n  }\n\n  async isEmpty(): Promise<boolean> {\n    const {rootHash} = this;\n    const node = await this.getNode(this.rootHash);\n    // The root hash has changed, so the tree has been modified.\n    if (this.rootHash !== rootHash) {\n      return this.isEmpty();\n    }\n    return node.entries.length === 0;\n  }\n\n  // We don't do any encoding of the key in the map, so we have no way of\n  // determining from an entry.key alone whether it is a regular key or an\n  // encoded IndexKey in an index map. Without encoding regular map keys the\n  // caller has to deal with encoding and decoding the keys for the index map.\n  scan(fromKey: string): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return scanForHash(\n      this.rootHash,\n      () => this.rootHash,\n      this.rootHash,\n      fromKey,\n      async hash => {\n        const cached = await this.getNode(hash);\n        if (cached) {\n          return [\n            cached.level,\n            cached.isMutable ? cached.entries.slice() : cached.entries,\n          ];\n        }\n        const chunk = await this._dagRead.mustGetChunk(hash);\n        return parseBTreeNode(\n          chunk.data,\n          this._formatVersion,\n          this.getEntrySize,\n        );\n      },\n    );\n  }\n\n  async *keys(): AsyncIterableIterator<string> {\n    const node = await this.getNode(this.rootHash);\n    yield* node.keys(this);\n  }\n\n  async *entries(): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    const node = await this.getNode(this.rootHash);\n    yield* node.entriesIter(this);\n  }\n\n  [Symbol.asyncIterator](): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return this.entries();\n  }\n\n  async *diff(last: BTreeRead): AsyncIterableIterator<InternalDiffOperation> {\n    const [currentNode, lastNode] = await Promise.all([\n      this.getNode(this.rootHash),\n      last.getNode(last.rootHash),\n    ]);\n    yield* diffNodes(lastNode, currentNode, last, this);\n  }\n}\n\nasync function* diffNodes(\n  last: InternalNodeImpl | DataNodeImpl,\n  current: InternalNodeImpl | DataNodeImpl,\n  lastTree: BTreeRead,\n  currentTree: BTreeRead,\n): AsyncIterableIterator<InternalDiffOperation> {\n  if (last.level > current.level) {\n    // merge all of last's children into a new node\n    // We know last is an internal node because level > 0.\n    const lastChild = (await (last as InternalNodeImpl).getCompositeChildren(\n      0,\n      last.entries.length,\n      lastTree,\n    )) as InternalNodeImpl;\n    yield* diffNodes(lastChild, current, lastTree, currentTree);\n    return;\n  }\n\n  if (current.level > last.level) {\n    // We know current is an internal node because level > 0.\n    const currentChild = (await (\n      current as InternalNodeImpl\n    ).getCompositeChildren(\n      0,\n      current.entries.length,\n      currentTree,\n    )) as InternalNodeImpl;\n    yield* diffNodes(last, currentChild, lastTree, currentTree);\n    return;\n  }\n\n  if (isDataNodeImpl(last) && isDataNodeImpl(current)) {\n    yield* diffEntries(\n      (last as DataNodeImpl).entries,\n      (current as DataNodeImpl).entries,\n    );\n    return;\n  }\n\n  // Now we have two internal nodes with the same level. We compute the diff as\n  // splices for the internal node entries. We then flatten these and call diff\n  // recursively.\n  const initialSplices = computeSplices(\n    (last as InternalNodeImpl).entries,\n    (current as InternalNodeImpl).entries,\n  );\n  for (const splice of initialSplices) {\n    const [lastChild, currentChild] = await Promise.all([\n      (last as InternalNodeImpl).getCompositeChildren(\n        splice[SPLICE_AT],\n        splice[SPLICE_REMOVED],\n        lastTree,\n      ),\n      (current as InternalNodeImpl).getCompositeChildren(\n        splice[SPLICE_FROM],\n        splice[SPLICE_ADDED],\n        currentTree,\n      ),\n    ]);\n    yield* diffNodes(lastChild, currentChild, lastTree, currentTree);\n  }\n}\n\nfunction* diffEntries(\n  lastEntries: readonly Entry<FrozenJSONValue>[],\n  currentEntries: readonly Entry<FrozenJSONValue>[],\n): IterableIterator<InternalDiffOperation> {\n  const lastLength = lastEntries.length;\n  const currentLength = currentEntries.length;\n  let i = 0;\n  let j = 0;\n  while (i < lastLength && j < currentLength) {\n    const lastKey = lastEntries[i][0];\n    const currentKey = currentEntries[j][0];\n    if (lastKey === currentKey) {\n      if (!deepEqual(lastEntries[i][1], currentEntries[j][1])) {\n        yield {\n          op: 'change',\n          key: lastKey,\n          oldValue: lastEntries[i][1],\n          newValue: currentEntries[j][1],\n        };\n      }\n      i++;\n      j++;\n    } else if (lastKey < currentKey) {\n      yield {\n        op: 'del',\n        key: lastKey,\n        oldValue: lastEntries[i][1],\n      };\n      i++;\n    } else {\n      yield {\n        op: 'add',\n        key: currentKey,\n        newValue: currentEntries[j][1],\n      };\n      j++;\n    }\n  }\n  for (; i < lastLength; i++) {\n    yield {\n      op: 'del',\n      key: lastEntries[i][0],\n      oldValue: lastEntries[i][1],\n    };\n  }\n  for (; j < currentLength; j++) {\n    yield {\n      op: 'add',\n      key: currentEntries[j][0],\n      newValue: currentEntries[j][1],\n    };\n  }\n}\n\n// Redefine the type here to allow the optional size in the tuple.\ntype ReadNodeResult = readonly [\n  level: number,\n  data: readonly Entry<FrozenJSONValue>[] | readonly Entry<Hash>[],\n];\n\ntype ReadNode = (hash: Hash) => Promise<ReadNodeResult>;\n\nasync function* scanForHash(\n  expectedRootHash: Hash,\n  getRootHash: () => Hash,\n  hash: Hash,\n  fromKey: string,\n  readNode: ReadNode,\n): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n  if (hash === emptyHash) {\n    return;\n  }\n\n  const data = await readNode(hash);\n  const entries = data[NODE_ENTRIES];\n  let i = 0;\n  if (fromKey) {\n    i = binarySearch(fromKey, entries);\n  }\n  if (data[NODE_LEVEL] > 0) {\n    for (; i < entries.length; i++) {\n      yield* scanForHash(\n        expectedRootHash,\n        getRootHash,\n        (entries[i] as Entry<Hash>)[1],\n        fromKey,\n        readNode,\n      );\n      fromKey = '';\n    }\n  } else {\n    for (; i < entries.length; i++) {\n      const rootHash = getRootHash();\n      // If rootHash changed then we start a new iterator from the key.\n      if (expectedRootHash !== rootHash) {\n        yield* scanForHash(\n          rootHash,\n          getRootHash,\n          rootHash,\n          entries[i][0],\n          readNode,\n        );\n        return;\n      }\n      yield entries[i] as Entry<FrozenJSONValue>;\n    }\n  }\n}\n\nexport async function allEntriesAsDiff(\n  map: BTreeRead,\n  op: 'add' | 'del',\n): Promise<InternalDiff> {\n  const diff: InternalDiffOperation[] = [];\n  const make: (entry: Entry<FrozenJSONValue>) => InternalDiffOperation =\n    op === 'add'\n      ? entry => ({\n          op: 'add',\n          key: entry[0],\n          newValue: entry[1],\n        })\n      : entry => ({\n          op: 'del',\n          key: entry[0],\n          oldValue: entry[1],\n        });\n\n  for await (const entry of map.entries()) {\n    diff.push(make(entry));\n  }\n  return diff;\n}\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"read.js","names":[],"sources":["../../../../../replicache/src/btree/read.ts"],"sourcesContent":["import type {Enum} from '../../../shared/src/enum.ts';\nimport {deepEqual} from '../../../shared/src/json.ts';\nimport {getSizeOfEntry} from '../../../shared/src/size-of-value.ts';\nimport type {Read} from '../dag/store.ts';\nimport type * as FormatVersion from '../format-version-enum.ts';\nimport type {FrozenJSONValue} from '../frozen-json.ts';\nimport {type Hash, emptyHash} from '../hash.ts';\nimport type {DataNodeImpl, InternalNodeImpl} from './node.ts';\nimport {\n  type Entry,\n  type InternalDiff,\n  type InternalDiffOperation,\n  NODE_ENTRIES,\n  NODE_LEVEL,\n  binarySearch,\n  binarySearchFound,\n  emptyDataNodeImpl,\n  findLeaf,\n  isDataNodeImpl,\n  newNodeImpl,\n  parseBTreeNode,\n} from './node.ts';\nimport {\n  SPLICE_ADDED,\n  SPLICE_AT,\n  SPLICE_FROM,\n  SPLICE_REMOVED,\n  computeSplices,\n} from './splice.ts';\n\ntype FormatVersion = Enum<typeof FormatVersion>;\n\n/**\n * The size of the header of a node. (If we had compile time\n * constants we would have used that).\n *\n * There is a test ensuring this is correct.\n */\nexport const NODE_HEADER_SIZE = 11;\n\nexport class BTreeRead implements AsyncIterable<Entry<FrozenJSONValue>> {\n  protected readonly _cache: Map<Hash, DataNodeImpl | InternalNodeImpl> =\n    new Map();\n\n  protected readonly _dagRead: Read;\n  protected readonly _formatVersion: FormatVersion;\n  rootHash: Hash;\n  readonly getEntrySize: <K, V>(k: K, v: V) => number;\n  readonly chunkHeaderSize: number;\n\n  constructor(\n    dagRead: Read,\n    formatVersion: FormatVersion,\n    root: Hash = emptyHash,\n    getEntrySize: <K, V>(k: K, v: V) => number = getSizeOfEntry,\n    chunkHeaderSize = NODE_HEADER_SIZE,\n  ) {\n    this._dagRead = dagRead;\n    this._formatVersion = formatVersion;\n    this.rootHash = root;\n    this.getEntrySize = getEntrySize;\n    this.chunkHeaderSize = chunkHeaderSize;\n  }\n\n  async getNode(hash: Hash): Promise<DataNodeImpl | InternalNodeImpl> {\n    if (hash === emptyHash) {\n      return emptyDataNodeImpl;\n    }\n\n    const cached = this._cache.get(hash);\n    if (cached) {\n      return cached;\n    }\n\n    const chunk = await this._dagRead.mustGetChunk(hash);\n    const data = parseBTreeNode(\n      chunk.data,\n      this._formatVersion,\n      this.getEntrySize,\n    );\n    const impl = newNodeImpl(\n      data[NODE_ENTRIES] as Entry<FrozenJSONValue>[],\n      hash,\n      data[NODE_LEVEL],\n      false,\n    );\n    this._cache.set(hash, impl);\n    return impl;\n  }\n\n  async get(key: string): Promise<FrozenJSONValue | undefined> {\n    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);\n    const index = binarySearch(key, leaf.entries);\n    if (!binarySearchFound(index, leaf.entries, key)) {\n      return undefined;\n    }\n    return leaf.entries[index][1];\n  }\n\n  async has(key: string): Promise<boolean> {\n    const leaf = await findLeaf(key, this.rootHash, this, this.rootHash);\n    const index = binarySearch(key, leaf.entries);\n    return binarySearchFound(index, leaf.entries, key);\n  }\n\n  async isEmpty(): Promise<boolean> {\n    const {rootHash} = this;\n    const node = await this.getNode(this.rootHash);\n    // The root hash has changed, so the tree has been modified.\n    if (this.rootHash !== rootHash) {\n      return this.isEmpty();\n    }\n    return node.entries.length === 0;\n  }\n\n  // We don't do any encoding of the key in the map, so we have no way of\n  // determining from an entry.key alone whether it is a regular key or an\n  // encoded IndexKey in an index map. Without encoding regular map keys the\n  // caller has to deal with encoding and decoding the keys for the index map.\n  scan(fromKey: string): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return scanForHash(\n      this.rootHash,\n      () => this.rootHash,\n      this.rootHash,\n      fromKey,\n      async hash => {\n        const cached = await this.getNode(hash);\n        if (cached) {\n          return [\n            cached.level,\n            cached.isMutable ? cached.entries.slice() : cached.entries,\n          ];\n        }\n        const chunk = await this._dagRead.mustGetChunk(hash);\n        return parseBTreeNode(\n          chunk.data,\n          this._formatVersion,\n          this.getEntrySize,\n        );\n      },\n    );\n  }\n\n  async *keys(): AsyncIterableIterator<string> {\n    const node = await this.getNode(this.rootHash);\n    yield* node.keys(this);\n  }\n\n  async *entries(): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    const node = await this.getNode(this.rootHash);\n    yield* node.entriesIter(this);\n  }\n\n  [Symbol.asyncIterator](): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n    return this.entries();\n  }\n\n  async *diff(last: BTreeRead): AsyncIterableIterator<InternalDiffOperation> {\n    const [currentNode, lastNode] = await Promise.all([\n      this.getNode(this.rootHash),\n      last.getNode(last.rootHash),\n    ]);\n    yield* diffNodes(lastNode, currentNode, last, this);\n  }\n}\n\nasync function* diffNodes(\n  last: InternalNodeImpl | DataNodeImpl,\n  current: InternalNodeImpl | DataNodeImpl,\n  lastTree: BTreeRead,\n  currentTree: BTreeRead,\n): AsyncIterableIterator<InternalDiffOperation> {\n  if (last.level > current.level) {\n    // merge all of last's children into a new node\n    // We know last is an internal node because level > 0.\n    const lastChild = (await (last as InternalNodeImpl).getCompositeChildren(\n      0,\n      last.entries.length,\n      lastTree,\n    )) as InternalNodeImpl;\n    yield* diffNodes(lastChild, current, lastTree, currentTree);\n    return;\n  }\n\n  if (current.level > last.level) {\n    // We know current is an internal node because level > 0.\n    const currentChild = (await (\n      current as InternalNodeImpl\n    ).getCompositeChildren(\n      0,\n      current.entries.length,\n      currentTree,\n    )) as InternalNodeImpl;\n    yield* diffNodes(last, currentChild, lastTree, currentTree);\n    return;\n  }\n\n  if (isDataNodeImpl(last) && isDataNodeImpl(current)) {\n    yield* diffEntries(\n      (last as DataNodeImpl).entries,\n      (current as DataNodeImpl).entries,\n    );\n    return;\n  }\n\n  // Now we have two internal nodes with the same level. We compute the diff as\n  // splices for the internal node entries. We then flatten these and call diff\n  // recursively.\n  const initialSplices = computeSplices(\n    (last as InternalNodeImpl).entries,\n    (current as InternalNodeImpl).entries,\n  );\n  for (const splice of initialSplices) {\n    const [lastChild, currentChild] = await Promise.all([\n      (last as InternalNodeImpl).getCompositeChildren(\n        splice[SPLICE_AT],\n        splice[SPLICE_REMOVED],\n        lastTree,\n      ),\n      (current as InternalNodeImpl).getCompositeChildren(\n        splice[SPLICE_FROM],\n        splice[SPLICE_ADDED],\n        currentTree,\n      ),\n    ]);\n    yield* diffNodes(lastChild, currentChild, lastTree, currentTree);\n  }\n}\n\nfunction* diffEntries(\n  lastEntries: readonly Entry<FrozenJSONValue>[],\n  currentEntries: readonly Entry<FrozenJSONValue>[],\n): IterableIterator<InternalDiffOperation> {\n  const lastLength = lastEntries.length;\n  const currentLength = currentEntries.length;\n  let i = 0;\n  let j = 0;\n  while (i < lastLength && j < currentLength) {\n    const lastKey = lastEntries[i][0];\n    const currentKey = currentEntries[j][0];\n    if (lastKey === currentKey) {\n      if (!deepEqual(lastEntries[i][1], currentEntries[j][1])) {\n        yield {\n          op: 'change',\n          key: lastKey,\n          oldValue: lastEntries[i][1],\n          newValue: currentEntries[j][1],\n        };\n      }\n      i++;\n      j++;\n    } else if (lastKey < currentKey) {\n      yield {\n        op: 'del',\n        key: lastKey,\n        oldValue: lastEntries[i][1],\n      };\n      i++;\n    } else {\n      yield {\n        op: 'add',\n        key: currentKey,\n        newValue: currentEntries[j][1],\n      };\n      j++;\n    }\n  }\n  for (; i < lastLength; i++) {\n    yield {\n      op: 'del',\n      key: lastEntries[i][0],\n      oldValue: lastEntries[i][1],\n    };\n  }\n  for (; j < currentLength; j++) {\n    yield {\n      op: 'add',\n      key: currentEntries[j][0],\n      newValue: currentEntries[j][1],\n    };\n  }\n}\n\n// Redefine the type here to allow the optional size in the tuple.\ntype ReadNodeResult = readonly [\n  level: number,\n  data: readonly Entry<FrozenJSONValue>[] | readonly Entry<Hash>[],\n];\n\ntype ReadNode = (hash: Hash) => Promise<ReadNodeResult>;\n\nasync function* scanForHash(\n  expectedRootHash: Hash,\n  getRootHash: () => Hash,\n  hash: Hash,\n  fromKey: string,\n  readNode: ReadNode,\n): AsyncIterableIterator<Entry<FrozenJSONValue>> {\n  if (hash === emptyHash) {\n    return;\n  }\n\n  const data = await readNode(hash);\n  const entries = data[NODE_ENTRIES];\n  let i = 0;\n  if (fromKey) {\n    i = binarySearch(fromKey, entries);\n  }\n  if (data[NODE_LEVEL] > 0) {\n    for (; i < entries.length; i++) {\n      yield* scanForHash(\n        expectedRootHash,\n        getRootHash,\n        (entries[i] as Entry<Hash>)[1],\n        fromKey,\n        readNode,\n      );\n      fromKey = '';\n    }\n  } else {\n    for (; i < entries.length; i++) {\n      const rootHash = getRootHash();\n      // If rootHash changed then we start a new iterator from the key.\n      if (expectedRootHash !== rootHash) {\n        yield* scanForHash(\n          rootHash,\n          getRootHash,\n          rootHash,\n          entries[i][0],\n          readNode,\n        );\n        return;\n      }\n      yield entries[i] as Entry<FrozenJSONValue>;\n    }\n  }\n}\n\nexport async function allEntriesAsDiff(\n  map: BTreeRead,\n  op: 'add' | 'del',\n): Promise<InternalDiff> {\n  const diff: InternalDiffOperation[] = [];\n  const make: (entry: Entry<FrozenJSONValue>) => InternalDiffOperation =\n    op === 'add'\n      ? entry => ({\n          op: 'add',\n          key: entry[0],\n          newValue: entry[1],\n        })\n      : entry => ({\n          op: 'del',\n          key: entry[0],\n          oldValue: entry[1],\n        });\n\n  for await (const entry of map.entries()) {\n    diff.push(make(entry));\n  }\n  return diff;\n}\n"],"mappings":"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"}