xitdb 0.1.0

package/dist/index.js

@@ -0,0 +1,3701 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/tag.ts
+function tagValueOf(n) {
+  if (n < 0 || n > 13) {
+    throw new Error(`Invalid tag value: ${n}`);
+  }
+  return n;
+}
+var Tag;
+var init_tag = __esm(() => {
+  ((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 ||= {});
+});
+
+// src/slot.ts
+class Slot {
+  static LENGTH = 9;
+  value;
+  tag;
+  full;
+  constructor(value = 0n, tag = 0 /* NONE */, full = false) {
+    this.value = 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;
+  }
+}
+var init_slot = __esm(() => {
+  init_tag();
+});
+
+// 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
+var 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;
+var init_exceptions = __esm(() => {
+  DatabaseException = class DatabaseException extends Error {
+    constructor(message) {
+      super(message);
+      this.name = this.constructor.name;
+    }
+  };
+  NotImplementedException = class NotImplementedException extends DatabaseException {
+  };
+  UnreachableException = class UnreachableException extends DatabaseException {
+  };
+  InvalidDatabaseException = class InvalidDatabaseException extends DatabaseException {
+  };
+  InvalidVersionException = class InvalidVersionException extends DatabaseException {
+  };
+  InvalidHashSizeException = class InvalidHashSizeException extends DatabaseException {
+  };
+  KeyNotFoundException = class KeyNotFoundException extends DatabaseException {
+  };
+  WriteNotAllowedException = class WriteNotAllowedException extends DatabaseException {
+  };
+  UnexpectedTagException = class UnexpectedTagException extends DatabaseException {
+  };
+  CursorNotWriteableException = class CursorNotWriteableException extends DatabaseException {
+  };
+  ExpectedTxStartException = class ExpectedTxStartException extends DatabaseException {
+  };
+  KeyOffsetExceededException = class KeyOffsetExceededException extends DatabaseException {
+  };
+  PathPartMustBeAtEndException = class PathPartMustBeAtEndException extends DatabaseException {
+  };
+  StreamTooLongException = class StreamTooLongException extends DatabaseException {
+  };
+  EndOfStreamException = class EndOfStreamException extends DatabaseException {
+  };
+  InvalidOffsetException = class InvalidOffsetException extends DatabaseException {
+  };
+  InvalidTopLevelTypeException = class InvalidTopLevelTypeException extends DatabaseException {
+  };
+  ExpectedUnsignedLongException = class ExpectedUnsignedLongException extends DatabaseException {
+  };
+  NoAvailableSlotsException = class NoAvailableSlotsException extends DatabaseException {
+  };
+  MustSetNewSlotsToFullException = class MustSetNewSlotsToFullException extends DatabaseException {
+  };
+  EmptySlotException = class EmptySlotException extends DatabaseException {
+  };
+  ExpectedRootNodeException = class ExpectedRootNodeException extends DatabaseException {
+  };
+  InvalidFormatTagSizeException = class InvalidFormatTagSizeException extends DatabaseException {
+  };
+  UnexpectedWriterPositionException = class UnexpectedWriterPositionException extends DatabaseException {
+  };
+  MaxShiftExceededException = class MaxShiftExceededException extends DatabaseException {
+  };
+});
+
+// src/writeable-data.ts
+class Uint {
+  value;
+  constructor(value) {
+    if (value < 0n) {
+      throw new Error("Uint must not be negative");
+    }
+    this.value = value;
+  }
+}
+
+class Int {
+  value;
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+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;
+  }
+}
+var init_writeable_data = __esm(() => {
+  init_exceptions();
+});
+
+// src/read-cursor.ts
+class KeyValuePairCursor {
+  valueCursor;
+  keyCursor;
+  hash;
+  constructor(valueCursor, keyCursor, hash) {
+    this.valueCursor = valueCursor;
+    this.keyCursor = keyCursor;
+    this.hash = hash;
+  }
+}
+
+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, Number(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 += BigInt(readSize);
+    return readSize;
+  }
+  async readFully(buffer) {
+    if (this.size < this.relativePosition || this.size - this.relativePosition < BigInt(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 += BigInt(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 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 = 0n;
+  index = 0n;
+  stack = [];
+  nextCursorMaybe = null;
+  initialized = false;
+  constructor(cursor) {
+    this.cursor = cursor;
+  }
+  async init() {
+    if (this.initialized)
+      return;
+    this.initialized = true;
+    switch (this.cursor.slotPtr.slot.tag) {
+      case 0 /* NONE */:
+        this.size = 0n;
+        this.index = 0n;
+        this.stack = [];
+        break;
+      case 2 /* ARRAY_LIST */: {
+        const position = 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 = 0n;
+        this.stack = await this.initStack(this.cursor, header.ptr, INDEX_BLOCK_SIZE);
+        break;
+      }
+      case 3 /* LINKED_ARRAY_LIST */: {
+        const position = 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 = 0n;
+        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 = 0n;
+        this.index = 0n;
+        this.stack = await this.initStack(this.cursor, this.cursor.slotPtr.slot.value, INDEX_BLOCK_SIZE);
+        break;
+      case 12 /* COUNTED_HASH_MAP */:
+      case 13 /* COUNTED_HASH_SET */:
+        this.size = 0n;
+        this.index = 0n;
+        this.stack = await this.initStack(this.cursor, this.cursor.slotPtr.slot.value + 8n, 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() {
+    await this.init();
+    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() {
+    await this.init();
+    switch (this.cursor.slotPtr.slot.tag) {
+      case 0 /* NONE */:
+        return null;
+      case 2 /* ARRAY_LIST */:
+        if (!await this.hasNext())
+          return null;
+        this.index += 1n;
+        return this.nextInternal(INDEX_BLOCK_SIZE);
+      case 3 /* LINKED_ARRAY_LIST */:
+        if (!await this.hasNext())
+          return null;
+        this.index += 1n;
+        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 = 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 + BigInt(level.index * Slot.LENGTH);
+            return new ReadCursor(new SlotPointer(position, nextSlot), this.cursor.db);
+          } else {
+            continue;
+          }
+        }
+      }
+    }
+    return null;
+  }
+}
+var ReadCursor;
+var init_read_cursor = __esm(() => {
+  init_tag();
+  init_slot();
+  init_database();
+  init_exceptions();
+  init_writeable_data();
+  ReadCursor = 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 this.slotPtr.slot.value;
+    }
+    readInt() {
+      if (this.slotPtr.slot.tag !== 9 /* INT */) {
+        throw new UnexpectedTagException;
+      }
+      return 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) {
+      const bytesObj = await this.readBytesObject(maxSizeMaybe);
+      return bytesObj.value;
+    }
+    async readBytesObject(maxSizeMaybe) {
+      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(this.slotPtr.slot.value);
+          const valueSize = await reader.readLong();
+          if (maxSizeMaybe !== undefined && valueSize > maxSizeMaybe) {
+            throw new StreamTooLongException;
+          }
+          const startPosition = await this.db.core.position();
+          const value = new Uint8Array(Number(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 !== undefined && BigInt(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(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 = this.slotPtr.slot.value;
+      const keySlotPos = hashPos + BigInt(this.db.header.hashSize);
+      const valueSlotPos = keySlotPos + BigInt(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(this.slotPtr.slot.value);
+          const size = await reader.readLong();
+          const startPosition = await this.db.core.position();
+          return new Reader(this, size, startPosition, 0n);
+        }
+        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 + 1n;
+          return new Reader(this, BigInt(valueSize), startPosition, 0n);
+        }
+        default:
+          throw new UnexpectedTagException;
+      }
+    }
+    async count() {
+      const reader = this.db.core.reader();
+      switch (this.slotPtr.slot.tag) {
+        case 0 /* NONE */:
+          return 0n;
+        case 2 /* ARRAY_LIST */: {
+          await this.db.core.seek(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(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(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 BigInt(size);
+        }
+        case 12 /* COUNTED_HASH_MAP */:
+        case 13 /* COUNTED_HASH_SET */: {
+          await this.db.core.seek(this.slotPtr.slot.value);
+          return reader.readLong();
+        }
+        default:
+          throw new UnexpectedTagException;
+      }
+    }
+    async* [Symbol.asyncIterator]() {
+      const iterator = new CursorIterator(this);
+      await iterator.init();
+      while (await iterator.hasNext()) {
+        const next = await iterator.next();
+        if (next !== null) {
+          yield next;
+        }
+      }
+    }
+    iterator() {
+      return new CursorIterator(this);
+    }
+  };
+});
+
+// src/write-cursor.ts
+var exports_write_cursor = {};
+__export(exports_write_cursor, {
+  Writer: () => Writer,
+  WriteKeyValuePairCursor: () => WriteKeyValuePairCursor,
+  WriteCursorIterator: () => WriteCursorIterator,
+  WriteCursor: () => WriteCursor
+});
+
+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 += BigInt(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(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;
+    }
+  }
+}
+var WriteKeyValuePairCursor, WriteCursor, WriteCursorIterator;
+var init_write_cursor = __esm(() => {
+  init_tag();
+  init_slot();
+  init_database();
+  init_read_cursor();
+  init_exceptions();
+  WriteKeyValuePairCursor = class WriteKeyValuePairCursor extends KeyValuePairCursor {
+    valueCursor;
+    keyCursor;
+    constructor(valueCursor, keyCursor, hash) {
+      super(valueCursor, keyCursor, hash);
+      this.valueCursor = valueCursor;
+      this.keyCursor = keyCursor;
+    }
+  };
+  WriteCursor = 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(0n);
+      const startPosition = await this.db.core.length();
+      return new Writer(this, 0n, new Slot(ptrPos, 6 /* BYTES */), startPosition, 0n);
+    }
+    async* [Symbol.asyncIterator]() {
+      const iterator = new WriteCursorIterator(this);
+      await iterator.init();
+      while (await iterator.hasNext()) {
+        const next = await iterator.next();
+        if (next !== null) {
+          yield next;
+        }
+      }
+    }
+    iterator() {
+      return new WriteCursorIterator(this);
+    }
+  };
+  WriteCursorIterator = 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
+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, this.size, false);
+    view.setBigInt64(8, this.ptr, false);
+    return new Uint8Array(buffer);
+  }
+  static fromBytes(bytes) {
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    const size = checkLong(view.getBigInt64(0, false));
+    const ptr = checkLong(view.getBigInt64(8, false));
+    return new ArrayListHeader(ptr, size);
+  }
+  withPtr(ptr) {
+    return new ArrayListHeader(ptr, this.size);
+  }
+}
+
+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, this.size, false);
+    view.setBigInt64(8, 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 = checkLong(view.getBigInt64(0, false));
+    const ptr = checkLong(view.getBigInt64(8, false));
+    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 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(BigInt(Header.LENGTH));
+        const arrayListPtr = BigInt(Header.LENGTH + TopLevelArrayListHeader.LENGTH);
+        await writer.write(new TopLevelArrayListHeader(0n, new ArrayListHeader(arrayListPtr, 0n)).toBytes());
+        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+        await db.core.seek(0n);
+        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 + BigInt(ArrayListHeader.LENGTH);
+        await writer.write(new ArrayListHeader(arrayListPtr, 0n).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 = 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 + BigInt(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 = 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 < 0n ? header.size - bigAbs(index) : index;
+    const lastKey = header.size - 1n;
+    const shift = lastKey < BigInt(SLOT_COUNT) ? 0 : Math.floor(Math.log(Number(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 = 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 = 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 + BigInt(LinkedArrayListHeader.LENGTH);
+        await writer.write(new LinkedArrayListHeader(0, arrayListPtr, 0n).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 = 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 + BigInt(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(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 < 0n ? header.size - bigAbs(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 = 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 = 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 = 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(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 = 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 < 0n ? origHeader.size - bigAbs(index) : index;
+    const headerA = await db.readLinkedArrayListSlice(origHeader, 0n, 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 = 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 < 0n ? origHeader.size - bigAbs(index) : index;
+    const headerA = await db.readLinkedArrayListSlice(origHeader, 0n, key);
+    const headerB = await db.readLinkedArrayListSlice(origHeader, key + 1n, origHeader.size - (key + 1n));
+    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(BigInt(Header.LENGTH));
+        if (this.counted) {
+          await writer.writeLong(0n);
+        }
+        await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
+        await db.core.seek(0n);
+        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(0n);
+        }
+        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 = 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 ? slotPtr.slot.value + 8n : 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(slotPtr.slot.value);
+      const mapCount = await reader.readLong();
+      await db.core.seek(slotPtr.slot.value);
+      await writer.writeLong(mapCount + 1n);
+    }
+    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 ? slotPtr.slot.value + 8n : 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(slotPtr.slot.value);
+      const mapCount = await reader.readLong();
+      await db.core.seek(slotPtr.slot.value);
+      await writer.writeLong(mapCount - 1n);
+    }
+    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) {
+      if (data.value < 0n) {
+        throw new Error("Uint must not be negative");
+      }
+      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 { WriteCursor: WriteCursor2 } = await Promise.resolve().then(() => (init_write_cursor(), exports_write_cursor));
+        const nextCursor = new WriteCursor2(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 { WriteCursor: WriteCursor2 } = await Promise.resolve().then(() => (init_write_cursor(), exports_write_cursor));
+    const nextCursor = new WriteCursor2(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 < 0n) {
+    throw new ExpectedUnsignedLongException;
+  }
+  return n;
+}
+function bigAbs(n) {
+  return n < 0n ? -n : 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(0n);
+    if (await core.length() === 0n) {
+      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;
+  }
+  async rootCursor() {
+    const { WriteCursor: WriteCursor2 } = await Promise.resolve().then(() => (init_write_cursor(), exports_write_cursor));
+    if (this.header.tag === 0 /* NONE */) {
+      await this.core.seek(0n);
+      this.header = await Header.read(this.core);
+    }
+    return new WriteCursor2(new SlotPointer(null, new Slot(BigInt(Header.LENGTH), this.header.tag)), this);
+  }
+  async freeze() {
+    if (this.txStart !== null) {
+      this.txStart = await this.core.length();
+    } else {
+      throw new ExpectedTxStartException;
+    }
+  }
+  async truncate() {
+    if (this.header.tag !== 2 /* ARRAY_LIST */)
+      return;
+    const rootCursor = await this.rootCursor();
+    const listSize = await rootCursor.count();
+    if (listSize === 0n)
+      return;
+    await this.core.seek(BigInt(Header.LENGTH + ArrayListHeader.LENGTH));
+    const reader = this.core.reader();
+    const headerFileSize = await reader.readLong();
+    if (headerFileSize === 0n)
+      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 + BigInt(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 = 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 + BigInt(this.header.hashSize);
+            const valueSlotPos = keySlotPos + BigInt(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 + BigInt(this.header.hashSize);
+                const valueSlotPos2 = keySlotPos2 + BigInt(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 + BigInt(this.header.hashSize);
+          const valueSlotPos = keySlotPos + BigInt(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 + BigInt(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 + BigInt(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(slot.value, keyHash, keyOffset + 1, isTopLevel);
+        break;
+      case 5 /* KV_PAIR */: {
+        await this.core.seek(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 + BigInt(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 < BigInt(SLOT_COUNT) ? 0 : Math.floor(Math.log(Number(key - 1n)) / Math.log(SLOT_COUNT));
+    const nextShift = key < BigInt(SLOT_COUNT) ? 0 : Math.floor(Math.log(Number(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 + 1n), slotPtr);
+  }
+  async readArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
+    if (shift >= MAX_BRANCH_LENGTH)
+      throw new MaxShiftExceededException;
+    const reader = this.core.reader();
+    const i = Number(key >> BigInt(shift * BIT_COUNT) & MASK);
+    const slotPos = indexPos + BigInt(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 = 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(BigInt(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 < 0n) {
+      throw new KeyNotFoundException;
+    }
+    const prevShift = header.size < BigInt(SLOT_COUNT + 1) ? 0 : Math.floor(Math.log(Number(header.size - 1n)) / Math.log(SLOT_COUNT));
+    const nextShift = size < BigInt(SLOT_COUNT + 1) ? 0 : Math.floor(Math.log(Number(size - 1n)) / 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 = 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(0n, 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(0n, newSlot).toBytes());
+    if (header.size < BigInt(SLOT_COUNT) && shift > 0) {
+      throw new MustSetNewSlotsToFullException;
+    }
+    return new LinkedArrayListAppendResult(new LinkedArrayListHeader(shift, ptr, header.size + 1n), slotPtr);
+  }
+  static blockLeafCount(block, shift, i) {
+    let n = 0n;
+    if (shift === 0) {
+      for (let blockI = 0;blockI < block.length; blockI++) {
+        const blockSlot = block[blockI];
+        if (!blockSlot.slot.empty() || blockI === i) {
+          n += 1n;
+        }
+      }
+    } else {
+      for (const blockSlot of block) {
+        n += blockSlot.size;
+      }
+    }
+    return n;
+  }
+  static slotLeafCount(slot, shift) {
+    if (shift === 0) {
+      if (slot.slot.empty()) {
+        return 0n;
+      } else {
+        return 1n;
+      }
+    } else {
+      return slot.size;
+    }
+  }
+  static keyAndIndexForLinkedArrayList(slotBlock, key, shift) {
+    let nextKey = key;
+    let i = 0;
+    const maxLeafCount = shift === 0 ? 1n : BigInt(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 + BigInt(LinkedArrayListSlot2.LENGTH * i);
+    if (shift === 0) {
+      const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
+      return new LinkedArrayListSlotPointer(new SlotPointer(slotPos, slot.slot), leafCount);
+    }
+    const ptr = 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(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(0n, 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 === 0n ? 0n : offset + size - 1n;
+    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 > 0n) {
+          if (nextSlots[0] !== null) {
+            newRootBlock[slotI] = nextSlots[0];
+          } else {
+            newRootBlock[slotI] = leftBlock.block[leftBlock.i];
+          }
+          slotI += 1;
+        }
+        if (size > 1n) {
+          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 = 0n;
+            for (let k = 0;k < blockMaybe.length; k++) {
+              const blockSlot = blockMaybe[k];
+              await writer.write(blockSlot.toBytes());
+              if (isLeafNode) {
+                if (!blockSlot.slot.empty()) {
+                  leafCount += 1n;
+                }
+              } 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, rootSlot.slot.value, size);
+  }
+  async readLinkedArrayListConcat(headerA, headerB) {
+    const writer = this.core.writer();
+    const blocksA = [];
+    const keyA = headerA.size === 0n ? 0n : headerA.size - 1n;
+    await this.readLinkedArrayListBlocks(headerA.ptr, keyA, headerA.shift, blocksA);
+    const blocksB = [];
+    await this.readLinkedArrayListBlocks(headerB.ptr, 0n, 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 = 0n;
+        for (const blockSlot of block) {
+          await writer.write(blockSlot.toBytes());
+          if (isLeafNode) {
+            if (!blockSlot.slot.empty()) {
+              leafCount += 1n;
+            }
+          } 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 = nextSlots[0].slot.value;
+      }
+    } else {
+      rootPtr = headerA.ptr;
+    }
+    return new LinkedArrayListHeader(nextShift, rootPtr, headerA.size + headerB.size);
+  }
+}
+var VERSION = 0, MAGIC_NUMBER, BIT_COUNT = 4, SLOT_COUNT, MASK, INDEX_BLOCK_SIZE, LINKED_ARRAY_LIST_SLOT_LENGTH, LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE, MAX_BRANCH_LENGTH = 16, WriteMode, TopLevelArrayListHeader, LinkedArrayListSlot2;
+var init_database = __esm(() => {
+  init_tag();
+  init_slot();
+  init_exceptions();
+  init_writeable_data();
+  MAGIC_NUMBER = new Uint8Array([120, 105, 116]);
+  SLOT_COUNT = 1 << BIT_COUNT;
+  MASK = BigInt(SLOT_COUNT - 1);
+  INDEX_BLOCK_SIZE = Slot.LENGTH * SLOT_COUNT;
+  LINKED_ARRAY_LIST_SLOT_LENGTH = 8 + Slot.LENGTH;
+  LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE = LINKED_ARRAY_LIST_SLOT_LENGTH * SLOT_COUNT;
+  ((WriteMode2) => {
+    WriteMode2[WriteMode2["READ_ONLY"] = 0] = "READ_ONLY";
+    WriteMode2[WriteMode2["READ_WRITE"] = 1] = "READ_WRITE";
+  })(WriteMode ||= {});
+  TopLevelArrayListHeader = 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, this.fileSize, false);
+      return arr;
+    }
+  };
+  LinkedArrayListSlot2 = 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, 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 = checkLong(view.getBigInt64(Slot.LENGTH, false));
+      return new LinkedArrayListSlot2(size, slot);
+    }
+  };
+});
+
+// src/index.ts
+init_tag();
+init_slot();
+init_writeable_data();
+init_exceptions();
+
+// src/random-access-memory.ts
+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, 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 view.getBigInt64(0, false);
+  }
+}
+// src/core-memory.ts
+class CoreMemory {
+  memory;
+  constructor(memory) {
+    this.memory = memory;
+  }
+  reader() {
+    return this.memory;
+  }
+  writer() {
+    return this.memory;
+  }
+  async length() {
+    return BigInt(this.memory.size());
+  }
+  async seek(pos) {
+    this.memory.seek(Number(pos));
+  }
+  async position() {
+    return BigInt(this.memory.getPosition());
+  }
+  async setLength(len) {
+    this.memory.setLength(Number(len));
+  }
+  async flush() {}
+  async sync() {}
+}
+// src/core-file.ts
+class FileDataReader {
+  file;
+  position;
+  buffer = null;
+  bufferStart = 0;
+  bufferEnd = 0;
+  constructor(file, position) {
+    this.file = file;
+    this.position = position;
+  }
+  setPosition(pos) {
+    this.position = pos;
+  }
+  getPosition() {
+    return this.position;
+  }
+  async readFully(b) {
+    const slice = this.file.slice(this.position, this.position + b.length);
+    const data = await slice.arrayBuffer();
+    b.set(new Uint8Array(data));
+    this.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 view.getBigInt64(0, false);
+  }
+}
+
+class FileDataWriter {
+  filePath;
+  position;
+  pendingWrites = [];
+  constructor(filePath, position) {
+    this.filePath = filePath;
+    this.position = position;
+  }
+  setPosition(pos) {
+    this.position = pos;
+  }
+  getPosition() {
+    return this.position;
+  }
+  async write(buffer) {
+    const file = Bun.file(this.filePath);
+    const currentSize = file.size;
+    if (this.position >= currentSize) {
+      const existingData = currentSize > 0 ? new Uint8Array(await file.arrayBuffer()) : new Uint8Array(0);
+      const newData = new Uint8Array(this.position + buffer.length);
+      newData.set(existingData);
+      newData.set(buffer, this.position);
+      await Bun.write(this.filePath, newData);
+    } else {
+      const existingData = new Uint8Array(await file.arrayBuffer());
+      const newSize = Math.max(existingData.length, this.position + buffer.length);
+      const newData = new Uint8Array(newSize);
+      newData.set(existingData);
+      newData.set(buffer, this.position);
+      await Bun.write(this.filePath, newData);
+    }
+    this.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, v, false);
+    await this.write(new Uint8Array(buffer));
+  }
+}
+
+class CoreFile {
+  filePath;
+  _position = 0;
+  _reader;
+  _writer;
+  constructor(filePath) {
+    this.filePath = filePath;
+    this._reader = new FileDataReader(Bun.file(filePath), 0);
+    this._writer = new FileDataWriter(filePath, 0);
+  }
+  static async create(filePath) {
+    const file = Bun.file(filePath);
+    if (!await file.exists()) {
+      await Bun.write(filePath, new Uint8Array(0));
+    }
+    return new CoreFile(filePath);
+  }
+  reader() {
+    return this._reader;
+  }
+  writer() {
+    return this._writer;
+  }
+  async length() {
+    const file = Bun.file(this.filePath);
+    return BigInt(file.size);
+  }
+  async seek(pos) {
+    this._position = Number(pos);
+    this._reader.setPosition(this._position);
+    this._writer.setPosition(this._position);
+  }
+  async position() {
+    return BigInt(this._reader.getPosition());
+  }
+  async setLength(len) {
+    const file = Bun.file(this.filePath);
+    const currentData = new Uint8Array(await file.arrayBuffer());
+    const newData = currentData.slice(0, Number(len));
+    await Bun.write(this.filePath, newData);
+  }
+  async flush() {}
+  async sync() {}
+}
+// 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/index.ts
+init_database();
+init_read_cursor();
+init_write_cursor();
+
+// src/read-array-list.ts
+init_tag();
+init_database();
+init_exceptions();
+
+class ReadArrayList {
+  cursor;
+  constructor(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();
+  }
+  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
+init_database();
+
+class WriteArrayList extends ReadArrayList {
+  constructor(cursor) {
+    super(cursor);
+  }
+  static async create(cursor) {
+    const newCursor = await cursor.writePath([new ArrayListInit]);
+    return new WriteArrayList(newCursor);
+  }
+  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
+init_tag();
+init_database();
+init_exceptions();
+
+class ReadHashMap {
+  cursor;
+  constructor() {}
+  static async create(cursor) {
+    const map = new ReadHashMap;
+    switch (cursor.slotPtr.slot.tag) {
+      case 0 /* NONE */:
+      case 4 /* HASH_MAP */:
+      case 11 /* HASH_SET */:
+        map.cursor = cursor;
+        break;
+      default:
+        throw new UnexpectedTagException;
+    }
+    return map;
+  }
+  slot() {
+    return this.cursor.slot();
+  }
+  iterator() {
+    return this.cursor.iterator();
+  }
+  async* [Symbol.asyncIterator]() {
+    yield* this.cursor;
+  }
+  async getCursorByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.getCursor(hash);
+  }
+  async getSlotByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.getSlot(hash);
+  }
+  async getKeyCursorByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.getKeyCursor(hash);
+  }
+  async getKeySlotByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.getKeySlot(hash);
+  }
+  async getKeyValuePairByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.getKeyValuePair(hash);
+  }
+  async getCursorByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.getCursor(hash);
+  }
+  async getSlotByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.getSlot(hash);
+  }
+  async getKeyCursorByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.getKeyCursor(hash);
+  }
+  async getKeySlotByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.getKeySlot(hash);
+  }
+  async getKeyValuePairByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.getKeyValuePair(hash);
+  }
+  async getCursor(hash) {
+    return this.cursor.readPath([new HashMapGet(new HashMapGetValue(hash))]);
+  }
+  async getSlot(hash) {
+    return this.cursor.readPathSlot([new HashMapGet(new HashMapGetValue(hash))]);
+  }
+  async getKeyCursor(hash) {
+    return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
+  }
+  async getKeySlot(hash) {
+    return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
+  }
+  async getKeyValuePair(hash) {
+    const cursor = await this.cursor.readPath([new HashMapGet(new HashMapGetKVPair(hash))]);
+    if (cursor === null) {
+      return null;
+    } else {
+      return cursor.readKeyValuePair();
+    }
+  }
+}
+// src/write-hash-map.ts
+init_database();
+init_writeable_data();
+init_exceptions();
+
+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;
+  }
+  iterator() {
+    return this.cursor.iterator();
+  }
+  async* [Symbol.asyncIterator]() {
+    yield* this.cursor;
+  }
+  async putByString(key, data) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    await this.putKey(hash, new Bytes(key));
+    await this.put(hash, data);
+  }
+  async putCursorByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    await this.putKey(hash, new Bytes(key));
+    return this.putCursor(hash);
+  }
+  async putKeyByString(key, data) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    await this.putKey(hash, data);
+  }
+  async putKeyCursorByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.putKeyCursor(hash);
+  }
+  async removeByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.remove(hash);
+  }
+  async putByBytes(key, data) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    await this.putKey(hash, key);
+    await this.put(hash, data);
+  }
+  async putCursorByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    await this.putKey(hash, key);
+    return this.putCursor(hash);
+  }
+  async putKeyByBytes(key, data) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    await this.putKey(hash, data);
+  }
+  async putKeyCursorByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.putKeyCursor(hash);
+  }
+  async removeByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.remove(hash);
+  }
+  async put(hash, data) {
+    await this.cursor.writePath([
+      new HashMapGet(new HashMapGetValue(hash)),
+      new WriteData(data)
+    ]);
+  }
+  async putCursor(hash) {
+    return this.cursor.writePath([
+      new HashMapGet(new HashMapGetValue(hash))
+    ]);
+  }
+  async putKey(hash, data) {
+    const cursor = await this.cursor.writePath([
+      new HashMapGet(new HashMapGetKey(hash))
+    ]);
+    await cursor.writeIfEmpty(data);
+  }
+  async putKeyCursor(hash) {
+    return this.cursor.writePath([
+      new HashMapGet(new HashMapGetKey(hash))
+    ]);
+  }
+  async remove(hash) {
+    try {
+      await this.cursor.writePath([new HashMapRemove(hash)]);
+    } catch (e) {
+      if (e instanceof KeyNotFoundException) {
+        return false;
+      }
+      throw e;
+    }
+    return true;
+  }
+}
+// src/read-hash-set.ts
+init_tag();
+init_database();
+init_exceptions();
+
+class ReadHashSet {
+  cursor;
+  constructor() {}
+  static async create(cursor) {
+    const set = new ReadHashSet;
+    switch (cursor.slotPtr.slot.tag) {
+      case 0 /* NONE */:
+      case 4 /* HASH_MAP */:
+      case 11 /* HASH_SET */:
+        set.cursor = cursor;
+        break;
+      default:
+        throw new UnexpectedTagException;
+    }
+    return set;
+  }
+  slot() {
+    return this.cursor.slot();
+  }
+  iterator() {
+    return this.cursor.iterator();
+  }
+  async* [Symbol.asyncIterator]() {
+    yield* this.cursor;
+  }
+  async getCursorByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.getCursor(hash);
+  }
+  async getSlotByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.getSlot(hash);
+  }
+  async getCursorByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.getCursor(hash);
+  }
+  async getSlotByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.getSlot(hash);
+  }
+  async getCursor(hash) {
+    return this.cursor.readPath([new HashMapGet(new HashMapGetKey(hash))]);
+  }
+  async getSlot(hash) {
+    return this.cursor.readPathSlot([new HashMapGet(new HashMapGetKey(hash))]);
+  }
+}
+// src/write-hash-set.ts
+init_database();
+init_writeable_data();
+init_exceptions();
+
+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;
+  }
+  iterator() {
+    return this.cursor.iterator();
+  }
+  async* [Symbol.asyncIterator]() {
+    yield* this.cursor;
+  }
+  async putByString(key) {
+    const bytes = new TextEncoder().encode(key);
+    const hash = await this.cursor.db.hasher.digest(bytes);
+    await this.put(hash, new Bytes(bytes));
+  }
+  async putCursorByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.putCursor(hash);
+  }
+  async removeByString(key) {
+    const hash = await this.cursor.db.hasher.digest(new TextEncoder().encode(key));
+    return this.remove(hash);
+  }
+  async putByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    await this.put(hash, key);
+  }
+  async putCursorByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.putCursor(hash);
+  }
+  async removeByBytes(key) {
+    const hash = await this.cursor.db.hasher.digest(key.value);
+    return this.remove(hash);
+  }
+  async put(hash, data) {
+    const cursor = await this.cursor.writePath([
+      new HashMapGet(new HashMapGetKey(hash))
+    ]);
+    await cursor.writeIfEmpty(data);
+  }
+  async putCursor(hash) {
+    return this.cursor.writePath([
+      new HashMapGet(new HashMapGetKey(hash))
+    ]);
+  }
+  async remove(hash) {
+    try {
+      await this.cursor.writePath([new HashMapRemove(hash)]);
+    } catch (e) {
+      if (e instanceof KeyNotFoundException) {
+        return false;
+      }
+      throw e;
+    }
+    return true;
+  }
+}
+// src/read-linked-array-list.ts
+init_tag();
+init_database();
+init_exceptions();
+
+class ReadLinkedArrayList {
+  cursor;
+  constructor(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();
+  }
+  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
+init_database();
+
+class WriteLinkedArrayList extends ReadLinkedArrayList {
+  constructor(cursor) {
+    super(cursor);
+  }
+  static async create(cursor) {
+    const newCursor = await cursor.writePath([new LinkedArrayListInit]);
+    return new WriteLinkedArrayList(newCursor);
+  }
+  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
+init_tag();
+init_exceptions();
+
+class ReadCountedHashMap extends ReadHashMap {
+  constructor() {
+    super();
+  }
+  static async create(cursor) {
+    const map = new ReadCountedHashMap;
+    switch (cursor.slotPtr.slot.tag) {
+      case 0 /* NONE */:
+      case 12 /* COUNTED_HASH_MAP */:
+      case 13 /* COUNTED_HASH_SET */:
+        map.cursor = cursor;
+        break;
+      default:
+        throw new UnexpectedTagException;
+    }
+    return map;
+  }
+  async count() {
+    return this.cursor.count();
+  }
+}
+// src/write-counted-hash-map.ts
+init_tag();
+init_database();
+init_exceptions();
+
+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
+init_tag();
+init_exceptions();
+
+class ReadCountedHashSet extends ReadHashSet {
+  constructor() {
+    super();
+  }
+  static async create(cursor) {
+    const set = new ReadCountedHashSet;
+    switch (cursor.slotPtr.slot.tag) {
+      case 0 /* NONE */:
+      case 12 /* COUNTED_HASH_MAP */:
+      case 13 /* COUNTED_HASH_SET */:
+        set.cursor = cursor;
+        break;
+      default:
+        throw new UnexpectedTagException;
+    }
+    return set;
+  }
+  async count() {
+    return this.cursor.count();
+  }
+}
+// src/write-counted-hash-set.ts
+init_tag();
+init_database();
+init_exceptions();
+
+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,
+  RandomAccessMemory,
+  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,
+  Context,
+  Bytes,
+  BIT_COUNT,
+  ArrayListSlice,
+  ArrayListInit,
+  ArrayListHeader,
+  ArrayListGet2 as ArrayListGet,
+  ArrayListAppend
+};