xitdb 0.12.0 → 0.14.0

package/dist/index.js

@@ -1,3986 +1,35 @@
-// @bun
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __require = import.meta.require;
-
-// src/tag.ts
-var Tag;
-((Tag2) => {
-  Tag2[Tag2["NONE"] = 0] = "NONE";
-  Tag2[Tag2["INDEX"] = 1] = "INDEX";
-  Tag2[Tag2["ARRAY_LIST"] = 2] = "ARRAY_LIST";
-  Tag2[Tag2["LINKED_ARRAY_LIST"] = 3] = "LINKED_ARRAY_LIST";
-  Tag2[Tag2["HASH_MAP"] = 4] = "HASH_MAP";
-  Tag2[Tag2["KV_PAIR"] = 5] = "KV_PAIR";
-  Tag2[Tag2["BYTES"] = 6] = "BYTES";
-  Tag2[Tag2["SHORT_BYTES"] = 7] = "SHORT_BYTES";
-  Tag2[Tag2["UINT"] = 8] = "UINT";
-  Tag2[Tag2["INT"] = 9] = "INT";
-  Tag2[Tag2["FLOAT"] = 10] = "FLOAT";
-  Tag2[Tag2["HASH_SET"] = 11] = "HASH_SET";
-  Tag2[Tag2["COUNTED_HASH_MAP"] = 12] = "COUNTED_HASH_MAP";
-  Tag2[Tag2["COUNTED_HASH_SET"] = 13] = "COUNTED_HASH_SET";
-})(Tag ||= {});
-function tagValueOf(n) {
-  if (n < 0 || n > 13) {
-    throw new Error(`Invalid tag value: ${n}`);
-  }
-  return n;
-}
-// src/slot.ts
-class Slot {
-  static LENGTH = 9;
-  value;
-  tag;
-  full;
-  constructor(value = 0n, tag = 0 /* NONE */, full = false) {
-    this.value = typeof value === "bigint" ? value : BigInt(value);
-    this.tag = tag;
-    this.full = full;
-  }
-  withTag(tag) {
-    return new Slot(this.value, tag, this.full);
-  }
-  withFull(full) {
-    return new Slot(this.value, this.tag, full);
-  }
-  empty() {
-    return this.tag === 0 /* NONE */ && !this.full;
-  }
-  toBytes() {
-    const buffer = new ArrayBuffer(Slot.LENGTH);
-    const view = new DataView(buffer);
-    let tagInt = this.full ? 128 : 0;
-    tagInt = tagInt | this.tag;
-    view.setUint8(0, tagInt);
-    view.setBigInt64(1, this.value, false);
-    return new Uint8Array(buffer);
-  }
-  static fromBytes(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const tagByte = view.getUint8(0);
-    const full = (tagByte & 128) !== 0;
-    const tag = tagValueOf(tagByte & 127);
-    const value = view.getBigInt64(1, false);
-    return new Slot(value, tag, full);
-  }
-  equals(other) {
-    return this.value === other.value && this.tag === other.tag && this.full === other.full;
-  }
-}
-// src/slot-pointer.ts
-class SlotPointer {
-  position;
-  slot;
-  constructor(position, slot) {
-    this.position = position;
-    this.slot = slot;
-  }
-  withSlot(slot) {
-    return new SlotPointer(this.position, slot);
-  }
-}
-// src/exceptions.ts
-class DatabaseException extends Error {
-  constructor(message) {
-    super(message);
-    this.name = this.constructor.name;
-  }
-}
-
-class NotImplementedException extends DatabaseException {
-}
-
-class UnreachableException extends DatabaseException {
-}
-
-class InvalidDatabaseException extends DatabaseException {
-}
-
-class InvalidVersionException extends DatabaseException {
-}
-
-class InvalidHashSizeException extends DatabaseException {
-}
-
-class KeyNotFoundException extends DatabaseException {
-}
-
-class WriteNotAllowedException extends DatabaseException {
-}
-
-class UnexpectedTagException extends DatabaseException {
-}
-
-class CursorNotWriteableException extends DatabaseException {
-}
-
-class ExpectedTxStartException extends DatabaseException {
-}
-
-class KeyOffsetExceededException extends DatabaseException {
-}
-
-class PathPartMustBeAtEndException extends DatabaseException {
-}
-
-class StreamTooLongException extends DatabaseException {
-}
-
-class EndOfStreamException extends DatabaseException {
-}
-
-class InvalidOffsetException extends DatabaseException {
-}
-
-class InvalidTopLevelTypeException extends DatabaseException {
-}
-
-class ExpectedUnsignedLongException extends DatabaseException {
-}
-
-class NoAvailableSlotsException extends DatabaseException {
-}
-
-class MustSetNewSlotsToFullException extends DatabaseException {
-}
-
-class EmptySlotException extends DatabaseException {
-}
-
-class ExpectedRootNodeException extends DatabaseException {
-}
-
-class InvalidFormatTagSizeException extends DatabaseException {
-}
-
-class UnexpectedWriterPositionException extends DatabaseException {
-}
-
-class MaxShiftExceededException extends DatabaseException {
-}
-
-class Uint64OverflowException extends DatabaseException {
-}
-
-class Int64OverflowException extends DatabaseException {
-}
-
-// src/writeable-data.ts
-var UINT64_MAX = 2n ** 64n - 1n;
-var INT64_MIN = -(2n ** 63n);
-var INT64_MAX = 2n ** 63n - 1n;
-
-class Uint {
-  value;
-  constructor(value) {
-    const bigintValue = BigInt(value);
-    if (bigintValue < 0n || bigintValue > UINT64_MAX) {
-      throw new Uint64OverflowException;
-    }
-    this.value = bigintValue;
-  }
-}
-
-class Int {
-  value;
-  constructor(value) {
-    const bigintValue = BigInt(value);
-    if (bigintValue < INT64_MIN || bigintValue > INT64_MAX) {
-      throw new Int64OverflowException;
-    }
-    this.value = bigintValue;
-  }
-}
-
-class Float {
-  value;
-  constructor(value) {
-    this.value = value;
-  }
-}
-
-class Bytes {
-  value;
-  formatTag;
-  constructor(value, formatTag) {
-    if (typeof value === "string") {
-      this.value = new TextEncoder().encode(value);
-    } else {
-      this.value = value;
-    }
-    if (formatTag === undefined || formatTag === null) {
-      this.formatTag = null;
-    } else if (typeof formatTag === "string") {
-      const encoded = new TextEncoder().encode(formatTag);
-      if (encoded.length !== 2) {
-        throw new InvalidFormatTagSizeException;
-      }
-      this.formatTag = encoded;
-    } else {
-      if (formatTag.length !== 2) {
-        throw new InvalidFormatTagSizeException;
-      }
-      this.formatTag = formatTag;
-    }
-  }
-  isShort() {
-    const totalSize = this.formatTag !== null ? 6 : 8;
-    if (this.value.length > totalSize)
-      return false;
-    for (const b of this.value) {
-      if (b === 0)
-        return false;
-    }
-    return true;
-  }
-}
-// src/core-memory.ts
-class CoreMemory {
-  memory;
-  constructor() {
-    this.memory = new RandomAccessMemory;
-  }
-  reader() {
-    return this.memory;
-  }
-  writer() {
-    return this.memory;
-  }
-  async length() {
-    return this.memory.size();
-  }
-  async seek(pos) {
-    this.memory.seek(pos);
-  }
-  position() {
-    return this.memory.getPosition();
-  }
-  async setLength(len) {
-    this.memory.setLength(len);
-  }
-  async flush() {}
-  async sync() {}
-}
-
-class RandomAccessMemory {
-  buffer;
-  _position = 0;
-  _count = 0;
-  constructor(initialSize = 1024) {
-    this.buffer = new Uint8Array(initialSize);
-  }
-  ensureCapacity(minCapacity) {
-    if (minCapacity > this.buffer.length) {
-      let newCapacity = this.buffer.length * 2;
-      if (newCapacity < minCapacity) {
-        newCapacity = minCapacity;
-      }
-      const newBuffer = new Uint8Array(newCapacity);
-      newBuffer.set(this.buffer.subarray(0, this._count));
-      this.buffer = newBuffer;
-    }
-  }
-  size() {
-    return this._count;
-  }
-  seek(pos) {
-    if (pos > this._count) {
-      this._position = this._count;
-    } else {
-      this._position = pos;
-    }
-  }
-  getPosition() {
-    return this._position;
-  }
-  setLength(len) {
-    if (len === 0) {
-      this.reset();
-    } else {
-      if (len > this._count)
-        throw new Error("Cannot extend length");
-      this._count = len;
-      if (this._position > len) {
-        this._position = len;
-      }
-    }
-  }
-  reset() {
-    this._count = 0;
-    this._position = 0;
-  }
-  toByteArray() {
-    return this.buffer.slice(0, this._count);
-  }
-  async write(data) {
-    const pos = this._position;
-    if (pos < this._count) {
-      const bytesBeforeEnd = Math.min(data.length, this._count - pos);
-      for (let i = 0;i < bytesBeforeEnd; i++) {
-        this.buffer[pos + i] = data[i];
-      }
-      if (bytesBeforeEnd < data.length) {
-        const bytesAfterEnd = data.length - bytesBeforeEnd;
-        this.ensureCapacity(this._count + bytesAfterEnd);
-        this.buffer.set(data.subarray(bytesBeforeEnd), this._count);
-        this._count += bytesAfterEnd;
-      }
-    } else {
-      this.ensureCapacity(this._count + data.length);
-      this.buffer.set(data, this._count);
-      this._count += data.length;
-    }
-    this._position = pos + data.length;
-  }
-  async writeByte(v) {
-    await this.write(new Uint8Array([v & 255]));
-  }
-  async writeShort(v) {
-    const buffer = new ArrayBuffer(2);
-    const view = new DataView(buffer);
-    view.setInt16(0, v, false);
-    await this.write(new Uint8Array(buffer));
-  }
-  async writeLong(v) {
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setBigInt64(0, BigInt(v), false);
-    await this.write(new Uint8Array(buffer));
-  }
-  async readFully(b) {
-    const pos = this._position;
-    if (pos + b.length > this._count) {
-      throw new Error("End of stream");
-    }
-    b.set(this.buffer.subarray(pos, pos + b.length));
-    this._position = pos + b.length;
-  }
-  async readByte() {
-    const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
-    return bytes[0];
-  }
-  async readShort() {
-    const bytes = new Uint8Array(2);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt16(0, false);
-  }
-  async readInt() {
-    const bytes = new Uint8Array(4);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt32(0, false);
-  }
-  async readLong() {
-    const bytes = new Uint8Array(8);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return Number(view.getBigInt64(0, false));
-  }
-}
-// src/core-file.ts
-import * as fs from "fs/promises";
-
-class CoreFile {
-  filePath;
-  _position = 0;
-  fileHandle;
-  constructor(filePath, fileHandle) {
-    this.filePath = filePath;
-    this.fileHandle = fileHandle;
-  }
-  static async create(filePath) {
-    try {
-      await fs.access(filePath);
-    } catch {
-      await fs.writeFile(filePath, new Uint8Array(0));
-    }
-    const fileHandle = await fs.open(filePath, "r+");
-    return new CoreFile(filePath, fileHandle);
-  }
-  reader() {
-    return new FileDataReader(this);
-  }
-  writer() {
-    return new FileDataWriter(this);
-  }
-  async length() {
-    const stats = await this.fileHandle.stat();
-    return stats.size;
-  }
-  async seek(pos) {
-    this._position = pos;
-  }
-  position() {
-    return this._position;
-  }
-  async setLength(len) {
-    await this.fileHandle.truncate(len);
-  }
-  async flush() {}
-  async sync() {
-    await this.fileHandle.sync();
-  }
-  [Symbol.dispose]() {
-    import("fs").then((fs2) => {
-      fs2.closeSync(this.fileHandle.fd);
-    });
-  }
-}
-
-class FileDataReader {
-  core;
-  constructor(core) {
-    this.core = core;
-  }
-  async readFully(b) {
-    const position = this.core.position();
-    await this.core.fileHandle.readv([b], position);
-    this.core.seek(position + b.length);
-  }
-  async readByte() {
-    const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
-    return bytes[0];
-  }
-  async readShort() {
-    const bytes = new Uint8Array(2);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt16(0, false);
-  }
-  async readInt() {
-    const bytes = new Uint8Array(4);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt32(0, false);
-  }
-  async readLong() {
-    const bytes = new Uint8Array(8);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return Number(view.getBigInt64(0, false));
-  }
-}
-
-class FileDataWriter {
-  core;
-  constructor(core) {
-    this.core = core;
-  }
-  async write(buffer) {
-    const position = this.core.position();
-    await this.core.fileHandle.writev([buffer], position);
-    this.core.seek(position + buffer.length);
-  }
-  async writeByte(v) {
-    await this.write(new Uint8Array([v & 255]));
-  }
-  async writeShort(v) {
-    const buffer = new ArrayBuffer(2);
-    const view = new DataView(buffer);
-    view.setInt16(0, v, false);
-    await this.write(new Uint8Array(buffer));
-  }
-  async writeLong(v) {
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setBigInt64(0, BigInt(v), false);
-    await this.write(new Uint8Array(buffer));
-  }
-}
-// src/core-buffered-file.ts
-class CoreBufferedFile {
-  file;
-  constructor(file) {
-    this.file = file;
-  }
-  static async create(filePath, bufferSize) {
-    const file = await RandomAccessBufferedFile.create(filePath, bufferSize);
-    return new CoreBufferedFile(file);
-  }
-  reader() {
-    return this.file;
-  }
-  writer() {
-    return this.file;
-  }
-  async length() {
-    return await this.file.length();
-  }
-  async seek(pos) {
-    await this.file.seek(pos);
-  }
-  position() {
-    return this.file.position();
-  }
-  async setLength(len) {
-    await this.file.setLength(len);
-  }
-  async flush() {
-    await this.file.flush();
-  }
-  async sync() {
-    await this.file.sync();
-  }
-  [Symbol.dispose]() {
-    this.file.file[Symbol.dispose]();
-  }
-}
-var DEFAULT_BUFFER_SIZE = 8 * 1024 * 1024;
-
-class RandomAccessBufferedFile {
-  file;
-  memory;
-  bufferSize;
-  filePos;
-  memoryPos;
-  constructor(file, bufferSize) {
-    this.file = file;
-    this.memory = new CoreMemory;
-    this.bufferSize = bufferSize;
-    this.filePos = 0;
-    this.memoryPos = 0;
-  }
-  static async create(filePath, bufferSize = DEFAULT_BUFFER_SIZE) {
-    const file = await CoreFile.create(filePath);
-    return new RandomAccessBufferedFile(file, bufferSize);
-  }
-  async seek(pos) {
-    if (pos > this.memoryPos + await this.memory.length()) {
-      await this.flush();
-    }
-    this.filePos = pos;
-    if (await this.memory.length() === 0) {
-      this.memoryPos = pos;
-    }
-  }
-  async length() {
-    return Math.max(this.memoryPos + await this.memory.length(), await this.file.length());
-  }
-  position() {
-    return this.filePos;
-  }
-  async setLength(len) {
-    await this.flush();
-    await this.file.setLength(len);
-    this.filePos = Math.min(len, this.filePos);
-  }
-  async flush() {
-    if (await this.memory.length() > 0) {
-      await this.file.seek(this.memoryPos);
-      await this.file.writer().write(this.memory.memory.toByteArray());
-      this.memoryPos = 0;
-      this.memory.memory.reset();
-    }
-  }
-  async sync() {
-    await this.flush();
-    await this.file.sync();
-  }
-  async write(buffer) {
-    if (await this.memory.length() + buffer.length > this.bufferSize) {
-      await this.flush();
-    }
-    if (this.filePos >= this.memoryPos && this.filePos <= this.memoryPos + await this.memory.length()) {
-      this.memory.seek(this.filePos - this.memoryPos);
-      await this.memory.memory.write(buffer);
-    } else {
-      await this.file.seek(this.filePos);
-      await this.file.writer().write(buffer);
-    }
-    this.filePos += buffer.length;
-  }
-  async writeByte(v) {
-    await this.write(new Uint8Array([v & 255]));
-  }
-  async writeShort(v) {
-    const buffer = new ArrayBuffer(2);
-    const view = new DataView(buffer);
-    view.setInt16(0, v & 65535, false);
-    await this.write(new Uint8Array(buffer));
-  }
-  async writeLong(v) {
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setBigInt64(0, BigInt(v), false);
-    await this.write(new Uint8Array(buffer));
-  }
-  async readFully(buffer) {
-    let pos = 0;
-    if (this.filePos < this.memoryPos) {
-      const sizeBeforeMem = Math.min(this.memoryPos - this.filePos, buffer.length);
-      const tempBuffer = new Uint8Array(sizeBeforeMem);
-      await this.file.seek(this.filePos);
-      await this.file.reader().readFully(tempBuffer);
-      buffer.set(tempBuffer, pos);
-      pos += sizeBeforeMem;
-      this.filePos += sizeBeforeMem;
-    }
-    if (pos === buffer.length)
-      return;
-    if (this.filePos >= this.memoryPos && this.filePos < this.memoryPos + await this.memory.length()) {
-      const memPos = this.filePos - this.memoryPos;
-      const sizeInMem = Math.min(await this.memory.length() - memPos, buffer.length - pos);
-      this.memory.seek(memPos);
-      const memBuffer = new Uint8Array(sizeInMem);
-      await this.memory.memory.readFully(memBuffer);
-      buffer.set(memBuffer, pos);
-      pos += sizeInMem;
-      this.filePos += sizeInMem;
-    }
-    if (pos === buffer.length)
-      return;
-    if (this.filePos >= this.memoryPos + await this.memory.length()) {
-      const sizeAfterMem = buffer.length - pos;
-      const tempBuffer = new Uint8Array(sizeAfterMem);
-      await this.file.seek(this.filePos);
-      await this.file.reader().readFully(tempBuffer);
-      buffer.set(tempBuffer, pos);
-      pos += sizeAfterMem;
-      this.filePos += sizeAfterMem;
-    }
-  }
-  async readByte() {
-    const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
-    return bytes[0];
-  }
-  async readShort() {
-    const bytes = new Uint8Array(2);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt16(0, false);
-  }
-  async readInt() {
-    const bytes = new Uint8Array(4);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt32(0, false);
-  }
-  async readLong() {
-    const bytes = new Uint8Array(8);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return Number(view.getBigInt64(0, false));
-  }
-}
-// src/hasher.ts
-class Hasher {
-  algorithm;
-  id;
-  digestLength;
-  constructor(algorithm, id = 0) {
-    this.algorithm = algorithm;
-    this.id = id;
-    switch (algorithm) {
-      case "SHA-1":
-        this.digestLength = 20;
-        break;
-      case "SHA-256":
-        this.digestLength = 32;
-        break;
-      case "SHA-384":
-        this.digestLength = 48;
-        break;
-      case "SHA-512":
-        this.digestLength = 64;
-        break;
-      default:
-        throw new Error(`Unsupported hash algorithm: ${algorithm}`);
-    }
-  }
-  async digest(data) {
-    const buffer = new ArrayBuffer(data.length);
-    const view = new Uint8Array(buffer);
-    view.set(data);
-    const hashBuffer = await crypto.subtle.digest(this.algorithm, buffer);
-    return new Uint8Array(hashBuffer);
-  }
-  static stringToId(hashIdName) {
-    const bytes = new TextEncoder().encode(hashIdName);
-    if (bytes.length !== 4) {
-      throw new Error("Name must be exactly four bytes long");
-    }
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt32(0, false);
-  }
-  static idToString(id) {
-    const buffer = new ArrayBuffer(4);
-    const view = new DataView(buffer);
-    view.setInt32(0, id, false);
-    return new TextDecoder().decode(new Uint8Array(buffer));
-  }
-}
-// src/read-cursor.ts
-class KeyValuePairCursor {
-  valueCursor;
-  keyCursor;
-  hash;
-  constructor(valueCursor, keyCursor, hash) {
-    this.valueCursor = valueCursor;
-    this.keyCursor = keyCursor;
-    this.hash = hash;
-  }
-}
-
-class ReadCursor {
-  slotPtr;
-  db;
-  constructor(slotPtr, db) {
-    this.slotPtr = slotPtr;
-    this.db = db;
-  }
-  slot() {
-    return this.slotPtr.slot;
-  }
-  async readPath(path) {
-    try {
-      const slotPtr = await this.db.readSlotPointer(0 /* READ_ONLY */, path, 0, this.slotPtr);
-      return new ReadCursor(slotPtr, this.db);
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        return null;
-      }
-      throw e;
-    }
-  }
-  async readPathSlot(path) {
-    try {
-      const slotPtr = await this.db.readSlotPointer(0 /* READ_ONLY */, path, 0, this.slotPtr);
-      if (!slotPtr.slot.empty()) {
-        return slotPtr.slot;
-      } else {
-        return null;
-      }
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        return null;
-      }
-      throw e;
-    }
-  }
-  readUint() {
-    if (this.slotPtr.slot.tag !== 8 /* UINT */) {
-      throw new UnexpectedTagException;
-    }
-    if (this.slotPtr.slot.value < 0n)
-      throw new ExpectedUnsignedLongException;
-    return Number(this.slotPtr.slot.value);
-  }
-  readInt() {
-    if (this.slotPtr.slot.tag !== 9 /* INT */) {
-      throw new UnexpectedTagException;
-    }
-    return Number(this.slotPtr.slot.value);
-  }
-  readFloat() {
-    if (this.slotPtr.slot.tag !== 10 /* FLOAT */) {
-      throw new UnexpectedTagException;
-    }
-    const buffer = new ArrayBuffer(8);
-    const view = new DataView(buffer);
-    view.setBigInt64(0, this.slotPtr.slot.value, false);
-    return view.getFloat64(0, false);
-  }
-  async readBytes(maxSizeMaybe = null) {
-    const bytesObj = await this.readBytesObject(maxSizeMaybe);
-    return bytesObj.value;
-  }
-  async readBytesObject(maxSizeMaybe = null) {
-    const reader = this.db.core.reader();
-    switch (this.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        return new Bytes(new Uint8Array(0));
-      case 6 /* BYTES */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        const valueSize = await reader.readLong();
-        if (maxSizeMaybe !== null && valueSize > maxSizeMaybe) {
-          throw new StreamTooLongException;
-        }
-        const startPosition = this.db.core.position();
-        const value = new Uint8Array(valueSize);
-        await reader.readFully(value);
-        let formatTag = null;
-        if (this.slotPtr.slot.full) {
-          await this.db.core.seek(startPosition + valueSize);
-          formatTag = new Uint8Array(2);
-          await reader.readFully(formatTag);
-        }
-        return new Bytes(value, formatTag);
-      }
-      case 7 /* SHORT_BYTES */: {
-        const buffer = new ArrayBuffer(8);
-        const view = new DataView(buffer);
-        view.setBigInt64(0, this.slotPtr.slot.value, false);
-        const bytes = new Uint8Array(buffer);
-        const totalSize = this.slotPtr.slot.full ? bytes.length - 2 : bytes.length;
-        let valueSize = 0;
-        for (const b of bytes) {
-          if (b === 0 || valueSize === totalSize)
-            break;
-          valueSize += 1;
-        }
-        if (maxSizeMaybe !== null && valueSize > maxSizeMaybe) {
-          throw new StreamTooLongException;
-        }
-        let formatTag = null;
-        if (this.slotPtr.slot.full) {
-          formatTag = bytes.slice(totalSize, bytes.length);
-        }
-        return new Bytes(bytes.slice(0, valueSize), formatTag);
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async readKeyValuePair() {
-    const reader = this.db.core.reader();
-    if (this.slotPtr.slot.tag !== 5 /* KV_PAIR */) {
-      throw new UnexpectedTagException;
-    }
-    await this.db.core.seek(Number(this.slotPtr.slot.value));
-    const kvPairBytes = new Uint8Array(KeyValuePair.length(this.db.header.hashSize));
-    await reader.readFully(kvPairBytes);
-    const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.db.header.hashSize);
-    const hashPos = Number(this.slotPtr.slot.value);
-    const keySlotPos = hashPos + this.db.header.hashSize;
-    const valueSlotPos = keySlotPos + Slot.LENGTH;
-    return new KeyValuePairCursor(new ReadCursor(new SlotPointer(valueSlotPos, kvPair.valueSlot), this.db), new ReadCursor(new SlotPointer(keySlotPos, kvPair.keySlot), this.db), kvPair.hash);
-  }
-  async reader() {
-    const reader = this.db.core.reader();
-    switch (this.slotPtr.slot.tag) {
-      case 6 /* BYTES */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        const size = await reader.readLong();
-        const startPosition = this.db.core.position();
-        return new Reader(this, size, startPosition, 0);
-      }
-      case 7 /* SHORT_BYTES */: {
-        const buffer = new ArrayBuffer(8);
-        const view = new DataView(buffer);
-        view.setBigInt64(0, this.slotPtr.slot.value, false);
-        const bytes = new Uint8Array(buffer);
-        const totalSize = this.slotPtr.slot.full ? bytes.length - 2 : bytes.length;
-        let valueSize = 0;
-        for (const b of bytes) {
-          if (b === 0 || valueSize === totalSize)
-            break;
-          valueSize += 1;
-        }
-        const startPosition = this.slotPtr.position + 1;
-        return new Reader(this, valueSize, startPosition, 0);
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async count() {
-    const reader = this.db.core.reader();
-    switch (this.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        return 0;
-      case 2 /* ARRAY_LIST */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
-        const header = ArrayListHeader.fromBytes(headerBytes);
-        return header.size;
-      }
-      case 3 /* LINKED_ARRAY_LIST */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
-        const header = LinkedArrayListHeader.fromBytes(headerBytes);
-        return header.size;
-      }
-      case 6 /* BYTES */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        return reader.readLong();
-      }
-      case 7 /* SHORT_BYTES */: {
-        const buffer = new ArrayBuffer(8);
-        const view = new DataView(buffer);
-        view.setBigInt64(0, this.slotPtr.slot.value, false);
-        const bytes = new Uint8Array(buffer);
-        const totalSize = this.slotPtr.slot.full ? bytes.length - 2 : bytes.length;
-        let size = 0;
-        for (const b of bytes) {
-          if (b === 0 || size === totalSize)
-            break;
-          size += 1;
-        }
-        return size;
-      }
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */: {
-        await this.db.core.seek(Number(this.slotPtr.slot.value));
-        return reader.readLong();
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async* [Symbol.asyncIterator]() {
-    const iterator = await this.iterator();
-    while (await iterator.hasNext()) {
-      const next = await iterator.next();
-      if (next !== null) {
-        yield next;
-      }
-    }
-  }
-  async iterator() {
-    const iterator = new CursorIterator(this);
-    await iterator.init();
-    return iterator;
-  }
-}
-
-class Reader {
-  parent;
-  size;
-  startPosition;
-  relativePosition;
-  constructor(parent, size, startPosition, relativePosition) {
-    this.parent = parent;
-    this.size = size;
-    this.startPosition = startPosition;
-    this.relativePosition = relativePosition;
-  }
-  async read(buffer) {
-    if (this.size < this.relativePosition)
-      throw new EndOfStreamException;
-    await this.parent.db.core.seek(this.startPosition + this.relativePosition);
-    const readSize = Math.min(buffer.length, this.size - this.relativePosition);
-    if (readSize === 0)
-      return -1;
-    const reader = this.parent.db.core.reader();
-    const tempBuffer = new Uint8Array(readSize);
-    await reader.readFully(tempBuffer);
-    buffer.set(tempBuffer);
-    this.relativePosition += readSize;
-    return readSize;
-  }
-  async readFully(buffer) {
-    if (this.size < this.relativePosition || this.size - this.relativePosition < buffer.length) {
-      throw new EndOfStreamException;
-    }
-    await this.parent.db.core.seek(this.startPosition + this.relativePosition);
-    const reader = this.parent.db.core.reader();
-    await reader.readFully(buffer);
-    this.relativePosition += buffer.length;
-  }
-  async readByte() {
-    const bytes = new Uint8Array(1);
-    await this.readFully(bytes);
-    return bytes[0];
-  }
-  async readShort() {
-    const readSize = 2;
-    const bytes = new Uint8Array(readSize);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt16(0, false);
-  }
-  async readInt() {
-    const readSize = 4;
-    const bytes = new Uint8Array(readSize);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getInt32(0, false);
-  }
-  async readLong() {
-    const readSize = 8;
-    const bytes = new Uint8Array(readSize);
-    await this.readFully(bytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return Number(view.getBigInt64(0, false));
-  }
-  seek(position) {
-    if (position > this.size) {
-      throw new InvalidOffsetException;
-    }
-    this.relativePosition = position;
-  }
-}
-
-class IteratorLevel {
-  position;
-  block;
-  index;
-  constructor(position, block, index) {
-    this.position = position;
-    this.block = block;
-    this.index = index;
-  }
-}
-
-class CursorIterator {
-  cursor;
-  size = 0;
-  index = 0;
-  stack = [];
-  nextCursorMaybe = null;
-  constructor(cursor) {
-    this.cursor = cursor;
-  }
-  async init() {
-    switch (this.cursor.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        this.size = 0;
-        this.index = 0;
-        this.stack = [];
-        break;
-      case 2 /* ARRAY_LIST */: {
-        const position = Number(this.cursor.slotPtr.slot.value);
-        await this.cursor.db.core.seek(position);
-        const reader = this.cursor.db.core.reader();
-        const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
-        const header = ArrayListHeader.fromBytes(headerBytes);
-        this.size = await this.cursor.count();
-        this.index = 0;
-        this.stack = await this.initStack(this.cursor, header.ptr, INDEX_BLOCK_SIZE);
-        break;
-      }
-      case 3 /* LINKED_ARRAY_LIST */: {
-        const position = Number(this.cursor.slotPtr.slot.value);
-        await this.cursor.db.core.seek(position);
-        const reader = this.cursor.db.core.reader();
-        const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-        await reader.readFully(headerBytes);
-        const header = LinkedArrayListHeader.fromBytes(headerBytes);
-        this.size = await this.cursor.count();
-        this.index = 0;
-        this.stack = await this.initStack(this.cursor, header.ptr, LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-        break;
-      }
-      case 4 /* HASH_MAP */:
-      case 11 /* HASH_SET */:
-        this.size = 0;
-        this.index = 0;
-        this.stack = await this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value), INDEX_BLOCK_SIZE);
-        break;
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */:
-        this.size = 0;
-        this.index = 0;
-        this.stack = await this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value) + 8, INDEX_BLOCK_SIZE);
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async initStack(cursor, position, blockSize) {
-    await cursor.db.core.seek(position);
-    const reader = cursor.db.core.reader();
-    const indexBlockBytes = new Uint8Array(blockSize);
-    await reader.readFully(indexBlockBytes);
-    const indexBlock = new Array(SLOT_COUNT);
-    const slotSize = blockSize / SLOT_COUNT;
-    for (let i = 0;i < SLOT_COUNT; i++) {
-      const slotBytes = indexBlockBytes.slice(i * slotSize, i * slotSize + Slot.LENGTH);
-      indexBlock[i] = Slot.fromBytes(slotBytes);
-    }
-    return [new IteratorLevel(position, indexBlock, 0)];
-  }
-  async hasNext() {
-    switch (this.cursor.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        return false;
-      case 2 /* ARRAY_LIST */:
-        return this.index < this.size;
-      case 3 /* LINKED_ARRAY_LIST */:
-        return this.index < this.size;
-      case 4 /* HASH_MAP */:
-      case 11 /* HASH_SET */:
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */:
-        if (this.nextCursorMaybe === null) {
-          this.nextCursorMaybe = await this.nextInternal(INDEX_BLOCK_SIZE);
-        }
-        return this.nextCursorMaybe !== null;
-      default:
-        return false;
-    }
-  }
-  async next() {
-    switch (this.cursor.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        return null;
-      case 2 /* ARRAY_LIST */:
-        if (!await this.hasNext())
-          return null;
-        this.index += 1;
-        return this.nextInternal(INDEX_BLOCK_SIZE);
-      case 3 /* LINKED_ARRAY_LIST */:
-        if (!await this.hasNext())
-          return null;
-        this.index += 1;
-        return this.nextInternal(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-      case 4 /* HASH_MAP */:
-      case 11 /* HASH_SET */:
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */:
-        if (this.nextCursorMaybe !== null) {
-          const nextCursor = this.nextCursorMaybe;
-          this.nextCursorMaybe = null;
-          return nextCursor;
-        } else {
-          return this.nextInternal(INDEX_BLOCK_SIZE);
-        }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async nextInternal(blockSize) {
-    while (this.stack.length > 0) {
-      const level = this.stack[this.stack.length - 1];
-      if (level.index === level.block.length) {
-        this.stack.pop();
-        if (this.stack.length > 0) {
-          this.stack[this.stack.length - 1].index += 1;
-        }
-        continue;
-      } else {
-        const nextSlot = level.block[level.index];
-        if (nextSlot.tag === 1 /* INDEX */) {
-          const nextPos = Number(nextSlot.value);
-          await this.cursor.db.core.seek(nextPos);
-          const reader = this.cursor.db.core.reader();
-          const indexBlockBytes = new Uint8Array(blockSize);
-          await reader.readFully(indexBlockBytes);
-          const indexBlock = new Array(SLOT_COUNT);
-          const slotSize = blockSize / SLOT_COUNT;
-          for (let i = 0;i < SLOT_COUNT; i++) {
-            const slotBytes = indexBlockBytes.slice(i * slotSize, i * slotSize + Slot.LENGTH);
-            indexBlock[i] = Slot.fromBytes(slotBytes);
-          }
-          this.stack.push(new IteratorLevel(nextPos, indexBlock, 0));
-          continue;
-        } else {
-          this.stack[this.stack.length - 1].index += 1;
-          if (!nextSlot.empty()) {
-            const position = level.position + level.index * Slot.LENGTH;
-            return new ReadCursor(new SlotPointer(position, nextSlot), this.cursor.db);
-          } else {
-            continue;
-          }
-        }
-      }
-    }
-    return null;
-  }
-}
-
-// src/write-cursor.ts
-class WriteKeyValuePairCursor extends KeyValuePairCursor {
-  valueCursor;
-  keyCursor;
-  constructor(valueCursor, keyCursor, hash) {
-    super(valueCursor, keyCursor, hash);
-    this.valueCursor = valueCursor;
-    this.keyCursor = keyCursor;
-  }
-}
-
-class WriteCursor extends ReadCursor {
-  constructor(slotPtr, db) {
-    super(slotPtr, db);
-  }
-  async writePath(path) {
-    const slotPtr = await this.db.readSlotPointer(1 /* READ_WRITE */, path, 0, this.slotPtr);
-    if (this.db.txStart === null) {
-      await this.db.core.sync();
-    }
-    return new WriteCursor(slotPtr, this.db);
-  }
-  async write(data) {
-    const cursor = await this.writePath([new WriteData(data)]);
-    this.slotPtr = cursor.slotPtr;
-  }
-  async writeIfEmpty(data) {
-    if (this.slotPtr.slot.empty()) {
-      await this.write(data);
-    }
-  }
-  async readKeyValuePair() {
-    const kvPairCursor = await super.readKeyValuePair();
-    return new WriteKeyValuePairCursor(new WriteCursor(kvPairCursor.valueCursor.slotPtr, this.db), new WriteCursor(kvPairCursor.keyCursor.slotPtr, this.db), kvPairCursor.hash);
-  }
-  async writer() {
-    const writer = this.db.core.writer();
-    const ptrPos = await this.db.core.length();
-    await this.db.core.seek(ptrPos);
-    await writer.writeLong(0);
-    const startPosition = await this.db.core.length();
-    return new Writer(this, 0, new Slot(ptrPos, 6 /* BYTES */), startPosition, 0);
-  }
-  async* [Symbol.asyncIterator]() {
-    const iterator = await this.iterator();
-    while (await iterator.hasNext()) {
-      const next = await iterator.next();
-      if (next !== null) {
-        yield next;
-      }
-    }
-  }
-  async iterator() {
-    const iterator = new WriteCursorIterator(this);
-    await iterator.init();
-    return iterator;
-  }
-}
-
-class Writer {
-  parent;
-  size;
-  slot;
-  startPosition;
-  relativePosition;
-  formatTag = null;
-  constructor(parent, size, slot, startPosition, relativePosition) {
-    this.parent = parent;
-    this.size = size;
-    this.slot = slot;
-    this.startPosition = startPosition;
-    this.relativePosition = relativePosition;
-  }
-  async write(buffer) {
-    if (this.size < this.relativePosition)
-      throw new EndOfStreamException;
-    await this.parent.db.core.seek(this.startPosition + this.relativePosition);
-    const writer = this.parent.db.core.writer();
-    await writer.write(buffer);
-    this.relativePosition += buffer.length;
-    if (this.relativePosition > this.size) {
-      this.size = this.relativePosition;
-    }
-  }
-  async finish() {
-    const writer = this.parent.db.core.writer();
-    if (this.formatTag !== null) {
-      this.slot = this.slot.withFull(true);
-      const formatTagPos = await this.parent.db.core.length();
-      await this.parent.db.core.seek(formatTagPos);
-      if (this.startPosition + this.size !== formatTagPos)
-        throw new UnexpectedWriterPositionException;
-      await writer.write(this.formatTag);
-    }
-    await this.parent.db.core.seek(Number(this.slot.value));
-    await writer.writeLong(this.size);
-    if (this.parent.slotPtr.position === null)
-      throw new CursorNotWriteableException;
-    const position = this.parent.slotPtr.position;
-    await this.parent.db.core.seek(position);
-    await writer.write(this.slot.toBytes());
-    this.parent.slotPtr = this.parent.slotPtr.withSlot(this.slot);
-  }
-  seek(position) {
-    if (position <= this.size) {
-      this.relativePosition = position;
-    }
-  }
-}
-
-class WriteCursorIterator extends CursorIterator {
-  constructor(cursor) {
-    super(cursor);
-  }
-  async next() {
-    const readCursor = await super.next();
-    if (readCursor !== null) {
-      return new WriteCursor(readCursor.slotPtr, readCursor.db);
-    } else {
-      return null;
-    }
-  }
-}
-
-// src/database.ts
-var VERSION = 0;
-var MAGIC_NUMBER = new Uint8Array([120, 105, 116]);
-var BIT_COUNT = 4;
-var SLOT_COUNT = 1 << BIT_COUNT;
-var MASK = BigInt(SLOT_COUNT - 1);
-var INDEX_BLOCK_SIZE = Slot.LENGTH * SLOT_COUNT;
-var LINKED_ARRAY_LIST_SLOT_LENGTH = 8 + Slot.LENGTH;
-var LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE = LINKED_ARRAY_LIST_SLOT_LENGTH * SLOT_COUNT;
-var MAX_BRANCH_LENGTH = 16;
-var WriteMode;
-((WriteMode2) => {
-  WriteMode2[WriteMode2["READ_ONLY"] = 0] = "READ_ONLY";
-  WriteMode2[WriteMode2["READ_WRITE"] = 1] = "READ_WRITE";
-})(WriteMode ||= {});
-
-class Header {
-  hashId;
-  hashSize;
-  version;
-  tag;
-  magicNumber;
-  static LENGTH = 12;
-  constructor(hashId, hashSize, version, tag, magicNumber) {
-    this.hashId = hashId;
-    this.hashSize = hashSize;
-    this.version = version;
-    this.tag = tag;
-    this.magicNumber = magicNumber;
-  }
-  toBytes() {
-    const buffer = new ArrayBuffer(Header.LENGTH);
-    const view = new DataView(buffer);
-    const arr = new Uint8Array(buffer);
-    arr.set(this.magicNumber, 0);
-    view.setUint8(3, this.tag);
-    view.setInt16(4, this.version, false);
-    view.setInt16(6, this.hashSize, false);
-    view.setInt32(8, this.hashId, false);
-    return arr;
-  }
-  static async read(core) {
-    const reader = core.reader();
-    const magicNumber = new Uint8Array(3);
-    await reader.readFully(magicNumber);
-    const tagByte = await reader.readByte();
-    const tag = tagValueOf(tagByte & 127);
-    const version = await reader.readShort();
-    const hashSize = await reader.readShort();
-    const hashId = await reader.readInt();
-    return new Header(hashId, hashSize, version, tag, magicNumber);
-  }
-  async write(core) {
-    const writer = core.writer();
-    await writer.write(this.toBytes());
-  }
-  validate() {
-    if (!arraysEqual(this.magicNumber, MAGIC_NUMBER)) {
-      throw new InvalidDatabaseException;
-    }
-    if (this.version > VERSION) {
-      throw new InvalidVersionException;
-    }
-  }
-  withTag(tag) {
-    return new Header(this.hashId, this.hashSize, this.version, tag, this.magicNumber);
-  }
-}
-
-class ArrayListHeader {
-  ptr;
-  size;
-  static LENGTH = 16;
-  constructor(ptr, size) {
-    this.ptr = ptr;
-    this.size = size;
-  }
-  toBytes() {
-    const buffer = new ArrayBuffer(ArrayListHeader.LENGTH);
-    const view = new DataView(buffer);
-    view.setBigInt64(0, BigInt(this.size), false);
-    view.setBigInt64(8, BigInt(this.ptr), false);
-    return new Uint8Array(buffer);
-  }
-  static fromBytes(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const size = Number(view.getBigInt64(0, false));
-    checkLong(size);
-    const ptr = Number(view.getBigInt64(8, false));
-    checkLong(ptr);
-    return new ArrayListHeader(ptr, size);
-  }
-  withPtr(ptr) {
-    return new ArrayListHeader(ptr, this.size);
-  }
-}
-
-class TopLevelArrayListHeader {
-  fileSize;
-  parent;
-  static LENGTH = 8 + ArrayListHeader.LENGTH;
-  constructor(fileSize, parent) {
-    this.fileSize = fileSize;
-    this.parent = parent;
-  }
-  toBytes() {
-    const buffer = new ArrayBuffer(TopLevelArrayListHeader.LENGTH);
-    const view = new DataView(buffer);
-    const arr = new Uint8Array(buffer);
-    arr.set(this.parent.toBytes(), 0);
-    view.setBigInt64(ArrayListHeader.LENGTH, BigInt(this.fileSize), false);
-    return arr;
-  }
-}
-
-class LinkedArrayListHeader {
-  shift;
-  ptr;
-  size;
-  static LENGTH = 17;
-  constructor(shift, ptr, size) {
-    this.shift = shift;
-    this.ptr = ptr;
-    this.size = size;
-  }
-  toBytes() {
-    const buffer = new ArrayBuffer(LinkedArrayListHeader.LENGTH);
-    const view = new DataView(buffer);
-    view.setBigInt64(0, BigInt(this.size), false);
-    view.setBigInt64(8, BigInt(this.ptr), false);
-    view.setUint8(16, this.shift & 63);
-    return new Uint8Array(buffer);
-  }
-  static fromBytes(bytes) {
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const size = Number(view.getBigInt64(0, false));
-    checkLong(size);
-    const ptr = Number(view.getBigInt64(8, false));
-    checkLong(ptr);
-    const shift = view.getUint8(16) & 63;
-    return new LinkedArrayListHeader(shift, ptr, size);
-  }
-  withPtr(ptr) {
-    return new LinkedArrayListHeader(this.shift, ptr, this.size);
-  }
-}
-
-class KeyValuePair {
-  valueSlot;
-  keySlot;
-  hash;
-  constructor(valueSlot, keySlot, hash) {
-    this.valueSlot = valueSlot;
-    this.keySlot = keySlot;
-    this.hash = hash;
-  }
-  static length(hashSize) {
-    return hashSize + Slot.LENGTH * 2;
-  }
-  toBytes() {
-    const buffer = new Uint8Array(KeyValuePair.length(this.hash.length));
-    buffer.set(this.hash, 0);
-    buffer.set(this.keySlot.toBytes(), this.hash.length);
-    buffer.set(this.valueSlot.toBytes(), this.hash.length + Slot.LENGTH);
-    return buffer;
-  }
-  static fromBytes(bytes, hashSize) {
-    const hash = bytes.slice(0, hashSize);
-    const keySlotBytes = bytes.slice(hashSize, hashSize + Slot.LENGTH);
-    const keySlot = Slot.fromBytes(keySlotBytes);
-    const valueSlotBytes = bytes.slice(hashSize + Slot.LENGTH, hashSize + Slot.LENGTH * 2);
-    const valueSlot = Slot.fromBytes(valueSlotBytes);
-    return new KeyValuePair(valueSlot, keySlot, hash);
-  }
-}
-
-class LinkedArrayListSlot2 {
-  size;
-  slot;
-  static LENGTH = 8 + Slot.LENGTH;
-  constructor(size, slot) {
-    this.size = size;
-    this.slot = slot;
-  }
-  withSize(size) {
-    return new LinkedArrayListSlot2(size, this.slot);
-  }
-  toBytes() {
-    const buffer = new ArrayBuffer(LinkedArrayListSlot2.LENGTH);
-    const view = new DataView(buffer);
-    const arr = new Uint8Array(buffer);
-    arr.set(this.slot.toBytes(), 0);
-    view.setBigInt64(Slot.LENGTH, BigInt(this.size), false);
-    return arr;
-  }
-  static fromBytes(bytes) {
-    const slotBytes = bytes.slice(0, Slot.LENGTH);
-    const slot = Slot.fromBytes(slotBytes);
-    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const size = Number(view.getBigInt64(Slot.LENGTH, false));
-    checkLong(size);
-    return new LinkedArrayListSlot2(size, slot);
-  }
-}
-
-class LinkedArrayListSlotPointer {
-  slotPtr;
-  leafCount;
-  constructor(slotPtr, leafCount) {
-    this.slotPtr = slotPtr;
-    this.leafCount = leafCount;
-  }
-  withSlotPointer(slotPtr) {
-    return new LinkedArrayListSlotPointer(slotPtr, this.leafCount);
-  }
-}
-
-class LinkedArrayListBlockInfo {
-  block;
-  i;
-  parentSlot;
-  constructor(block, i, parentSlot) {
-    this.block = block;
-    this.i = i;
-    this.parentSlot = parentSlot;
-  }
-}
-
-class HashMapGetKVPair {
-  hash;
-  kind = "kv_pair";
-  constructor(hash) {
-    this.hash = hash;
-  }
-}
-
-class HashMapGetKey {
-  hash;
-  kind = "key";
-  constructor(hash) {
-    this.hash = hash;
-  }
-}
-
-class HashMapGetValue {
-  hash;
-  kind = "value";
-  constructor(hash) {
-    this.hash = hash;
-  }
-}
-
-class ArrayListInit {
-  kind = "ArrayListInit";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (isTopLevel) {
-      const writer = db.core.writer();
-      if (db.header.tag === 0 /* NONE */) {
-        await db.core.seek(Header.LENGTH);
-        const arrayListPtr = Header.LENGTH + TopLevelArrayListHeader.LENGTH;
-        await writer.write(new TopLevelArrayListHeader(0, new ArrayListHeader(arrayListPtr, 0)).toBytes());
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        await db.core.seek(0);
-        db.header = db.header.withTag(2 /* ARRAY_LIST */);
-        await writer.write(db.header.toBytes());
-      }
-      const nextSlotPtr = slotPtr.withSlot(slotPtr.slot.withTag(2 /* ARRAY_LIST */));
-      return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-    }
-    if (slotPtr.position === null)
-      throw new CursorNotWriteableException;
-    const position = slotPtr.position;
-    switch (slotPtr.slot.tag) {
-      case 0 /* NONE */: {
-        const writer = db.core.writer();
-        let arrayListStart = await db.core.length();
-        await db.core.seek(arrayListStart);
-        const arrayListPtr = arrayListStart + ArrayListHeader.LENGTH;
-        await writer.write(new ArrayListHeader(arrayListPtr, 0).toBytes());
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 2 /* ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
-        return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-      }
-      case 2 /* ARRAY_LIST */: {
-        const reader = db.core.reader();
-        const writer = db.core.writer();
-        let arrayListStart = Number(slotPtr.slot.value);
-        if (db.txStart !== null) {
-          if (arrayListStart < db.txStart) {
-            await db.core.seek(arrayListStart);
-            const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-            await reader.readFully(headerBytes);
-            const header = ArrayListHeader.fromBytes(headerBytes);
-            await db.core.seek(header.ptr);
-            const arrayListIndexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-            await reader.readFully(arrayListIndexBlock);
-            arrayListStart = await db.core.length();
-            await db.core.seek(arrayListStart);
-            const nextArrayListPtr = arrayListStart + ArrayListHeader.LENGTH;
-            const newHeader = header.withPtr(nextArrayListPtr);
-            await writer.write(newHeader.toBytes());
-            await writer.write(arrayListIndexBlock);
-          }
-        } else if (db.header.tag === 2 /* ARRAY_LIST */) {
-          throw new ExpectedTxStartException;
-        }
-        const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 2 /* ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
-        return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-}
-
-class ArrayListGet2 {
-  index;
-  kind = "ArrayListGet";
-  constructor(index) {
-    this.index = index;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    const tag = isTopLevel ? db.header.tag : slotPtr.slot.tag;
-    switch (tag) {
-      case 0 /* NONE */:
-        throw new KeyNotFoundException;
-      case 2 /* ARRAY_LIST */:
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    let index = this.index;
-    await db.core.seek(nextArrayListStart);
-    const reader = db.core.reader();
-    const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const header = ArrayListHeader.fromBytes(headerBytes);
-    if (index >= header.size || index < -header.size) {
-      throw new KeyNotFoundException;
-    }
-    const key = index < 0 ? header.size - Math.abs(index) : index;
-    const lastKey = header.size - 1;
-    const shift = lastKey < SLOT_COUNT ? 0 : Math.floor(Math.log(lastKey) / Math.log(SLOT_COUNT));
-    const finalSlotPtr = await db.readArrayListSlot(header.ptr, key, shift, writeMode, isTopLevel);
-    return db.readSlotPointer(writeMode, path, pathI + 1, finalSlotPtr);
-  }
-}
-
-class ArrayListAppend {
-  kind = "ArrayListAppend";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    const tag = isTopLevel ? db.header.tag : slotPtr.slot.tag;
-    if (tag !== 2 /* ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    const reader = db.core.reader();
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
-    const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const origHeader = ArrayListHeader.fromBytes(headerBytes);
-    const appendResult = await db.readArrayListSlotAppend(origHeader, writeMode, isTopLevel);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, appendResult.slotPtr);
-    const writer = db.core.writer();
-    if (isTopLevel) {
-      await db.core.flush();
-      const fileSize = await db.core.length();
-      const header = new TopLevelArrayListHeader(fileSize, appendResult.header);
-      await db.core.seek(nextArrayListStart);
-      await writer.write(header.toBytes());
-    } else {
-      await db.core.seek(nextArrayListStart);
-      await writer.write(appendResult.header.toBytes());
-    }
-    return finalSlotPtr;
-  }
-}
-
-class ArrayListSlice {
-  size;
-  kind = "ArrayListSlice";
-  constructor(size) {
-    this.size = size;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (slotPtr.slot.tag !== 2 /* ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    const reader = db.core.reader();
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
-    const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const origHeader = ArrayListHeader.fromBytes(headerBytes);
-    const sliceHeader = await db.readArrayListSlice(origHeader, this.size);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
-    const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(sliceHeader.toBytes());
-    return finalSlotPtr;
-  }
-}
-
-class LinkedArrayListInit {
-  kind = "LinkedArrayListInit";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (isTopLevel)
-      throw new InvalidTopLevelTypeException;
-    if (slotPtr.position === null)
-      throw new CursorNotWriteableException;
-    const position = slotPtr.position;
-    switch (slotPtr.slot.tag) {
-      case 0 /* NONE */: {
-        const writer = db.core.writer();
-        const arrayListStart = await db.core.length();
-        await db.core.seek(arrayListStart);
-        const arrayListPtr = arrayListStart + LinkedArrayListHeader.LENGTH;
-        await writer.write(new LinkedArrayListHeader(0, arrayListPtr, 0).toBytes());
-        await writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
-        const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 3 /* LINKED_ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
-        return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-      }
-      case 3 /* LINKED_ARRAY_LIST */: {
-        const reader = db.core.reader();
-        const writer = db.core.writer();
-        let arrayListStart = Number(slotPtr.slot.value);
-        if (db.txStart !== null) {
-          if (arrayListStart < db.txStart) {
-            await db.core.seek(arrayListStart);
-            const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-            await reader.readFully(headerBytes);
-            const header = LinkedArrayListHeader.fromBytes(headerBytes);
-            await db.core.seek(header.ptr);
-            const arrayListIndexBlock = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-            await reader.readFully(arrayListIndexBlock);
-            arrayListStart = await db.core.length();
-            await db.core.seek(arrayListStart);
-            const nextArrayListPtr = arrayListStart + LinkedArrayListHeader.LENGTH;
-            const newHeader = header.withPtr(nextArrayListPtr);
-            await writer.write(newHeader.toBytes());
-            await writer.write(arrayListIndexBlock);
-          }
-        } else if (db.header.tag === 2 /* ARRAY_LIST */) {
-          throw new ExpectedTxStartException;
-        }
-        const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 3 /* LINKED_ARRAY_LIST */));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
-        return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-}
-
-class LinkedArrayListGet {
-  index;
-  kind = "LinkedArrayListGet";
-  constructor(index) {
-    this.index = index;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    switch (slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        throw new KeyNotFoundException;
-      case 3 /* LINKED_ARRAY_LIST */:
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-    let index = this.index;
-    await db.core.seek(Number(slotPtr.slot.value));
-    const reader = db.core.reader();
-    const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const header = LinkedArrayListHeader.fromBytes(headerBytes);
-    if (index >= header.size || index < -header.size) {
-      throw new KeyNotFoundException;
-    }
-    const key = index < 0 ? header.size - Math.abs(index) : index;
-    const finalSlotPtr = await db.readLinkedArrayListSlot(header.ptr, key, header.shift, writeMode, isTopLevel);
-    return db.readSlotPointer(writeMode, path, pathI + 1, finalSlotPtr.slotPtr);
-  }
-}
-
-class LinkedArrayListAppend {
-  kind = "LinkedArrayListAppend";
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    const reader = db.core.reader();
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
-    const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
-    const appendResult = await db.readLinkedArrayListSlotAppend(origHeader, writeMode, isTopLevel);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, appendResult.slotPtr.slotPtr);
-    const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(appendResult.header.toBytes());
-    return finalSlotPtr;
-  }
-}
-
-class LinkedArrayListSlice {
-  offset;
-  size;
-  kind = "LinkedArrayListSlice";
-  constructor(offset, size) {
-    this.offset = offset;
-    this.size = size;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    const reader = db.core.reader();
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
-    const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
-    const sliceHeader = await db.readLinkedArrayListSlice(origHeader, this.offset, this.size);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
-    const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(sliceHeader.toBytes());
-    return finalSlotPtr;
-  }
-}
-
-class LinkedArrayListConcat {
-  list;
-  kind = "LinkedArrayListConcat";
-  constructor(list) {
-    this.list = list;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    if (this.list.tag !== 3 /* LINKED_ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    const reader = db.core.reader();
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
-    const headerBytesA = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytesA);
-    const headerA = LinkedArrayListHeader.fromBytes(headerBytesA);
-    await db.core.seek(Number(this.list.value));
-    const headerBytesB = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytesB);
-    const headerB = LinkedArrayListHeader.fromBytes(headerBytesB);
-    const concatHeader = await db.readLinkedArrayListConcat(headerA, headerB);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, slotPtr);
-    const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(concatHeader.toBytes());
-    return finalSlotPtr;
-  }
-}
-
-class LinkedArrayListInsert {
-  index;
-  kind = "LinkedArrayListInsert";
-  constructor(index) {
-    this.index = index;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    const reader = db.core.reader();
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
-    const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
-    let index = this.index;
-    if (index >= origHeader.size || index < -origHeader.size) {
-      throw new KeyNotFoundException;
-    }
-    const key = index < 0 ? origHeader.size - Math.abs(index) : index;
-    const headerA = await db.readLinkedArrayListSlice(origHeader, 0, key);
-    const headerB = await db.readLinkedArrayListSlice(origHeader, key, origHeader.size - key);
-    const appendResult = await db.readLinkedArrayListSlotAppend(headerA, writeMode, isTopLevel);
-    const concatHeader = await db.readLinkedArrayListConcat(appendResult.header, headerB);
-    const nextSlotPtr = await db.readLinkedArrayListSlot(concatHeader.ptr, key, concatHeader.shift, 0 /* READ_ONLY */, isTopLevel);
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr.slotPtr);
-    const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(concatHeader.toBytes());
-    return finalSlotPtr;
-  }
-}
-
-class LinkedArrayListRemove {
-  index;
-  kind = "LinkedArrayListRemove";
-  constructor(index) {
-    this.index = index;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    const reader = db.core.reader();
-    const nextArrayListStart = Number(slotPtr.slot.value);
-    await db.core.seek(nextArrayListStart);
-    const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-    await reader.readFully(headerBytes);
-    const origHeader = LinkedArrayListHeader.fromBytes(headerBytes);
-    let index = this.index;
-    if (index >= origHeader.size || index < -origHeader.size) {
-      throw new KeyNotFoundException;
-    }
-    const key = index < 0 ? origHeader.size - Math.abs(index) : index;
-    const headerA = await db.readLinkedArrayListSlice(origHeader, 0, key);
-    const headerB = await db.readLinkedArrayListSlice(origHeader, key + 1, origHeader.size - (key + 1));
-    const concatHeader = await db.readLinkedArrayListConcat(headerA, headerB);
-    const nextSlotPtr = new SlotPointer(concatHeader.ptr, new Slot(nextArrayListStart, 3 /* LINKED_ARRAY_LIST */));
-    const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-    const writer = db.core.writer();
-    await db.core.seek(nextArrayListStart);
-    await writer.write(concatHeader.toBytes());
-    return finalSlotPtr;
-  }
-}
-
-class HashMapInit {
-  counted;
-  set;
-  kind = "HashMapInit";
-  constructor(counted = false, set = false) {
-    this.counted = counted;
-    this.set = set;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    const tag = this.counted ? this.set ? 13 /* COUNTED_HASH_SET */ : 12 /* COUNTED_HASH_MAP */ : this.set ? 11 /* HASH_SET */ : 4 /* HASH_MAP */;
-    if (isTopLevel) {
-      const writer = db.core.writer();
-      if (db.header.tag === 0 /* NONE */) {
-        await db.core.seek(Header.LENGTH);
-        if (this.counted) {
-          await writer.writeLong(0);
-        }
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        await db.core.seek(0);
-        db.header = db.header.withTag(tag);
-        await writer.write(db.header.toBytes());
-      }
-      const nextSlotPtr = slotPtr.withSlot(slotPtr.slot.withTag(tag));
-      return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-    }
-    if (slotPtr.position === null)
-      throw new CursorNotWriteableException;
-    const position = slotPtr.position;
-    switch (slotPtr.slot.tag) {
-      case 0 /* NONE */: {
-        const writer = db.core.writer();
-        const mapStart = await db.core.length();
-        await db.core.seek(mapStart);
-        if (this.counted) {
-          await writer.writeLong(0);
-        }
-        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        const nextSlotPtr = new SlotPointer(position, new Slot(mapStart, tag));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
-        return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-      }
-      case 4 /* HASH_MAP */:
-      case 11 /* HASH_SET */:
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */: {
-        if (this.counted) {
-          switch (slotPtr.slot.tag) {
-            case 12 /* COUNTED_HASH_MAP */:
-            case 13 /* COUNTED_HASH_SET */:
-              break;
-            default:
-              throw new UnexpectedTagException;
-          }
-        } else {
-          switch (slotPtr.slot.tag) {
-            case 4 /* HASH_MAP */:
-            case 11 /* HASH_SET */:
-              break;
-            default:
-              throw new UnexpectedTagException;
-          }
-        }
-        const reader = db.core.reader();
-        const writer = db.core.writer();
-        let mapStart = Number(slotPtr.slot.value);
-        if (db.txStart !== null) {
-          if (mapStart < db.txStart) {
-            await db.core.seek(mapStart);
-            let mapCountMaybe = null;
-            if (this.counted) {
-              mapCountMaybe = await reader.readLong();
-            }
-            const mapIndexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-            await reader.readFully(mapIndexBlock);
-            mapStart = await db.core.length();
-            await db.core.seek(mapStart);
-            if (mapCountMaybe !== null) {
-              await writer.writeLong(mapCountMaybe);
-            }
-            await writer.write(mapIndexBlock);
-          }
-        } else if (db.header.tag === 2 /* ARRAY_LIST */) {
-          throw new ExpectedTxStartException;
-        }
-        const nextSlotPtr = new SlotPointer(position, new Slot(mapStart, tag));
-        await db.core.seek(position);
-        await writer.write(nextSlotPtr.slot.toBytes());
-        return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-}
-
-class HashMapGet {
-  target;
-  kind = "HashMapGet";
-  constructor(target) {
-    this.target = target;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    let counted = false;
-    switch (slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        throw new KeyNotFoundException;
-      case 4 /* HASH_MAP */:
-      case 11 /* HASH_SET */:
-        break;
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */:
-        counted = true;
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-    const indexPos = counted ? Number(slotPtr.slot.value) + 8 : Number(slotPtr.slot.value);
-    const hash = db.checkHash(this.target);
-    const res = await db.readMapSlot(indexPos, hash, 0, writeMode, isTopLevel, this.target);
-    if (writeMode === 1 /* READ_WRITE */ && counted && res.isEmpty) {
-      const reader = db.core.reader();
-      const writer = db.core.writer();
-      await db.core.seek(Number(slotPtr.slot.value));
-      const mapCount = await reader.readLong();
-      await db.core.seek(Number(slotPtr.slot.value));
-      await writer.writeLong(mapCount + 1);
-    }
-    return db.readSlotPointer(writeMode, path, pathI + 1, res.slotPtr);
-  }
-}
-
-class HashMapRemove {
-  hash;
-  kind = "HashMapRemove";
-  constructor(hash) {
-    this.hash = hash;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    let counted = false;
-    switch (slotPtr.slot.tag) {
-      case 0 /* NONE */:
-        throw new KeyNotFoundException;
-      case 4 /* HASH_MAP */:
-      case 11 /* HASH_SET */:
-        break;
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */:
-        counted = true;
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-    const indexPos = counted ? Number(slotPtr.slot.value) + 8 : Number(slotPtr.slot.value);
-    const hash = db.checkHashBytes(this.hash);
-    let keyFound = true;
-    try {
-      await db.removeMapSlot(indexPos, hash, 0, isTopLevel);
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        keyFound = false;
-      } else {
-        throw e;
-      }
-    }
-    if (writeMode === 1 /* READ_WRITE */ && counted && keyFound) {
-      const reader = db.core.reader();
-      const writer = db.core.writer();
-      await db.core.seek(Number(slotPtr.slot.value));
-      const mapCount = await reader.readLong();
-      await db.core.seek(Number(slotPtr.slot.value));
-      await writer.writeLong(mapCount - 1);
-    }
-    if (!keyFound)
-      throw new KeyNotFoundException;
-    return slotPtr;
-  }
-}
-
-class WriteData {
-  data;
-  kind = "WriteData";
-  constructor(data) {
-    this.data = data;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (slotPtr.position === null)
-      throw new CursorNotWriteableException;
-    const position = slotPtr.position;
-    const writer = db.core.writer();
-    const data = this.data;
-    let slot;
-    if (data === null) {
-      slot = new Slot;
-    } else if (data instanceof Slot) {
-      slot = data;
-    } else if (data instanceof Uint) {
-      slot = new Slot(data.value, 8 /* UINT */);
-    } else if (data instanceof Int) {
-      slot = new Slot(data.value, 9 /* INT */);
-    } else if (data instanceof Float) {
-      const buffer = new ArrayBuffer(8);
-      const view = new DataView(buffer);
-      view.setFloat64(0, data.value, false);
-      const longValue = view.getBigInt64(0, false);
-      slot = new Slot(longValue, 10 /* FLOAT */);
-    } else if (data instanceof Bytes) {
-      if (data.isShort()) {
-        const buffer = new Uint8Array(8);
-        buffer.set(data.value, 0);
-        if (data.formatTag !== null) {
-          buffer.set(data.formatTag, 6);
-        }
-        const view = new DataView(buffer.buffer);
-        const longValue = view.getBigInt64(0, false);
-        slot = new Slot(longValue, 7 /* SHORT_BYTES */, data.formatTag !== null);
-      } else {
-        const nextCursor = new WriteCursor(slotPtr, db);
-        const cursorWriter = await nextCursor.writer();
-        cursorWriter.formatTag = data.formatTag;
-        await cursorWriter.write(data.value);
-        await cursorWriter.finish();
-        slot = cursorWriter.slot;
-      }
-    } else {
-      throw new Error("Unknown data type");
-    }
-    if (slot.tag === 0 /* NONE */) {
-      slot = slot.withFull(true);
-    }
-    await db.core.seek(position);
-    await writer.write(slot.toBytes());
-    const nextSlotPtr = new SlotPointer(slotPtr.position, slot);
-    return db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
-  }
-}
-
-class Context {
-  fn;
-  kind = "Context";
-  constructor(fn) {
-    this.fn = fn;
-  }
-  async readSlotPointer(db, isTopLevel, writeMode, path, pathI, slotPtr) {
-    if (writeMode === 0 /* READ_ONLY */)
-      throw new WriteNotAllowedException;
-    if (pathI !== path.length - 1)
-      throw new PathPartMustBeAtEndException;
-    const nextCursor = new WriteCursor(slotPtr, db);
-    try {
-      await this.fn(nextCursor);
-    } catch (e) {
-      try {
-        await db.truncate();
-      } catch (_) {}
-      throw e;
-    }
-    return nextCursor.slotPtr;
-  }
-}
-
-class HashMapGetResult {
-  slotPtr;
-  isEmpty;
-  constructor(slotPtr, isEmpty) {
-    this.slotPtr = slotPtr;
-    this.isEmpty = isEmpty;
-  }
-}
-
-class ArrayListAppendResult {
-  header;
-  slotPtr;
-  constructor(header, slotPtr) {
-    this.header = header;
-    this.slotPtr = slotPtr;
-  }
-}
-
-class LinkedArrayListAppendResult {
-  header;
-  slotPtr;
-  constructor(header, slotPtr) {
-    this.header = header;
-    this.slotPtr = slotPtr;
-  }
-}
-function arraysEqual(a, b) {
-  if (a.length !== b.length)
-    return false;
-  for (let i = 0;i < a.length; i++) {
-    if (a[i] !== b[i])
-      return false;
-  }
-  return true;
-}
-function checkLong(n) {
-  if (n < 0) {
-    throw new ExpectedUnsignedLongException;
-  }
-  return n;
-}
-function bigIntShiftRight(value, bits) {
-  let result = 0n;
-  for (let i = 0;i < value.length; i++) {
-    result = result << 8n | BigInt(value[i]);
-  }
-  return result >> BigInt(bits);
-}
-
-class Database3 {
-  core;
-  hasher;
-  header;
-  txStart = null;
-  constructor(core, hasher) {
-    this.core = core;
-    this.hasher = hasher;
-  }
-  static async create(core, hasher) {
-    const db = new Database3(core, hasher);
-    await core.seek(0);
-    if (await core.length() === 0) {
-      db.header = new Header(hasher.id, hasher.digestLength, VERSION, 0 /* NONE */, MAGIC_NUMBER);
-      await db.header.write(core);
-      await core.flush();
-    } else {
-      db.header = await Header.read(core);
-      db.header.validate();
-      if (db.header.hashSize !== hasher.digestLength) {
-        throw new InvalidHashSizeException;
-      }
-      await db.truncate();
-    }
-    return db;
-  }
-  rootCursor() {
-    return new WriteCursor(new SlotPointer(null, new Slot(Header.LENGTH, this.header.tag)), this);
-  }
-  async freeze() {
-    if (this.txStart !== null) {
-      this.txStart = await this.core.length();
-    } else {
-      throw new ExpectedTxStartException;
-    }
-  }
-  async compact(targetCore) {
-    const offsetMap = new Map;
-    const hasher = new Hasher(this.hasher.algorithm, this.header.hashId);
-    const target = await Database3.create(targetCore, hasher);
-    if (this.header.tag === 0 /* NONE */)
-      return target;
-    if (this.header.tag !== 2 /* ARRAY_LIST */)
-      throw new UnexpectedTagException;
-    await this.core.seek(Header.LENGTH);
-    const sourceReader = this.core.reader();
-    const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-    await sourceReader.readFully(headerBytes);
-    const sourceHeader = ArrayListHeader.fromBytes(headerBytes);
-    if (sourceHeader.size === 0)
-      return target;
-    const lastKey = sourceHeader.size - 1;
-    const shift = lastKey < SLOT_COUNT ? 0 : Math.floor(Math.log(lastKey) / Math.log(SLOT_COUNT));
-    const lastSlotPtr = await this.readArrayListSlot(sourceHeader.ptr, lastKey, shift, 0 /* READ_ONLY */, true);
-    const momentSlot = lastSlotPtr.slot;
-    const targetWriter = targetCore.writer();
-    await targetCore.seek(Header.LENGTH);
-    const targetArrayListPtr = Header.LENGTH + TopLevelArrayListHeader.LENGTH;
-    await targetWriter.write(new TopLevelArrayListHeader(0, new ArrayListHeader(targetArrayListPtr, 1)).toBytes());
-    await targetWriter.write(new Uint8Array(INDEX_BLOCK_SIZE));
-    const remappedMoment = await remapSlot(this.core, targetCore, this.header.hashSize, offsetMap, momentSlot);
-    await targetCore.seek(targetArrayListPtr);
-    await targetWriter.write(remappedMoment.toBytes());
-    target.header = target.header.withTag(2 /* ARRAY_LIST */);
-    await targetCore.seek(0);
-    await target.header.write(targetCore);
-    await targetCore.flush();
-    const fileSize = await targetCore.length();
-    await targetCore.seek(Header.LENGTH + ArrayListHeader.LENGTH);
-    await targetWriter.writeLong(fileSize);
-    await targetCore.flush();
-    return target;
-  }
-  async truncate() {
-    if (this.header.tag !== 2 /* ARRAY_LIST */)
-      return;
-    const rootCursor = this.rootCursor();
-    const listSize = await rootCursor.count();
-    if (listSize === 0)
-      return;
-    await this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
-    const reader = this.core.reader();
-    const headerFileSize = await reader.readLong();
-    if (headerFileSize === 0)
-      return;
-    const fileSize = await this.core.length();
-    if (fileSize === headerFileSize)
-      return;
-    try {
-      await this.core.setLength(headerFileSize);
-    } catch (_) {}
-  }
-  checkHashBytes(hash) {
-    if (hash.length !== this.header.hashSize) {
-      throw new InvalidHashSizeException;
-    }
-    return hash;
-  }
-  checkHash(target) {
-    return this.checkHashBytes(target.hash);
-  }
-  async readSlotPointer(writeMode, path, pathI, slotPtr) {
-    if (pathI === path.length) {
-      if (writeMode === 0 /* READ_ONLY */ && slotPtr.slot.tag === 0 /* NONE */) {
-        throw new KeyNotFoundException;
-      }
-      return slotPtr;
-    }
-    const part = path[pathI];
-    const isTopLevel = slotPtr.slot.value === BigInt(Header.LENGTH);
-    const isTxStart = isTopLevel && this.header.tag === 2 /* ARRAY_LIST */ && this.txStart === null;
-    if (isTxStart) {
-      this.txStart = await this.core.length();
-    }
-    try {
-      return await part.readSlotPointer(this, isTopLevel, writeMode, path, pathI, slotPtr);
-    } finally {
-      if (isTxStart) {
-        this.txStart = null;
-      }
-    }
-  }
-  async readMapSlot(indexPos, keyHash, keyOffset, writeMode, isTopLevel, target) {
-    if (keyOffset > this.header.hashSize * 8 / BIT_COUNT) {
-      throw new KeyOffsetExceededException;
-    }
-    const reader = this.core.reader();
-    const writer = this.core.writer();
-    const i = Number(bigIntShiftRight(keyHash, keyOffset * BIT_COUNT) & MASK);
-    const slotPos = indexPos + Slot.LENGTH * i;
-    await this.core.seek(slotPos);
-    const slotBytes = new Uint8Array(Slot.LENGTH);
-    await reader.readFully(slotBytes);
-    const slot = Slot.fromBytes(slotBytes);
-    const ptr = Number(slot.value);
-    switch (slot.tag) {
-      case 0 /* NONE */: {
-        switch (writeMode) {
-          case 0 /* READ_ONLY */:
-            throw new KeyNotFoundException;
-          case 1 /* READ_WRITE */: {
-            const hashPos = await this.core.length();
-            await this.core.seek(hashPos);
-            const keySlotPos = hashPos + this.header.hashSize;
-            const valueSlotPos = keySlotPos + Slot.LENGTH;
-            const kvPair = new KeyValuePair(new Slot, new Slot, keyHash);
-            await writer.write(kvPair.toBytes());
-            const nextSlot = new Slot(hashPos, 5 /* KV_PAIR */);
-            await this.core.seek(slotPos);
-            await writer.write(nextSlot.toBytes());
-            let nextSlotPtr;
-            if (target.kind === "kv_pair") {
-              nextSlotPtr = new SlotPointer(slotPos, nextSlot);
-            } else if (target.kind === "key") {
-              nextSlotPtr = new SlotPointer(keySlotPos, kvPair.keySlot);
-            } else {
-              nextSlotPtr = new SlotPointer(valueSlotPos, kvPair.valueSlot);
-            }
-            return new HashMapGetResult(nextSlotPtr, true);
-          }
-          default:
-            throw new UnreachableException;
-        }
-      }
-      case 1 /* INDEX */: {
-        let nextPtr = ptr;
-        if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
-          if (this.txStart !== null) {
-            if (nextPtr < this.txStart) {
-              await this.core.seek(ptr);
-              const indexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-              await reader.readFully(indexBlock);
-              nextPtr = await this.core.length();
-              await this.core.seek(nextPtr);
-              await writer.write(indexBlock);
-              await this.core.seek(slotPos);
-              await writer.write(new Slot(nextPtr, 1 /* INDEX */).toBytes());
-            }
-          } else if (this.header.tag === 2 /* ARRAY_LIST */) {
-            throw new ExpectedTxStartException;
-          }
-        }
-        return this.readMapSlot(nextPtr, keyHash, keyOffset + 1, writeMode, isTopLevel, target);
-      }
-      case 5 /* KV_PAIR */: {
-        await this.core.seek(ptr);
-        const kvPairBytes = new Uint8Array(KeyValuePair.length(this.header.hashSize));
-        await reader.readFully(kvPairBytes);
-        const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.header.hashSize);
-        if (arraysEqual(kvPair.hash, keyHash)) {
-          if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
-            if (this.txStart !== null) {
-              if (ptr < this.txStart) {
-                const hashPos = await this.core.length();
-                await this.core.seek(hashPos);
-                const keySlotPos2 = hashPos + this.header.hashSize;
-                const valueSlotPos2 = keySlotPos2 + Slot.LENGTH;
-                await writer.write(kvPair.toBytes());
-                const nextSlot = new Slot(hashPos, 5 /* KV_PAIR */);
-                await this.core.seek(slotPos);
-                await writer.write(nextSlot.toBytes());
-                let nextSlotPtr2;
-                if (target.kind === "kv_pair") {
-                  nextSlotPtr2 = new SlotPointer(slotPos, nextSlot);
-                } else if (target.kind === "key") {
-                  nextSlotPtr2 = new SlotPointer(keySlotPos2, kvPair.keySlot);
-                } else {
-                  nextSlotPtr2 = new SlotPointer(valueSlotPos2, kvPair.valueSlot);
-                }
-                return new HashMapGetResult(nextSlotPtr2, false);
-              }
-            } else if (this.header.tag === 2 /* ARRAY_LIST */) {
-              throw new ExpectedTxStartException;
-            }
-          }
-          const keySlotPos = ptr + this.header.hashSize;
-          const valueSlotPos = keySlotPos + Slot.LENGTH;
-          let nextSlotPtr;
-          if (target.kind === "kv_pair") {
-            nextSlotPtr = new SlotPointer(slotPos, slot);
-          } else if (target.kind === "key") {
-            nextSlotPtr = new SlotPointer(keySlotPos, kvPair.keySlot);
-          } else {
-            nextSlotPtr = new SlotPointer(valueSlotPos, kvPair.valueSlot);
-          }
-          return new HashMapGetResult(nextSlotPtr, false);
-        } else {
-          switch (writeMode) {
-            case 0 /* READ_ONLY */:
-              throw new KeyNotFoundException;
-            case 1 /* READ_WRITE */: {
-              if (keyOffset + 1 >= this.header.hashSize * 8 / BIT_COUNT) {
-                throw new KeyOffsetExceededException;
-              }
-              const nextI = Number(bigIntShiftRight(kvPair.hash, (keyOffset + 1) * BIT_COUNT) & MASK);
-              const nextIndexPos = await this.core.length();
-              await this.core.seek(nextIndexPos);
-              await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-              await this.core.seek(nextIndexPos + Slot.LENGTH * nextI);
-              await writer.write(slot.toBytes());
-              const res = await this.readMapSlot(nextIndexPos, keyHash, keyOffset + 1, writeMode, isTopLevel, target);
-              await this.core.seek(slotPos);
-              await writer.write(new Slot(nextIndexPos, 1 /* INDEX */).toBytes());
-              return res;
-            }
-            default:
-              throw new UnreachableException;
-          }
-        }
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async removeMapSlot(indexPos, keyHash, keyOffset, isTopLevel) {
-    if (keyOffset > this.header.hashSize * 8 / BIT_COUNT) {
-      throw new KeyOffsetExceededException;
-    }
-    const reader = this.core.reader();
-    const writer = this.core.writer();
-    const slotBlock = new Array(SLOT_COUNT);
-    await this.core.seek(indexPos);
-    const indexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-    await reader.readFully(indexBlock);
-    for (let i2 = 0;i2 < SLOT_COUNT; i2++) {
-      const slotBytes = indexBlock.slice(i2 * Slot.LENGTH, (i2 + 1) * Slot.LENGTH);
-      slotBlock[i2] = Slot.fromBytes(slotBytes);
-    }
-    const i = Number(bigIntShiftRight(keyHash, keyOffset * BIT_COUNT) & MASK);
-    const slotPos = indexPos + Slot.LENGTH * i;
-    const slot = slotBlock[i];
-    let nextSlot;
-    switch (slot.tag) {
-      case 0 /* NONE */:
-        throw new KeyNotFoundException;
-      case 1 /* INDEX */:
-        nextSlot = await this.removeMapSlot(Number(slot.value), keyHash, keyOffset + 1, isTopLevel);
-        break;
-      case 5 /* KV_PAIR */: {
-        await this.core.seek(Number(slot.value));
-        const kvPairBytes = new Uint8Array(KeyValuePair.length(this.header.hashSize));
-        await reader.readFully(kvPairBytes);
-        const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.header.hashSize);
-        if (arraysEqual(kvPair.hash, keyHash)) {
-          nextSlot = new Slot;
-        } else {
-          throw new KeyNotFoundException;
-        }
-        break;
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-    if (keyOffset === 0) {
-      await this.core.seek(slotPos);
-      await writer.write(nextSlot.toBytes());
-      return new Slot(indexPos, 1 /* INDEX */);
-    }
-    let slotToReturnMaybe = new Slot;
-    slotBlock[i] = nextSlot;
-    for (const blockSlot of slotBlock) {
-      if (blockSlot.tag === 0 /* NONE */)
-        continue;
-      if (slotToReturnMaybe !== null) {
-        if (slotToReturnMaybe.tag !== 0 /* NONE */) {
-          slotToReturnMaybe = null;
-          break;
-        }
-      }
-      slotToReturnMaybe = blockSlot;
-    }
-    if (slotToReturnMaybe !== null) {
-      switch (slotToReturnMaybe.tag) {
-        case 0 /* NONE */:
-        case 5 /* KV_PAIR */:
-          return slotToReturnMaybe;
-        default:
-          break;
-      }
-    }
-    if (!isTopLevel) {
-      if (this.txStart !== null) {
-        if (indexPos < this.txStart) {
-          const nextIndexPos = await this.core.length();
-          await this.core.seek(nextIndexPos);
-          await writer.write(indexBlock);
-          const nextSlotPos = nextIndexPos + Slot.LENGTH * i;
-          await this.core.seek(nextSlotPos);
-          await writer.write(nextSlot.toBytes());
-          return new Slot(nextIndexPos, 1 /* INDEX */);
-        }
-      } else if (this.header.tag === 2 /* ARRAY_LIST */) {
-        throw new ExpectedTxStartException;
-      }
-    }
-    await this.core.seek(slotPos);
-    await writer.write(nextSlot.toBytes());
-    return new Slot(indexPos, 1 /* INDEX */);
-  }
-  async readArrayListSlotAppend(header, writeMode, isTopLevel) {
-    const writer = this.core.writer();
-    let indexPos = header.ptr;
-    const key = header.size;
-    const prevShift = key < SLOT_COUNT ? 0 : Math.floor(Math.log(key - 1) / Math.log(SLOT_COUNT));
-    const nextShift = key < SLOT_COUNT ? 0 : Math.floor(Math.log(key) / Math.log(SLOT_COUNT));
-    if (prevShift !== nextShift) {
-      const nextIndexPos = await this.core.length();
-      await this.core.seek(nextIndexPos);
-      await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-      await this.core.seek(nextIndexPos);
-      await writer.write(new Slot(indexPos, 1 /* INDEX */).toBytes());
-      indexPos = nextIndexPos;
-    }
-    const slotPtr = await this.readArrayListSlot(indexPos, key, nextShift, writeMode, isTopLevel);
-    return new ArrayListAppendResult(new ArrayListHeader(indexPos, header.size + 1), slotPtr);
-  }
-  async readArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
-    if (shift >= MAX_BRANCH_LENGTH)
-      throw new MaxShiftExceededException;
-    const reader = this.core.reader();
-    const i = key >>> shift * BIT_COUNT & SLOT_COUNT - 1;
-    const slotPos = indexPos + Slot.LENGTH * i;
-    await this.core.seek(slotPos);
-    const slotBytes = new Uint8Array(Slot.LENGTH);
-    await reader.readFully(slotBytes);
-    const slot = Slot.fromBytes(slotBytes);
-    if (shift === 0) {
-      return new SlotPointer(slotPos, slot);
-    }
-    const ptr = Number(slot.value);
-    switch (slot.tag) {
-      case 0 /* NONE */: {
-        switch (writeMode) {
-          case 0 /* READ_ONLY */:
-            throw new KeyNotFoundException;
-          case 1 /* READ_WRITE */: {
-            const writer = this.core.writer();
-            const nextIndexPos = await this.core.length();
-            await this.core.seek(nextIndexPos);
-            await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-            if (isTopLevel) {
-              const fileSize = await this.core.length();
-              await this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
-              await writer.writeLong(fileSize);
-            }
-            await this.core.seek(slotPos);
-            await writer.write(new Slot(nextIndexPos, 1 /* INDEX */).toBytes());
-            return this.readArrayListSlot(nextIndexPos, key, shift - 1, writeMode, isTopLevel);
-          }
-          default:
-            throw new UnreachableException;
-        }
-      }
-      case 1 /* INDEX */: {
-        let nextPtr = ptr;
-        if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
-          if (this.txStart !== null) {
-            if (nextPtr < this.txStart) {
-              await this.core.seek(ptr);
-              const indexBlock = new Uint8Array(INDEX_BLOCK_SIZE);
-              await reader.readFully(indexBlock);
-              const writer = this.core.writer();
-              nextPtr = await this.core.length();
-              await this.core.seek(nextPtr);
-              await writer.write(indexBlock);
-              await this.core.seek(slotPos);
-              await writer.write(new Slot(nextPtr, 1 /* INDEX */).toBytes());
-            }
-          } else if (this.header.tag === 2 /* ARRAY_LIST */) {
-            throw new ExpectedTxStartException;
-          }
-        }
-        return this.readArrayListSlot(nextPtr, key, shift - 1, writeMode, isTopLevel);
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async readArrayListSlice(header, size) {
-    const reader = this.core.reader();
-    if (size > header.size || size < 0) {
-      throw new KeyNotFoundException;
-    }
-    const prevShift = header.size < SLOT_COUNT + 1 ? 0 : Math.floor(Math.log(header.size - 1) / Math.log(SLOT_COUNT));
-    const nextShift = size < SLOT_COUNT + 1 ? 0 : Math.floor(Math.log(size - 1) / Math.log(SLOT_COUNT));
-    if (prevShift === nextShift) {
-      return new ArrayListHeader(header.ptr, size);
-    } else {
-      let shift = prevShift;
-      let indexPos = header.ptr;
-      while (shift > nextShift) {
-        await this.core.seek(indexPos);
-        const slotBytes = new Uint8Array(Slot.LENGTH);
-        await reader.readFully(slotBytes);
-        const slot = Slot.fromBytes(slotBytes);
-        shift -= 1;
-        indexPos = Number(slot.value);
-      }
-      return new ArrayListHeader(indexPos, size);
-    }
-  }
-  async readLinkedArrayListSlotAppend(header, writeMode, isTopLevel) {
-    const writer = this.core.writer();
-    let ptr = header.ptr;
-    const key = header.size;
-    let shift = header.shift;
-    let slotPtr;
-    try {
-      slotPtr = await this.readLinkedArrayListSlot(ptr, key, shift, writeMode, isTopLevel);
-    } catch (e) {
-      if (e instanceof NoAvailableSlotsException) {
-        const nextPtr = await this.core.length();
-        await this.core.seek(nextPtr);
-        await writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
-        await this.core.seek(nextPtr);
-        await writer.write(new LinkedArrayListSlot2(header.size, new Slot(ptr, 1 /* INDEX */, true)).toBytes());
-        ptr = nextPtr;
-        shift += 1;
-        slotPtr = await this.readLinkedArrayListSlot(ptr, key, shift, writeMode, isTopLevel);
-      } else {
-        throw e;
-      }
-    }
-    const newSlot = new Slot(0, 0 /* NONE */, true);
-    slotPtr = slotPtr.withSlotPointer(slotPtr.slotPtr.withSlot(newSlot));
-    if (slotPtr.slotPtr.position === null)
-      throw new CursorNotWriteableException;
-    const position = slotPtr.slotPtr.position;
-    await this.core.seek(position);
-    await writer.write(new LinkedArrayListSlot2(0, newSlot).toBytes());
-    if (header.size < SLOT_COUNT && shift > 0) {
-      throw new MustSetNewSlotsToFullException;
-    }
-    return new LinkedArrayListAppendResult(new LinkedArrayListHeader(shift, ptr, header.size + 1), slotPtr);
-  }
-  static blockLeafCount(block, shift, i) {
-    let n = 0;
-    if (shift === 0) {
-      for (let blockI = 0;blockI < block.length; blockI++) {
-        const blockSlot = block[blockI];
-        if (!blockSlot.slot.empty() || blockI === i) {
-          n += 1;
-        }
-      }
-    } else {
-      for (const blockSlot of block) {
-        n += blockSlot.size;
-      }
-    }
-    return n;
-  }
-  static slotLeafCount(slot, shift) {
-    if (shift === 0) {
-      if (slot.slot.empty()) {
-        return 0;
-      } else {
-        return 1;
-      }
-    } else {
-      return slot.size;
-    }
-  }
-  static keyAndIndexForLinkedArrayList(slotBlock, key, shift) {
-    let nextKey = key;
-    let i = 0;
-    const maxLeafCount = shift === 0 ? 1 : Math.pow(SLOT_COUNT, shift);
-    while (true) {
-      const slotLeafCount = Database3.slotLeafCount(slotBlock[i], shift);
-      if (nextKey === slotLeafCount) {
-        if (slotLeafCount === maxLeafCount || slotBlock[i].slot.full) {
-          if (i < SLOT_COUNT - 1) {
-            nextKey -= slotLeafCount;
-            i += 1;
-          } else {
-            return null;
-          }
-        }
-        break;
-      } else if (nextKey < slotLeafCount) {
-        break;
-      } else if (i < SLOT_COUNT - 1) {
-        nextKey -= slotLeafCount;
-        i += 1;
-      } else {
-        return null;
-      }
-    }
-    return { key: nextKey, index: i };
-  }
-  async readLinkedArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
-    if (shift >= MAX_BRANCH_LENGTH)
-      throw new MaxShiftExceededException;
-    const reader = this.core.reader();
-    const writer = this.core.writer();
-    const slotBlock = new Array(SLOT_COUNT);
-    await this.core.seek(indexPos);
-    const indexBlock = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-    await reader.readFully(indexBlock);
-    for (let i2 = 0;i2 < SLOT_COUNT; i2++) {
-      const slotBytes = indexBlock.slice(i2 * LinkedArrayListSlot2.LENGTH, (i2 + 1) * LinkedArrayListSlot2.LENGTH);
-      slotBlock[i2] = LinkedArrayListSlot2.fromBytes(slotBytes);
-    }
-    const keyAndIndex = Database3.keyAndIndexForLinkedArrayList(slotBlock, key, shift);
-    if (keyAndIndex === null)
-      throw new NoAvailableSlotsException;
-    const nextKey = keyAndIndex.key;
-    const i = keyAndIndex.index;
-    const slot = slotBlock[i];
-    const slotPos = indexPos + LinkedArrayListSlot2.LENGTH * i;
-    if (shift === 0) {
-      const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
-      return new LinkedArrayListSlotPointer(new SlotPointer(slotPos, slot.slot), leafCount);
-    }
-    const ptr = Number(slot.slot.value);
-    switch (slot.slot.tag) {
-      case 0 /* NONE */: {
-        switch (writeMode) {
-          case 0 /* READ_ONLY */:
-            throw new KeyNotFoundException;
-          case 1 /* READ_WRITE */: {
-            const nextIndexPos = await this.core.length();
-            await this.core.seek(nextIndexPos);
-            await writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
-            const nextSlotPtr = await this.readLinkedArrayListSlot(nextIndexPos, nextKey, shift - 1, writeMode, isTopLevel);
-            slotBlock[i] = slotBlock[i].withSize(nextSlotPtr.leafCount);
-            const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
-            await this.core.seek(slotPos);
-            await writer.write(new LinkedArrayListSlot2(nextSlotPtr.leafCount, new Slot(nextIndexPos, 1 /* INDEX */)).toBytes());
-            return new LinkedArrayListSlotPointer(nextSlotPtr.slotPtr, leafCount);
-          }
-          default:
-            throw new UnreachableException;
-        }
-      }
-      case 1 /* INDEX */: {
-        let nextPtr = ptr;
-        if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
-          if (this.txStart !== null) {
-            if (nextPtr < this.txStart) {
-              await this.core.seek(ptr);
-              const indexBlockCopy = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-              await reader.readFully(indexBlockCopy);
-              nextPtr = await this.core.length();
-              await this.core.seek(nextPtr);
-              await writer.write(indexBlockCopy);
-            }
-          } else if (this.header.tag === 2 /* ARRAY_LIST */) {
-            throw new ExpectedTxStartException;
-          }
-        }
-        const nextSlotPtr = await this.readLinkedArrayListSlot(nextPtr, nextKey, shift - 1, writeMode, isTopLevel);
-        slotBlock[i] = slotBlock[i].withSize(nextSlotPtr.leafCount);
-        const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
-        if (writeMode === 1 /* READ_WRITE */ && !isTopLevel) {
-          await this.core.seek(slotPos);
-          await writer.write(new LinkedArrayListSlot2(nextSlotPtr.leafCount, new Slot(nextPtr, 1 /* INDEX */)).toBytes());
-        }
-        return new LinkedArrayListSlotPointer(nextSlotPtr.slotPtr, leafCount);
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async readLinkedArrayListBlocks(indexPos, key, shift, blocks) {
-    const reader = this.core.reader();
-    const slotBlock = new Array(SLOT_COUNT);
-    await this.core.seek(indexPos);
-    const indexBlock = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-    await reader.readFully(indexBlock);
-    for (let i2 = 0;i2 < SLOT_COUNT; i2++) {
-      const slotBytes = indexBlock.slice(i2 * LinkedArrayListSlot2.LENGTH, (i2 + 1) * LinkedArrayListSlot2.LENGTH);
-      slotBlock[i2] = LinkedArrayListSlot2.fromBytes(slotBytes);
-    }
-    const keyAndIndex = Database3.keyAndIndexForLinkedArrayList(slotBlock, key, shift);
-    if (keyAndIndex === null)
-      throw new NoAvailableSlotsException;
-    const nextKey = keyAndIndex.key;
-    const i = keyAndIndex.index;
-    const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
-    blocks.push(new LinkedArrayListBlockInfo(slotBlock, i, new LinkedArrayListSlot2(leafCount, new Slot(indexPos, 1 /* INDEX */))));
-    if (shift === 0) {
-      return;
-    }
-    const slot = slotBlock[i];
-    switch (slot.slot.tag) {
-      case 0 /* NONE */:
-        throw new EmptySlotException;
-      case 1 /* INDEX */:
-        await this.readLinkedArrayListBlocks(Number(slot.slot.value), nextKey, shift - 1, blocks);
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  populateArray(arr) {
-    for (let i = 0;i < arr.length; i++) {
-      arr[i] = new LinkedArrayListSlot2(0, new Slot);
-    }
-  }
-  async readLinkedArrayListSlice(header, offset, size) {
-    const writer = this.core.writer();
-    if (offset + size > header.size) {
-      throw new KeyNotFoundException;
-    }
-    const leftBlocks = [];
-    await this.readLinkedArrayListBlocks(header.ptr, offset, header.shift, leftBlocks);
-    const rightBlocks = [];
-    const rightKey = offset + size === 0 ? 0 : offset + size - 1;
-    await this.readLinkedArrayListBlocks(header.ptr, rightKey, header.shift, rightBlocks);
-    const blockCount = leftBlocks.length;
-    let nextSlots = [null, null];
-    let nextShift = 0;
-    for (let i = 0;i < blockCount; i++) {
-      const isLeafNode = nextSlots[0] === null;
-      const leftBlock = leftBlocks[blockCount - i - 1];
-      const rightBlock = rightBlocks[blockCount - i - 1];
-      const origBlockInfos = [leftBlock, rightBlock];
-      let nextBlocks = [null, null];
-      if (leftBlock.parentSlot.slot.value === rightBlock.parentSlot.slot.value) {
-        let slotI = 0;
-        const newRootBlock = new Array(SLOT_COUNT);
-        this.populateArray(newRootBlock);
-        if (size > 0) {
-          if (nextSlots[0] !== null) {
-            newRootBlock[slotI] = nextSlots[0];
-          } else {
-            newRootBlock[slotI] = leftBlock.block[leftBlock.i];
-          }
-          slotI += 1;
-        }
-        if (size > 1) {
-          for (let j = leftBlock.i + 1;j < rightBlock.i; j++) {
-            const middleSlot = leftBlock.block[j];
-            newRootBlock[slotI] = middleSlot;
-            slotI += 1;
-          }
-          if (nextSlots[1] !== null) {
-            newRootBlock[slotI] = nextSlots[1];
-          } else {
-            newRootBlock[slotI] = leftBlock.block[rightBlock.i];
-          }
-        }
-        nextBlocks[0] = newRootBlock;
-      } else {
-        let slotI = 0;
-        const newLeftBlock = new Array(SLOT_COUNT);
-        this.populateArray(newLeftBlock);
-        if (nextSlots[0] !== null) {
-          newLeftBlock[slotI] = nextSlots[0];
-        } else {
-          newLeftBlock[slotI] = leftBlock.block[leftBlock.i];
-        }
-        slotI += 1;
-        for (let j = leftBlock.i + 1;j < leftBlock.block.length; j++) {
-          const nextSlot = leftBlock.block[j];
-          newLeftBlock[slotI] = nextSlot;
-          slotI += 1;
-        }
-        nextBlocks[0] = newLeftBlock;
-        slotI = 0;
-        const newRightBlock = new Array(SLOT_COUNT);
-        this.populateArray(newRightBlock);
-        for (let j = 0;j < rightBlock.i; j++) {
-          const firstSlot = rightBlock.block[j];
-          newRightBlock[slotI] = firstSlot;
-          slotI += 1;
-        }
-        if (nextSlots[1] !== null) {
-          newRightBlock[slotI] = nextSlots[1];
-        } else {
-          newRightBlock[slotI] = rightBlock.block[rightBlock.i];
-        }
-        nextBlocks[1] = newRightBlock;
-        nextShift += 1;
-      }
-      nextSlots = [null, null];
-      await this.core.seek(await this.core.length());
-      for (let j = 0;j < 2; j++) {
-        const blockMaybe = nextBlocks[j];
-        const origBlockInfo = origBlockInfos[j];
-        if (blockMaybe !== null) {
-          let eql = true;
-          for (let k = 0;k < blockMaybe.length; k++) {
-            const blockSlot = blockMaybe[k];
-            const origSlot = origBlockInfo.block[k];
-            if (!blockSlot.slot.equals(origSlot.slot)) {
-              eql = false;
-              break;
-            }
-          }
-          if (eql) {
-            nextSlots[j] = origBlockInfo.parentSlot;
-          } else {
-            const nextPtr = await this.core.position();
-            let leafCount = 0;
-            for (let k = 0;k < blockMaybe.length; k++) {
-              const blockSlot = blockMaybe[k];
-              await writer.write(blockSlot.toBytes());
-              if (isLeafNode) {
-                if (!blockSlot.slot.empty()) {
-                  leafCount += 1;
-                }
-              } else {
-                leafCount += blockSlot.size;
-              }
-            }
-            nextSlots[j] = new LinkedArrayListSlot2(leafCount, j === 0 ? new Slot(nextPtr, 1 /* INDEX */, true) : new Slot(nextPtr, 1 /* INDEX */));
-          }
-        }
-      }
-      if (nextSlots[0] !== null && nextSlots[1] === null) {
-        break;
-      }
-    }
-    const rootSlot = nextSlots[0];
-    if (rootSlot === null)
-      throw new ExpectedRootNodeException;
-    return new LinkedArrayListHeader(nextShift, Number(rootSlot.slot.value), size);
-  }
-  async readLinkedArrayListConcat(headerA, headerB) {
-    const writer = this.core.writer();
-    const blocksA = [];
-    const keyA = headerA.size === 0 ? 0 : headerA.size - 1;
-    await this.readLinkedArrayListBlocks(headerA.ptr, keyA, headerA.shift, blocksA);
-    const blocksB = [];
-    await this.readLinkedArrayListBlocks(headerB.ptr, 0, headerB.shift, blocksB);
-    let nextSlots = [null, null];
-    let nextShift = 0;
-    for (let i = 0;i < Math.max(blocksA.length, blocksB.length); i++) {
-      const blockInfos = [
-        i < blocksA.length ? blocksA[blocksA.length - 1 - i] : null,
-        i < blocksB.length ? blocksB[blocksB.length - 1 - i] : null
-      ];
-      let nextBlocks = [null, null];
-      const isLeafNode = nextSlots[0] === null;
-      if (!isLeafNode) {
-        nextShift += 1;
-      }
-      for (let j = 0;j < 2; j++) {
-        const blockInfoMaybe = blockInfos[j];
-        if (blockInfoMaybe !== null) {
-          const block = new Array(SLOT_COUNT);
-          this.populateArray(block);
-          let targetI = 0;
-          for (let sourceI = 0;sourceI < blockInfoMaybe.block.length; sourceI++) {
-            const blockSlot = blockInfoMaybe.block[sourceI];
-            if (!isLeafNode && blockInfoMaybe.i === sourceI) {
-              continue;
-            } else if (blockSlot.slot.empty()) {
-              break;
-            }
-            block[targetI] = blockSlot;
-            targetI += 1;
-          }
-          if (targetI === 0) {
-            continue;
-          }
-          nextBlocks[j] = block;
-        }
-      }
-      const slotsToWrite = new Array(SLOT_COUNT * 2);
-      this.populateArray(slotsToWrite);
-      let slotI = 0;
-      if (nextBlocks[0] !== null) {
-        for (const blockSlot of nextBlocks[0]) {
-          if (blockSlot.slot.empty()) {
-            break;
-          }
-          slotsToWrite[slotI] = blockSlot;
-          slotI += 1;
-        }
-      }
-      for (const slotMaybe of nextSlots) {
-        if (slotMaybe !== null) {
-          slotsToWrite[slotI] = slotMaybe;
-          slotI += 1;
-        }
-      }
-      if (nextBlocks[1] !== null) {
-        for (const blockSlot of nextBlocks[1]) {
-          if (blockSlot.slot.empty()) {
-            break;
-          }
-          slotsToWrite[slotI] = blockSlot;
-          slotI += 1;
-        }
-      }
-      nextSlots = [null, null];
-      const blocks = [new Array(SLOT_COUNT), new Array(SLOT_COUNT)];
-      this.populateArray(blocks[0]);
-      this.populateArray(blocks[1]);
-      if (slotI > SLOT_COUNT) {
-        if (headerA.size < headerB.size) {
-          for (let j = 0;j < slotI - SLOT_COUNT; j++) {
-            blocks[0][j] = slotsToWrite[j];
-          }
-          for (let j = 0;j < SLOT_COUNT; j++) {
-            blocks[1][j] = slotsToWrite[j + (slotI - SLOT_COUNT)];
-          }
-        } else {
-          for (let j = 0;j < SLOT_COUNT; j++) {
-            blocks[0][j] = slotsToWrite[j];
-          }
-          for (let j = 0;j < slotI - SLOT_COUNT; j++) {
-            blocks[1][j] = slotsToWrite[j + SLOT_COUNT];
-          }
-        }
-      } else {
-        for (let j = 0;j < slotI; j++) {
-          blocks[0][j] = slotsToWrite[j];
-        }
-      }
-      await this.core.seek(await this.core.length());
-      for (let blockI = 0;blockI < blocks.length; blockI++) {
-        const block = blocks[blockI];
-        if (block[0].slot.empty()) {
-          break;
-        }
-        const nextPtr = await this.core.position();
-        let leafCount = 0;
-        for (const blockSlot of block) {
-          await writer.write(blockSlot.toBytes());
-          if (isLeafNode) {
-            if (!blockSlot.slot.empty()) {
-              leafCount += 1;
-            }
-          } else {
-            leafCount += blockSlot.size;
-          }
-        }
-        nextSlots[blockI] = new LinkedArrayListSlot2(leafCount, new Slot(nextPtr, 1 /* INDEX */, true));
-      }
-    }
-    let rootPtr;
-    if (nextSlots[0] !== null) {
-      if (nextSlots[1] !== null) {
-        const block = new Array(SLOT_COUNT);
-        this.populateArray(block);
-        block[0] = nextSlots[0];
-        block[1] = nextSlots[1];
-        const newPtr = await this.core.length();
-        for (const blockSlot of block) {
-          await writer.write(blockSlot.toBytes());
-        }
-        if (nextShift === MAX_BRANCH_LENGTH)
-          throw new MaxShiftExceededException;
-        nextShift += 1;
-        rootPtr = newPtr;
-      } else {
-        rootPtr = Number(nextSlots[0].slot.value);
-      }
-    } else {
-      rootPtr = headerA.ptr;
-    }
-    return new LinkedArrayListHeader(nextShift, rootPtr, headerA.size + headerB.size);
-  }
-}
-async function remapSlot(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  switch (slot.tag) {
-    case 0 /* NONE */:
-    case 8 /* UINT */:
-    case 9 /* INT */:
-    case 10 /* FLOAT */:
-    case 7 /* SHORT_BYTES */:
-      return slot;
-    case 6 /* BYTES */: {
-      const mapped = offsetMap.get(Number(slot.value));
-      if (mapped !== undefined)
-        return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapBytes(sourceCore, targetCore, slot);
-      offsetMap.set(Number(slot.value), newOffset);
-      return new Slot(newOffset, slot.tag, slot.full);
-    }
-    case 1 /* INDEX */: {
-      const mapped = offsetMap.get(Number(slot.value));
-      if (mapped !== undefined)
-        return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapIndex(sourceCore, targetCore, hashSize, offsetMap, slot);
-      offsetMap.set(Number(slot.value), newOffset);
-      return new Slot(newOffset, slot.tag, slot.full);
-    }
-    case 2 /* ARRAY_LIST */: {
-      const mapped = offsetMap.get(Number(slot.value));
-      if (mapped !== undefined)
-        return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapArrayList(sourceCore, targetCore, hashSize, offsetMap, slot);
-      offsetMap.set(Number(slot.value), newOffset);
-      return new Slot(newOffset, slot.tag, slot.full);
-    }
-    case 3 /* LINKED_ARRAY_LIST */: {
-      const mapped = offsetMap.get(Number(slot.value));
-      if (mapped !== undefined)
-        return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapLinkedArrayList(sourceCore, targetCore, hashSize, offsetMap, slot);
-      offsetMap.set(Number(slot.value), newOffset);
-      return new Slot(newOffset, slot.tag, slot.full);
-    }
-    case 4 /* HASH_MAP */:
-    case 11 /* HASH_SET */: {
-      const mapped = offsetMap.get(Number(slot.value));
-      if (mapped !== undefined)
-        return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, false);
-      offsetMap.set(Number(slot.value), newOffset);
-      return new Slot(newOffset, slot.tag, slot.full);
-    }
-    case 12 /* COUNTED_HASH_MAP */:
-    case 13 /* COUNTED_HASH_SET */: {
-      const mapped = offsetMap.get(Number(slot.value));
-      if (mapped !== undefined)
-        return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, true);
-      offsetMap.set(Number(slot.value), newOffset);
-      return new Slot(newOffset, slot.tag, slot.full);
-    }
-    case 5 /* KV_PAIR */: {
-      const mapped = offsetMap.get(Number(slot.value));
-      if (mapped !== undefined)
-        return new Slot(mapped, slot.tag, slot.full);
-      const newOffset = await remapKvPair(sourceCore, targetCore, hashSize, offsetMap, slot);
-      offsetMap.set(Number(slot.value), newOffset);
-      return new Slot(newOffset, slot.tag, slot.full);
-    }
-    default:
-      throw new UnexpectedTagException;
-  }
-}
-async function remapBytes(sourceCore, targetCore, slot) {
-  await sourceCore.seek(Number(slot.value));
-  const sourceReader = sourceCore.reader();
-  const length = await sourceReader.readLong();
-  const formatTagSize = slot.full ? 2 : 0;
-  const totalPayload = length + formatTagSize;
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
-  const targetWriter = targetCore.writer();
-  await targetWriter.writeLong(length);
-  let remaining = totalPayload;
-  while (remaining > 0) {
-    const chunk = Math.min(remaining, 4096);
-    const buf = new Uint8Array(chunk);
-    await sourceReader.readFully(buf);
-    await targetWriter.write(buf);
-    remaining -= chunk;
-  }
-  return newOffset;
-}
-async function remapIndex(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
-  const sourceReader = sourceCore.reader();
-  const blockBytes = new Uint8Array(INDEX_BLOCK_SIZE);
-  await sourceReader.readFully(blockBytes);
-  const remappedSlots = [];
-  for (let i = 0;i < SLOT_COUNT; i++) {
-    const slotBytes = blockBytes.slice(i * Slot.LENGTH, (i + 1) * Slot.LENGTH);
-    const childSlot = Slot.fromBytes(slotBytes);
-    remappedSlots.push(await remapSlot(sourceCore, targetCore, hashSize, offsetMap, childSlot));
-  }
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
-  const targetWriter = targetCore.writer();
-  for (const s of remappedSlots) {
-    await targetWriter.write(s.toBytes());
-  }
-  return newOffset;
-}
-async function remapArrayList(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
-  const sourceReader = sourceCore.reader();
-  const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
-  await sourceReader.readFully(headerBytes);
-  const header = ArrayListHeader.fromBytes(headerBytes);
-  const indexSlot = new Slot(header.ptr, 1 /* INDEX */);
-  const remappedIndex = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, indexSlot);
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
-  const targetWriter = targetCore.writer();
-  await targetWriter.write(new ArrayListHeader(Number(remappedIndex.value), header.size).toBytes());
-  return newOffset;
-}
-async function remapLinkedArrayList(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
-  const sourceReader = sourceCore.reader();
-  const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
-  await sourceReader.readFully(headerBytes);
-  const header = LinkedArrayListHeader.fromBytes(headerBytes);
-  const remappedPtr = await remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, header.ptr);
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
-  const targetWriter = targetCore.writer();
-  await targetWriter.write(new LinkedArrayListHeader(header.shift, remappedPtr, header.size).toBytes());
-  return newOffset;
-}
-async function remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, blockOffset) {
-  const mapped = offsetMap.get(blockOffset);
-  if (mapped !== undefined)
-    return mapped;
-  await sourceCore.seek(blockOffset);
-  const sourceReader = sourceCore.reader();
-  const blockBytes = new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
-  await sourceReader.readFully(blockBytes);
-  const slots = [];
-  for (let i = 0;i < SLOT_COUNT; i++) {
-    const slotBytes = blockBytes.slice(i * LinkedArrayListSlot2.LENGTH, (i + 1) * LinkedArrayListSlot2.LENGTH);
-    slots.push(LinkedArrayListSlot2.fromBytes(slotBytes));
-  }
-  const remappedSlots = [];
-  for (const s of slots) {
-    if (s.slot.tag === 1 /* INDEX */) {
-      const remappedPtr = await remapLinkedArrayListBlock(sourceCore, targetCore, hashSize, offsetMap, Number(s.slot.value));
-      remappedSlots.push(new LinkedArrayListSlot2(s.size, new Slot(remappedPtr, 1 /* INDEX */, s.slot.full)));
-    } else if (s.slot.empty()) {
-      remappedSlots.push(s);
-    } else {
-      const remapped = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, s.slot);
-      remappedSlots.push(new LinkedArrayListSlot2(s.size, remapped));
-    }
-  }
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
-  const targetWriter = targetCore.writer();
-  for (const s of remappedSlots) {
-    await targetWriter.write(s.toBytes());
-  }
-  offsetMap.set(blockOffset, newOffset);
-  return newOffset;
-}
-async function remapHashMapOrSet(sourceCore, targetCore, hashSize, offsetMap, slot, counted) {
-  await sourceCore.seek(Number(slot.value));
-  const sourceReader = sourceCore.reader();
-  let countValue = -1;
-  if (counted) {
-    countValue = await sourceReader.readLong();
-  }
-  const blockBytes = new Uint8Array(INDEX_BLOCK_SIZE);
-  await sourceReader.readFully(blockBytes);
-  const remappedSlots = [];
-  for (let i = 0;i < SLOT_COUNT; i++) {
-    const slotBytes = blockBytes.slice(i * Slot.LENGTH, (i + 1) * Slot.LENGTH);
-    const childSlot = Slot.fromBytes(slotBytes);
-    remappedSlots.push(await remapSlot(sourceCore, targetCore, hashSize, offsetMap, childSlot));
-  }
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
-  const targetWriter = targetCore.writer();
-  if (counted) {
-    await targetWriter.writeLong(countValue);
-  }
-  for (const s of remappedSlots) {
-    await targetWriter.write(s.toBytes());
-  }
-  return newOffset;
-}
-async function remapKvPair(sourceCore, targetCore, hashSize, offsetMap, slot) {
-  await sourceCore.seek(Number(slot.value));
-  const sourceReader = sourceCore.reader();
-  const kvPairBytes = new Uint8Array(KeyValuePair.length(hashSize));
-  await sourceReader.readFully(kvPairBytes);
-  const kvPair = KeyValuePair.fromBytes(kvPairBytes, hashSize);
-  const remappedKey = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, kvPair.keySlot);
-  const remappedValue = await remapSlot(sourceCore, targetCore, hashSize, offsetMap, kvPair.valueSlot);
-  const newOffset = await targetCore.length();
-  await targetCore.seek(newOffset);
-  const targetWriter = targetCore.writer();
-  await targetWriter.write(new KeyValuePair(remappedValue, remappedKey, kvPair.hash).toBytes());
-  return newOffset;
-}
-// src/read-array-list.ts
-class ReadArrayList {
-  cursor;
-  constructor(cursor) {
-    if (cursor) {
-      switch (cursor.slotPtr.slot.tag) {
-        case 0 /* NONE */:
-        case 2 /* ARRAY_LIST */:
-          this.cursor = cursor;
-          break;
-        default:
-          throw new UnexpectedTagException;
-      }
-    }
-  }
-  slot() {
-    return this.cursor.slot();
-  }
-  async count() {
-    return this.cursor.count();
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async getCursor(index) {
-    return this.cursor.readPath([new ArrayListGet2(index)]);
-  }
-  async getSlot(index) {
-    return this.cursor.readPathSlot([new ArrayListGet2(index)]);
-  }
-}
-// src/write-array-list.ts
-class WriteArrayList extends ReadArrayList {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const list = new WriteArrayList;
-    const newCursor = await cursor.writePath([new ArrayListInit]);
-    list.cursor = newCursor;
-    return list;
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async put(index, data) {
-    await this.cursor.writePath([
-      new ArrayListGet2(index),
-      new WriteData(data)
-    ]);
-  }
-  async putCursor(index) {
-    return this.cursor.writePath([new ArrayListGet2(index)]);
-  }
-  async append(data) {
-    await this.cursor.writePath([
-      new ArrayListAppend,
-      new WriteData(data)
-    ]);
-  }
-  async appendCursor() {
-    return this.cursor.writePath([new ArrayListAppend]);
-  }
-  async appendContext(data, fn) {
-    await this.cursor.writePath([
-      new ArrayListAppend,
-      new WriteData(data),
-      new Context(fn)
-    ]);
-  }
-  async slice(size) {
-    await this.cursor.writePath([new ArrayListSlice(size)]);
-  }
-}
-// src/read-hash-map.ts
-class ReadHashMap {
-  cursor;
-  constructor(cursor) {
-    if (cursor) {
-      switch (cursor.slotPtr.slot.tag) {
-        case 0 /* NONE */:
-        case 4 /* HASH_MAP */:
-        case 11 /* HASH_SET */:
-          this.cursor = cursor;
-          break;
-        default:
-          throw new UnexpectedTagException;
-      }
-    }
-  }
-  slot() {
-    return this.cursor.slot();
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async getCursor(key) {
-    const hash = await this.resolveHash(key);
-    return this.cursor.readPath([new HashMapGet(new HashMapGetValue(hash))]);
-  }
-  async getSlot(key) {
-    const hash = await this.resolveHash(key);
-    return this.cursor.readPathSlot([new HashMapGet(new HashMapGetValue(hash))]);
-  }
-  async getKeyCursor(key) {
-    const hash = await this.resolveHash(key);
-    return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
-  }
-  async getKeySlot(key) {
-    const hash = await this.resolveHash(key);
-    return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
-  }
-  async getKeyValuePair(key) {
-    const hash = await this.resolveHash(key);
-    const cursor = await this.cursor.readPath([new HashMapGet(new HashMapGetKVPair(hash))]);
-    if (cursor === null) {
-      return null;
-    } else {
-      return cursor.readKeyValuePair();
-    }
-  }
-  async resolveHash(key) {
-    if (key instanceof Uint8Array) {
-      return key;
-    } else if (typeof key === "string") {
-      return this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    } else {
-      return this.cursor.db.hasher.digest(key.value);
-    }
-  }
-}
-// src/write-hash-map.ts
-class WriteHashMap extends ReadHashMap {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const map = new WriteHashMap;
-    const newCursor = await cursor.writePath([new HashMapInit(false, false)]);
-    map.cursor = newCursor;
-    return map;
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async put(key, data) {
-    if (typeof key === "string") {
-      const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-      await this.putKeyInternal(hash, new Bytes(key));
-      await this.putInternal(hash, data);
-    } else if (key instanceof Bytes) {
-      const hash = await this.cursor.db.hasher.digest(key.value);
-      await this.putKeyInternal(hash, key);
-      await this.putInternal(hash, data);
-    } else {
-      await this.putInternal(key, data);
-    }
-  }
-  async putCursor(key) {
-    if (typeof key === "string") {
-      const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-      await this.putKeyInternal(hash, new Bytes(key));
-      return this.putCursorInternal(hash);
-    } else if (key instanceof Bytes) {
-      const hash = await this.cursor.db.hasher.digest(key.value);
-      await this.putKeyInternal(hash, key);
-      return this.putCursorInternal(hash);
-    } else {
-      return this.putCursorInternal(key);
-    }
-  }
-  async putKey(key, data) {
-    const hash = await this.resolveHash(key);
-    await this.putKeyInternal(hash, data);
-  }
-  async putKeyCursor(key) {
-    const hash = await this.resolveHash(key);
-    return this.putKeyCursorInternal(hash);
-  }
-  async remove(key) {
-    const hash = await this.resolveHash(key);
-    try {
-      await this.cursor.writePath([new HashMapRemove(hash)]);
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        return false;
-      }
-      throw e;
-    }
-    return true;
-  }
-  async putInternal(hash, data) {
-    await this.cursor.writePath([
-      new HashMapGet(new HashMapGetValue(hash)),
-      new WriteData(data)
-    ]);
-  }
-  async putCursorInternal(hash) {
-    return this.cursor.writePath([
-      new HashMapGet(new HashMapGetValue(hash))
-    ]);
-  }
-  async putKeyInternal(hash, data) {
-    const cursor = await this.cursor.writePath([
-      new HashMapGet(new HashMapGetKey(hash))
-    ]);
-    await cursor.writeIfEmpty(data);
-  }
-  async putKeyCursorInternal(hash) {
-    return this.cursor.writePath([
-      new HashMapGet(new HashMapGetKey(hash))
-    ]);
-  }
-}
-// src/read-hash-set.ts
-class ReadHashSet {
-  cursor;
-  constructor(cursor) {
-    if (cursor) {
-      switch (cursor.slotPtr.slot.tag) {
-        case 0 /* NONE */:
-        case 4 /* HASH_MAP */:
-        case 11 /* HASH_SET */:
-          this.cursor = cursor;
-          break;
-        default:
-          throw new UnexpectedTagException;
-      }
-    }
-  }
-  slot() {
-    return this.cursor.slot();
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async getCursor(key) {
-    const hash = await this.resolveHash(key);
-    return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
-  }
-  async getSlot(key) {
-    const hash = await this.resolveHash(key);
-    return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
-  }
-  async resolveHash(key) {
-    if (key instanceof Uint8Array) {
-      return key;
-    } else if (typeof key === "string") {
-      return this.cursor.db.hasher.digest(new TextEncoder().encode(key));
-    } else {
-      return this.cursor.db.hasher.digest(key.value);
-    }
-  }
-}
-// src/write-hash-set.ts
-class WriteHashSet extends ReadHashSet {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const set = new WriteHashSet;
-    const newCursor = await cursor.writePath([new HashMapInit(false, true)]);
-    set.cursor = newCursor;
-    return set;
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async put(key, data) {
-    if (typeof key === "string") {
-      const bytes = new TextEncoder().encode(key);
-      const hash = await this.cursor.db.hasher.digest(bytes);
-      await this.putInternal(hash, new Bytes(bytes));
-    } else if (key instanceof Bytes) {
-      const hash = await this.cursor.db.hasher.digest(key.value);
-      await this.putInternal(hash, key);
-    } else {
-      await this.putInternal(key, data);
-    }
-  }
-  async putCursor(key) {
-    const hash = await this.resolveHash(key);
-    return this.putCursorInternal(hash);
-  }
-  async remove(key) {
-    const hash = await this.resolveHash(key);
-    try {
-      await this.cursor.writePath([new HashMapRemove(hash)]);
-    } catch (e) {
-      if (e instanceof KeyNotFoundException) {
-        return false;
-      }
-      throw e;
-    }
-    return true;
-  }
-  async putInternal(hash, data) {
-    const cursor = await this.cursor.writePath([
-      new HashMapGet(new HashMapGetKey(hash))
-    ]);
-    await cursor.writeIfEmpty(data);
-  }
-  async putCursorInternal(hash) {
-    return this.cursor.writePath([
-      new HashMapGet(new HashMapGetKey(hash))
-    ]);
-  }
-}
-// src/read-linked-array-list.ts
-class ReadLinkedArrayList {
-  cursor;
-  constructor(cursor) {
-    if (cursor) {
-      switch (cursor.slotPtr.slot.tag) {
-        case 0 /* NONE */:
-        case 3 /* LINKED_ARRAY_LIST */:
-          this.cursor = cursor;
-          break;
-        default:
-          throw new UnexpectedTagException;
-      }
-    }
-  }
-  slot() {
-    return this.cursor.slot();
-  }
-  async count() {
-    return this.cursor.count();
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async getCursor(index) {
-    return this.cursor.readPath([new LinkedArrayListGet(index)]);
-  }
-  async getSlot(index) {
-    return this.cursor.readPathSlot([new LinkedArrayListGet(index)]);
-  }
-}
-// src/write-linked-array-list.ts
-class WriteLinkedArrayList extends ReadLinkedArrayList {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const list = new WriteLinkedArrayList;
-    const newCursor = await cursor.writePath([new LinkedArrayListInit]);
-    list.cursor = newCursor;
-    return list;
-  }
-  async iterator() {
-    return this.cursor.iterator();
-  }
-  async* [Symbol.asyncIterator]() {
-    yield* this.cursor;
-  }
-  async put(index, data) {
-    await this.cursor.writePath([
-      new LinkedArrayListGet(index),
-      new WriteData(data)
-    ]);
-  }
-  async putCursor(index) {
-    return this.cursor.writePath([new LinkedArrayListGet(index)]);
-  }
-  async append(data) {
-    await this.cursor.writePath([
-      new LinkedArrayListAppend,
-      new WriteData(data)
-    ]);
-  }
-  async appendCursor() {
-    return this.cursor.writePath([new LinkedArrayListAppend]);
-  }
-  async slice(offset, size) {
-    await this.cursor.writePath([
-      new LinkedArrayListSlice(offset, size)
-    ]);
-  }
-  async concat(list) {
-    await this.cursor.writePath([new LinkedArrayListConcat(list)]);
-  }
-  async insert(index, data) {
-    await this.cursor.writePath([
-      new LinkedArrayListInsert(index),
-      new WriteData(data)
-    ]);
-  }
-  async insertCursor(index) {
-    return this.cursor.writePath([new LinkedArrayListInsert(index)]);
-  }
-  async remove(index) {
-    await this.cursor.writePath([new LinkedArrayListRemove(index)]);
-  }
-}
-// src/read-counted-hash-map.ts
-class ReadCountedHashMap extends ReadHashMap {
-  constructor(cursor) {
-    super();
-    switch (cursor.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */:
-        this.cursor = cursor;
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async count() {
-    return this.cursor.count();
-  }
-}
-// src/write-counted-hash-map.ts
-class WriteCountedHashMap extends WriteHashMap {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const map = new WriteCountedHashMap;
-    switch (cursor.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */: {
-        const newCursor = await cursor.writePath([new HashMapInit(true, false)]);
-        map.cursor = newCursor;
-        break;
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-    return map;
-  }
-  async count() {
-    return this.cursor.count();
-  }
-}
-// src/read-counted-hash-set.ts
-class ReadCountedHashSet extends ReadHashSet {
-  constructor(cursor) {
-    super();
-    switch (cursor.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */:
-        this.cursor = cursor;
-        break;
-      default:
-        throw new UnexpectedTagException;
-    }
-  }
-  async count() {
-    return this.cursor.count();
-  }
-}
-// src/write-counted-hash-set.ts
-class WriteCountedHashSet extends WriteHashSet {
-  constructor() {
-    super();
-  }
-  static async create(cursor) {
-    const set = new WriteCountedHashSet;
-    switch (cursor.slotPtr.slot.tag) {
-      case 0 /* NONE */:
-      case 12 /* COUNTED_HASH_MAP */:
-      case 13 /* COUNTED_HASH_SET */: {
-        const newCursor = await cursor.writePath([new HashMapInit(true, true)]);
-        set.cursor = newCursor;
-        break;
-      }
-      default:
-        throw new UnexpectedTagException;
-    }
-    return set;
-  }
-  async count() {
-    return this.cursor.count();
-  }
-}
-export {
-  tagValueOf,
-  Writer,
-  WriteNotAllowedException,
-  WriteMode,
-  WriteLinkedArrayList,
-  WriteKeyValuePairCursor,
-  WriteHashSet,
-  WriteHashMap,
-  WriteData,
-  WriteCursorIterator,
-  WriteCursor,
-  WriteCountedHashSet,
-  WriteCountedHashMap,
-  WriteArrayList,
-  VERSION,
-  UnreachableException,
-  UnexpectedWriterPositionException,
-  UnexpectedTagException,
-  Uint,
-  TopLevelArrayListHeader,
-  Tag,
-  StreamTooLongException,
-  SlotPointer,
-  Slot,
-  SLOT_COUNT,
-  Reader,
-  ReadLinkedArrayList,
-  ReadHashSet,
-  ReadHashMap,
-  ReadCursor,
-  ReadCountedHashSet,
-  ReadCountedHashMap,
-  ReadArrayList,
-  PathPartMustBeAtEndException,
-  NotImplementedException,
-  NoAvailableSlotsException,
-  MustSetNewSlotsToFullException,
-  MaxShiftExceededException,
-  MAX_BRANCH_LENGTH,
-  MASK,
-  MAGIC_NUMBER,
-  LinkedArrayListSlotPointer,
-  LinkedArrayListSlot2 as LinkedArrayListSlot,
-  LinkedArrayListSlice,
-  LinkedArrayListRemove,
-  LinkedArrayListInsert,
-  LinkedArrayListInit,
-  LinkedArrayListHeader,
-  LinkedArrayListGet,
-  LinkedArrayListConcat,
-  LinkedArrayListBlockInfo,
-  LinkedArrayListAppend,
-  LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE,
-  KeyValuePairCursor,
-  KeyValuePair,
-  KeyOffsetExceededException,
-  KeyNotFoundException,
-  InvalidVersionException,
-  InvalidTopLevelTypeException,
-  InvalidOffsetException,
-  InvalidHashSizeException,
-  InvalidFormatTagSizeException,
-  InvalidDatabaseException,
-  Int,
-  INDEX_BLOCK_SIZE,
-  Header,
-  Hasher,
-  HashMapRemove,
-  HashMapInit,
-  HashMapGetValue,
-  HashMapGetKey,
-  HashMapGetKVPair,
-  HashMapGet,
-  Float,
-  ExpectedUnsignedLongException,
-  ExpectedTxStartException,
-  ExpectedRootNodeException,
-  EndOfStreamException,
-  EmptySlotException,
-  DatabaseException,
-  Database3 as Database,
-  CursorNotWriteableException,
-  CursorIterator,
-  CoreMemory,
-  CoreFile,
-  CoreBufferedFile,
-  Context,
-  Bytes,
-  BIT_COUNT,
-  ArrayListSlice,
-  ArrayListInit,
-  ArrayListHeader,
-  ArrayListGet2 as ArrayListGet,
-  ArrayListAppend
-};
+// Tag
+export { Tag, tagValueOf } from './tag.js';
+// Slot
+export { Slot } from './slot.js';
+export { SlotPointer } from './slot-pointer.js';
+// Writeable Data
+export { Uint, Int, Float, Bytes } from './writeable-data.js';
+// Exceptions
+export { DatabaseException, NotImplementedException, UnreachableException, InvalidDatabaseException, InvalidVersionException, InvalidHashSizeException, KeyNotFoundException, WriteNotAllowedException, UnexpectedTagException, CursorNotWriteableException, ExpectedTxStartException, KeyOffsetExceededException, PathPartMustBeAtEndException, StreamTooLongException, EndOfStreamException, InvalidOffsetException, InvalidTopLevelTypeException, ExpectedUnsignedLongException, NoAvailableSlotsException, MustSetNewSlotsToFullException, EmptySlotException, ExpectedRootNodeException, InvalidFormatTagSizeException, UnexpectedWriterPositionException, MaxShiftExceededException, } from './exceptions.js';
+export { CoreMemory } from './core-memory.js';
+export { CoreFile } from './core-file.js';
+export { CoreBufferedFile } from './core-buffered-file.js';
+export { Hasher } from './hasher.js';
+// Database
+export { Database, WriteMode, Header, ArrayListHeader, TopLevelArrayListHeader, BTreeHeader, KeyValuePair, BTreeNode, BTreeNodeKind, BTreeNodeRef, BTreeInsertResult, BTreeWriteSlot, BTreeJoinResult, BTreeSplitResult, SortedNode, SortedSplit, SortedInsertResult, SortedRemoveResult, SortedSlot, SortedEntry, VERSION, MAGIC_NUMBER, BIT_COUNT, SLOT_COUNT, MASK, INDEX_BLOCK_SIZE, MAX_BRANCH_LENGTH, BTREE_SLOT_COUNT, BTREE_SPLIT_COUNT, BTREE_NODE_HEADER_SIZE, BTREE_LEAF_BLOCK_SIZE, BTREE_BRANCH_BLOCK_SIZE, SORTED_LEAF_BLOCK_SIZE, SORTED_BRANCH_BLOCK_SIZE, ArrayListInit, ArrayListGet, ArrayListAppend, ArrayListSlice, LinkedArrayListInit, LinkedArrayListGet, LinkedArrayListAppend, LinkedArrayListSlice, LinkedArrayListConcat, LinkedArrayListInsert, LinkedArrayListRemove, HashMapInit, HashMapGet, HashMapRemove, SortedMapInit, SortedMapGet, SortedMapGetIndex, SortedMapRemove, WriteData, Context, HashMapGetKVPair, HashMapGetKey, HashMapGetValue, SortedMapGetKVPair, SortedMapGetKey, SortedMapGetValue, } from './database.js';
+// Cursors
+export { ReadCursor, Reader, CursorIterator, KeyValuePairCursor } from './read-cursor.js';
+export { WriteCursor, Writer, WriteCursorIterator, WriteKeyValuePairCursor } from './write-cursor.js';
+// Collections
+export { ReadArrayList } from './read-array-list.js';
+export { WriteArrayList } from './write-array-list.js';
+export { ReadHashMap } from './read-hash-map.js';
+export { WriteHashMap } from './write-hash-map.js';
+export { ReadHashSet } from './read-hash-set.js';
+export { WriteHashSet } from './write-hash-set.js';
+export { ReadLinkedArrayList } from './read-linked-array-list.js';
+export { WriteLinkedArrayList } from './write-linked-array-list.js';
+export { ReadCountedHashMap } from './read-counted-hash-map.js';
+export { WriteCountedHashMap } from './write-counted-hash-map.js';
+export { ReadCountedHashSet } from './read-counted-hash-set.js';
+export { WriteCountedHashSet } from './write-counted-hash-set.js';
+export { ReadSortedMap } from './read-sorted-map.js';
+export { WriteSortedMap } from './write-sorted-map.js';
+export { ReadSortedSet } from './read-sorted-set.js';
+export { WriteSortedSet } from './write-sorted-set.js';