xitdb 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,5 +1,20 @@
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
 var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
@@ -10,6 +25,7 @@ var __export = (target, all) => {
     });
 };
 var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
 
 // src/tag.ts
 function tagValueOf(n) {
@@ -45,7 +61,7 @@ class Slot {
   tag;
   full;
   constructor(value = 0n, tag = 0 /* NONE */, full = false) {
-    this.value = value;
+    this.value = typeof value === "bigint" ? value : BigInt(value);
     this.tag = tag;
     this.full = full;
   }
@@ -159,7 +175,7 @@ var init_exceptions = __esm(() => {
 class Uint {
   value;
   constructor(value) {
-    if (value < 0n) {
+    if (value < 0) {
       throw new Error("Uint must not be negative");
     }
     this.value = value;
@@ -246,24 +262,24 @@ class Reader {
     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));
+    const readSize = Math.min(buffer.length, this.size - this.relativePosition);
     if (readSize === 0)
       return -1;
     const reader = this.parent.db.core.reader();
     const tempBuffer = new Uint8Array(readSize);
     await reader.readFully(tempBuffer);
     buffer.set(tempBuffer);
-    this.relativePosition += BigInt(readSize);
+    this.relativePosition += readSize;
     return readSize;
   }
   async readFully(buffer) {
-    if (this.size < this.relativePosition || this.size - this.relativePosition < BigInt(buffer.length)) {
+    if (this.size < this.relativePosition || this.size - this.relativePosition < buffer.length) {
       throw new EndOfStreamException;
     }
     await this.parent.db.core.seek(this.startPosition + this.relativePosition);
     const reader = this.parent.db.core.reader();
     await reader.readFully(buffer);
-    this.relativePosition += BigInt(buffer.length);
+    this.relativePosition += buffer.length;
   }
   async readByte() {
     const bytes = new Uint8Array(1);
@@ -289,7 +305,7 @@ class Reader {
     const bytes = new Uint8Array(readSize);
     await this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getBigInt64(0, false);
+    return Number(view.getBigInt64(0, false));
   }
   seek(position) {
     if (position > this.size) {
@@ -312,8 +328,8 @@ class IteratorLevel {
 
 class CursorIterator {
   cursor;
-  size = 0n;
-  index = 0n;
+  size = 0;
+  index = 0;
   stack = [];
   nextCursorMaybe = null;
   initialized = false;
@@ -326,45 +342,45 @@ class CursorIterator {
     this.initialized = true;
     switch (this.cursor.slotPtr.slot.tag) {
       case 0 /* NONE */:
-        this.size = 0n;
-        this.index = 0n;
+        this.size = 0;
+        this.index = 0;
         this.stack = [];
         break;
       case 2 /* ARRAY_LIST */: {
-        const position = this.cursor.slotPtr.slot.value;
+        const position = Number(this.cursor.slotPtr.slot.value);
         await this.cursor.db.core.seek(position);
         const reader = this.cursor.db.core.reader();
         const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
         await reader.readFully(headerBytes);
         const header = ArrayListHeader.fromBytes(headerBytes);
         this.size = await this.cursor.count();
-        this.index = 0n;
+        this.index = 0;
         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;
+        const position = Number(this.cursor.slotPtr.slot.value);
         await this.cursor.db.core.seek(position);
         const reader = this.cursor.db.core.reader();
         const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
         await reader.readFully(headerBytes);
         const header = LinkedArrayListHeader.fromBytes(headerBytes);
         this.size = await this.cursor.count();
-        this.index = 0n;
+        this.index = 0;
         this.stack = await this.initStack(this.cursor, header.ptr, LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
         break;
       }
       case 4 /* HASH_MAP */:
       case 11 /* HASH_SET */:
-        this.size = 0n;
-        this.index = 0n;
-        this.stack = await this.initStack(this.cursor, this.cursor.slotPtr.slot.value, INDEX_BLOCK_SIZE);
+        this.size = 0;
+        this.index = 0;
+        this.stack = await this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value), INDEX_BLOCK_SIZE);
         break;
       case 12 /* COUNTED_HASH_MAP */:
       case 13 /* COUNTED_HASH_SET */:
-        this.size = 0n;
-        this.index = 0n;
-        this.stack = await this.initStack(this.cursor, this.cursor.slotPtr.slot.value + 8n, INDEX_BLOCK_SIZE);
+        this.size = 0;
+        this.index = 0;
+        this.stack = await this.initStack(this.cursor, Number(this.cursor.slotPtr.slot.value) + 8, INDEX_BLOCK_SIZE);
         break;
       default:
         throw new UnexpectedTagException;
@@ -412,12 +428,12 @@ class CursorIterator {
       case 2 /* ARRAY_LIST */:
         if (!await this.hasNext())
           return null;
-        this.index += 1n;
+        this.index += 1;
         return this.nextInternal(INDEX_BLOCK_SIZE);
       case 3 /* LINKED_ARRAY_LIST */:
         if (!await this.hasNext())
           return null;
-        this.index += 1n;
+        this.index += 1;
         return this.nextInternal(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE);
       case 4 /* HASH_MAP */:
       case 11 /* HASH_SET */:
@@ -446,7 +462,7 @@ class CursorIterator {
       } else {
         const nextSlot = level.block[level.index];
         if (nextSlot.tag === 1 /* INDEX */) {
-          const nextPos = nextSlot.value;
+          const nextPos = Number(nextSlot.value);
           await this.cursor.db.core.seek(nextPos);
           const reader = this.cursor.db.core.reader();
           const indexBlockBytes = new Uint8Array(blockSize);
@@ -462,7 +478,7 @@ class CursorIterator {
         } else {
           this.stack[this.stack.length - 1].index += 1;
           if (!nextSlot.empty()) {
-            const position = level.position + BigInt(level.index * Slot.LENGTH);
+            const position = level.position + level.index * Slot.LENGTH;
             return new ReadCursor(new SlotPointer(position, nextSlot), this.cursor.db);
           } else {
             continue;
@@ -522,13 +538,13 @@ var init_read_cursor = __esm(() => {
       }
       if (this.slotPtr.slot.value < 0n)
         throw new ExpectedUnsignedLongException;
-      return this.slotPtr.slot.value;
+      return Number(this.slotPtr.slot.value);
     }
     readInt() {
       if (this.slotPtr.slot.tag !== 9 /* INT */) {
         throw new UnexpectedTagException;
       }
-      return this.slotPtr.slot.value;
+      return Number(this.slotPtr.slot.value);
     }
     readFloat() {
       if (this.slotPtr.slot.tag !== 10 /* FLOAT */) {
@@ -539,23 +555,23 @@ var init_read_cursor = __esm(() => {
       view.setBigInt64(0, this.slotPtr.slot.value, false);
       return view.getFloat64(0, false);
     }
-    async readBytes(maxSizeMaybe) {
+    async readBytes(maxSizeMaybe = null) {
       const bytesObj = await this.readBytesObject(maxSizeMaybe);
       return bytesObj.value;
     }
-    async readBytesObject(maxSizeMaybe) {
+    async readBytesObject(maxSizeMaybe = null) {
       const reader = this.db.core.reader();
       switch (this.slotPtr.slot.tag) {
         case 0 /* NONE */:
           return new Bytes(new Uint8Array(0));
         case 6 /* BYTES */: {
-          await this.db.core.seek(this.slotPtr.slot.value);
+          await this.db.core.seek(Number(this.slotPtr.slot.value));
           const valueSize = await reader.readLong();
-          if (maxSizeMaybe !== undefined && valueSize > maxSizeMaybe) {
+          if (maxSizeMaybe !== null && valueSize > maxSizeMaybe) {
             throw new StreamTooLongException;
           }
-          const startPosition = await this.db.core.position();
-          const value = new Uint8Array(Number(valueSize));
+          const startPosition = this.db.core.position();
+          const value = new Uint8Array(valueSize);
           await reader.readFully(value);
           let formatTag = null;
           if (this.slotPtr.slot.full) {
@@ -577,7 +593,7 @@ var init_read_cursor = __esm(() => {
               break;
             valueSize += 1;
           }
-          if (maxSizeMaybe !== undefined && BigInt(valueSize) > maxSizeMaybe) {
+          if (maxSizeMaybe !== null && valueSize > maxSizeMaybe) {
             throw new StreamTooLongException;
           }
           let formatTag = null;
@@ -595,23 +611,23 @@ var init_read_cursor = __esm(() => {
       if (this.slotPtr.slot.tag !== 5 /* KV_PAIR */) {
         throw new UnexpectedTagException;
       }
-      await this.db.core.seek(this.slotPtr.slot.value);
+      await this.db.core.seek(Number(this.slotPtr.slot.value));
       const kvPairBytes = new Uint8Array(KeyValuePair.length(this.db.header.hashSize));
       await reader.readFully(kvPairBytes);
       const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.db.header.hashSize);
-      const hashPos = this.slotPtr.slot.value;
-      const keySlotPos = hashPos + BigInt(this.db.header.hashSize);
-      const valueSlotPos = keySlotPos + BigInt(Slot.LENGTH);
+      const hashPos = Number(this.slotPtr.slot.value);
+      const keySlotPos = hashPos + this.db.header.hashSize;
+      const valueSlotPos = keySlotPos + Slot.LENGTH;
       return new KeyValuePairCursor(new ReadCursor(new SlotPointer(valueSlotPos, kvPair.valueSlot), this.db), new ReadCursor(new SlotPointer(keySlotPos, kvPair.keySlot), this.db), kvPair.hash);
     }
     async reader() {
       const reader = this.db.core.reader();
       switch (this.slotPtr.slot.tag) {
         case 6 /* BYTES */: {
-          await this.db.core.seek(this.slotPtr.slot.value);
+          await this.db.core.seek(Number(this.slotPtr.slot.value));
           const size = await reader.readLong();
-          const startPosition = await this.db.core.position();
-          return new Reader(this, size, startPosition, 0n);
+          const startPosition = this.db.core.position();
+          return new Reader(this, size, startPosition, 0);
         }
         case 7 /* SHORT_BYTES */: {
           const buffer = new ArrayBuffer(8);
@@ -625,8 +641,8 @@ var init_read_cursor = __esm(() => {
               break;
             valueSize += 1;
           }
-          const startPosition = this.slotPtr.position + 1n;
-          return new Reader(this, BigInt(valueSize), startPosition, 0n);
+          const startPosition = this.slotPtr.position + 1;
+          return new Reader(this, valueSize, startPosition, 0);
         }
         default:
           throw new UnexpectedTagException;
@@ -636,23 +652,23 @@ var init_read_cursor = __esm(() => {
       const reader = this.db.core.reader();
       switch (this.slotPtr.slot.tag) {
         case 0 /* NONE */:
-          return 0n;
+          return 0;
         case 2 /* ARRAY_LIST */: {
-          await this.db.core.seek(this.slotPtr.slot.value);
+          await this.db.core.seek(Number(this.slotPtr.slot.value));
           const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
           await reader.readFully(headerBytes);
           const header = ArrayListHeader.fromBytes(headerBytes);
           return header.size;
         }
         case 3 /* LINKED_ARRAY_LIST */: {
-          await this.db.core.seek(this.slotPtr.slot.value);
+          await this.db.core.seek(Number(this.slotPtr.slot.value));
           const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
           await reader.readFully(headerBytes);
           const header = LinkedArrayListHeader.fromBytes(headerBytes);
           return header.size;
         }
         case 6 /* BYTES */: {
-          await this.db.core.seek(this.slotPtr.slot.value);
+          await this.db.core.seek(Number(this.slotPtr.slot.value));
           return reader.readLong();
         }
         case 7 /* SHORT_BYTES */: {
@@ -667,11 +683,11 @@ var init_read_cursor = __esm(() => {
               break;
             size += 1;
           }
-          return BigInt(size);
+          return size;
         }
         case 12 /* COUNTED_HASH_MAP */:
         case 13 /* COUNTED_HASH_SET */: {
-          await this.db.core.seek(this.slotPtr.slot.value);
+          await this.db.core.seek(Number(this.slotPtr.slot.value));
           return reader.readLong();
         }
         default:
@@ -723,7 +739,7 @@ class Writer {
     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);
+    this.relativePosition += buffer.length;
     if (this.relativePosition > this.size) {
       this.size = this.relativePosition;
     }
@@ -738,7 +754,7 @@ class Writer {
         throw new UnexpectedWriterPositionException;
       await writer.write(this.formatTag);
     }
-    await this.parent.db.core.seek(this.slot.value);
+    await this.parent.db.core.seek(Number(this.slot.value));
     await writer.writeLong(this.size);
     if (this.parent.slotPtr.position === null)
       throw new CursorNotWriteableException;
@@ -797,9 +813,9 @@ var init_write_cursor = __esm(() => {
       const writer = this.db.core.writer();
       const ptrPos = await this.db.core.length();
       await this.db.core.seek(ptrPos);
-      await writer.writeLong(0n);
+      await writer.writeLong(0);
       const startPosition = await this.db.core.length();
-      return new Writer(this, 0n, new Slot(ptrPos, 6 /* BYTES */), startPosition, 0n);
+      return new Writer(this, 0, new Slot(ptrPos, 6 /* BYTES */), startPosition, 0);
     }
     async* [Symbol.asyncIterator]() {
       const iterator = new WriteCursorIterator(this);
@@ -895,14 +911,16 @@ class ArrayListHeader {
   toBytes() {
     const buffer = new ArrayBuffer(ArrayListHeader.LENGTH);
     const view = new DataView(buffer);
-    view.setBigInt64(0, this.size, false);
-    view.setBigInt64(8, this.ptr, false);
+    view.setBigInt64(0, BigInt(this.size), false);
+    view.setBigInt64(8, BigInt(this.ptr), false);
     return new Uint8Array(buffer);
   }
   static fromBytes(bytes) {
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const size = checkLong(view.getBigInt64(0, false));
-    const ptr = checkLong(view.getBigInt64(8, false));
+    const size = Number(view.getBigInt64(0, false));
+    checkLong(size);
+    const ptr = Number(view.getBigInt64(8, false));
+    checkLong(ptr);
     return new ArrayListHeader(ptr, size);
   }
   withPtr(ptr) {
@@ -923,15 +941,17 @@ class LinkedArrayListHeader {
   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.setBigInt64(0, BigInt(this.size), false);
+    view.setBigInt64(8, BigInt(this.ptr), false);
     view.setUint8(16, this.shift & 63);
     return new Uint8Array(buffer);
   }
   static fromBytes(bytes) {
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    const size = checkLong(view.getBigInt64(0, false));
-    const ptr = checkLong(view.getBigInt64(8, false));
+    const size = Number(view.getBigInt64(0, false));
+    checkLong(size);
+    const ptr = Number(view.getBigInt64(8, false));
+    checkLong(ptr);
     const shift = view.getUint8(16) & 63;
     return new LinkedArrayListHeader(shift, ptr, size);
   }
@@ -1024,11 +1044,11 @@ class ArrayListInit {
     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 db.core.seek(Header.LENGTH);
+        const arrayListPtr = Header.LENGTH + TopLevelArrayListHeader.LENGTH;
+        await writer.write(new TopLevelArrayListHeader(0, new ArrayListHeader(arrayListPtr, 0)).toBytes());
         await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        await db.core.seek(0n);
+        await db.core.seek(0);
         db.header = db.header.withTag(2 /* ARRAY_LIST */);
         await writer.write(db.header.toBytes());
       }
@@ -1043,8 +1063,8 @@ class ArrayListInit {
         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());
+        const arrayListPtr = arrayListStart + ArrayListHeader.LENGTH;
+        await writer.write(new ArrayListHeader(arrayListPtr, 0).toBytes());
         await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
         const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 2 /* ARRAY_LIST */));
         await db.core.seek(position);
@@ -1054,7 +1074,7 @@ class ArrayListInit {
       case 2 /* ARRAY_LIST */: {
         const reader = db.core.reader();
         const writer = db.core.writer();
-        let arrayListStart = slotPtr.slot.value;
+        let arrayListStart = Number(slotPtr.slot.value);
         if (db.txStart !== null) {
           if (arrayListStart < db.txStart) {
             await db.core.seek(arrayListStart);
@@ -1066,7 +1086,7 @@ class ArrayListInit {
             await reader.readFully(arrayListIndexBlock);
             arrayListStart = await db.core.length();
             await db.core.seek(arrayListStart);
-            const nextArrayListPtr = arrayListStart + BigInt(ArrayListHeader.LENGTH);
+            const nextArrayListPtr = arrayListStart + ArrayListHeader.LENGTH;
             const newHeader = header.withPtr(nextArrayListPtr);
             await writer.write(newHeader.toBytes());
             await writer.write(arrayListIndexBlock);
@@ -1101,7 +1121,7 @@ class ArrayListGet2 {
       default:
         throw new UnexpectedTagException;
     }
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     let index = this.index;
     await db.core.seek(nextArrayListStart);
     const reader = db.core.reader();
@@ -1111,9 +1131,9 @@ class ArrayListGet2 {
     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 key = index < 0 ? header.size - Math.abs(index) : index;
+    const lastKey = header.size - 1;
+    const shift = lastKey < SLOT_COUNT ? 0 : Math.floor(Math.log(lastKey) / Math.log(SLOT_COUNT));
     const finalSlotPtr = await db.readArrayListSlot(header.ptr, key, shift, writeMode, isTopLevel);
     return db.readSlotPointer(writeMode, path, pathI + 1, finalSlotPtr);
   }
@@ -1128,7 +1148,7 @@ class ArrayListAppend {
     if (tag !== 2 /* ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     await db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
     await reader.readFully(headerBytes);
@@ -1162,7 +1182,7 @@ class ArrayListSlice {
     if (slotPtr.slot.tag !== 2 /* ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     await db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(ArrayListHeader.LENGTH);
     await reader.readFully(headerBytes);
@@ -1191,8 +1211,8 @@ class LinkedArrayListInit {
         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());
+        const arrayListPtr = arrayListStart + LinkedArrayListHeader.LENGTH;
+        await writer.write(new LinkedArrayListHeader(0, arrayListPtr, 0).toBytes());
         await writer.write(new Uint8Array(LINKED_ARRAY_LIST_INDEX_BLOCK_SIZE));
         const nextSlotPtr = new SlotPointer(position, new Slot(arrayListStart, 3 /* LINKED_ARRAY_LIST */));
         await db.core.seek(position);
@@ -1202,7 +1222,7 @@ class LinkedArrayListInit {
       case 3 /* LINKED_ARRAY_LIST */: {
         const reader = db.core.reader();
         const writer = db.core.writer();
-        let arrayListStart = slotPtr.slot.value;
+        let arrayListStart = Number(slotPtr.slot.value);
         if (db.txStart !== null) {
           if (arrayListStart < db.txStart) {
             await db.core.seek(arrayListStart);
@@ -1214,7 +1234,7 @@ class LinkedArrayListInit {
             await reader.readFully(arrayListIndexBlock);
             arrayListStart = await db.core.length();
             await db.core.seek(arrayListStart);
-            const nextArrayListPtr = arrayListStart + BigInt(LinkedArrayListHeader.LENGTH);
+            const nextArrayListPtr = arrayListStart + LinkedArrayListHeader.LENGTH;
             const newHeader = header.withPtr(nextArrayListPtr);
             await writer.write(newHeader.toBytes());
             await writer.write(arrayListIndexBlock);
@@ -1249,7 +1269,7 @@ class LinkedArrayListGet {
         throw new UnexpectedTagException;
     }
     let index = this.index;
-    await db.core.seek(slotPtr.slot.value);
+    await db.core.seek(Number(slotPtr.slot.value));
     const reader = db.core.reader();
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
     await reader.readFully(headerBytes);
@@ -1257,7 +1277,7 @@ class LinkedArrayListGet {
     if (index >= header.size || index < -header.size) {
       throw new KeyNotFoundException;
     }
-    const key = index < 0n ? header.size - bigAbs(index) : index;
+    const key = index < 0 ? header.size - Math.abs(index) : index;
     const finalSlotPtr = await db.readLinkedArrayListSlot(header.ptr, key, header.shift, writeMode, isTopLevel);
     return db.readSlotPointer(writeMode, path, pathI + 1, finalSlotPtr.slotPtr);
   }
@@ -1271,7 +1291,7 @@ class LinkedArrayListAppend {
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     await db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
     await reader.readFully(headerBytes);
@@ -1299,7 +1319,7 @@ class LinkedArrayListSlice {
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     await db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
     await reader.readFully(headerBytes);
@@ -1327,12 +1347,12 @@ class LinkedArrayListConcat {
     if (this.list.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     await db.core.seek(nextArrayListStart);
     const headerBytesA = new Uint8Array(LinkedArrayListHeader.LENGTH);
     await reader.readFully(headerBytesA);
     const headerA = LinkedArrayListHeader.fromBytes(headerBytesA);
-    await db.core.seek(this.list.value);
+    await db.core.seek(Number(this.list.value));
     const headerBytesB = new Uint8Array(LinkedArrayListHeader.LENGTH);
     await reader.readFully(headerBytesB);
     const headerB = LinkedArrayListHeader.fromBytes(headerBytesB);
@@ -1357,7 +1377,7 @@ class LinkedArrayListInsert {
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     await db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
     await reader.readFully(headerBytes);
@@ -1366,8 +1386,8 @@ class LinkedArrayListInsert {
     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 key = index < 0 ? origHeader.size - Math.abs(index) : index;
+    const headerA = await db.readLinkedArrayListSlice(origHeader, 0, key);
     const headerB = await db.readLinkedArrayListSlice(origHeader, key, origHeader.size - key);
     const appendResult = await db.readLinkedArrayListSlotAppend(headerA, writeMode, isTopLevel);
     const concatHeader = await db.readLinkedArrayListConcat(appendResult.header, headerB);
@@ -1392,7 +1412,7 @@ class LinkedArrayListRemove {
     if (slotPtr.slot.tag !== 3 /* LINKED_ARRAY_LIST */)
       throw new UnexpectedTagException;
     const reader = db.core.reader();
-    const nextArrayListStart = slotPtr.slot.value;
+    const nextArrayListStart = Number(slotPtr.slot.value);
     await db.core.seek(nextArrayListStart);
     const headerBytes = new Uint8Array(LinkedArrayListHeader.LENGTH);
     await reader.readFully(headerBytes);
@@ -1401,9 +1421,9 @@ class LinkedArrayListRemove {
     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 key = index < 0 ? origHeader.size - Math.abs(index) : index;
+    const headerA = await db.readLinkedArrayListSlice(origHeader, 0, key);
+    const headerB = await db.readLinkedArrayListSlice(origHeader, key + 1, origHeader.size - (key + 1));
     const concatHeader = await db.readLinkedArrayListConcat(headerA, headerB);
     const nextSlotPtr = new SlotPointer(concatHeader.ptr, new Slot(nextArrayListStart, 3 /* LINKED_ARRAY_LIST */));
     const finalSlotPtr = await db.readSlotPointer(writeMode, path, pathI + 1, nextSlotPtr);
@@ -1429,12 +1449,12 @@ class HashMapInit {
     if (isTopLevel) {
       const writer = db.core.writer();
       if (db.header.tag === 0 /* NONE */) {
-        await db.core.seek(BigInt(Header.LENGTH));
+        await db.core.seek(Header.LENGTH);
         if (this.counted) {
-          await writer.writeLong(0n);
+          await writer.writeLong(0);
         }
         await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
-        await db.core.seek(0n);
+        await db.core.seek(0);
         db.header = db.header.withTag(tag);
         await writer.write(db.header.toBytes());
       }
@@ -1450,7 +1470,7 @@ class HashMapInit {
         const mapStart = await db.core.length();
         await db.core.seek(mapStart);
         if (this.counted) {
-          await writer.writeLong(0n);
+          await writer.writeLong(0);
         }
         await writer.write(new Uint8Array(INDEX_BLOCK_SIZE));
         const nextSlotPtr = new SlotPointer(position, new Slot(mapStart, tag));
@@ -1481,7 +1501,7 @@ class HashMapInit {
         }
         const reader = db.core.reader();
         const writer = db.core.writer();
-        let mapStart = slotPtr.slot.value;
+        let mapStart = Number(slotPtr.slot.value);
         if (db.txStart !== null) {
           if (mapStart < db.txStart) {
             await db.core.seek(mapStart);
@@ -1533,16 +1553,16 @@ class HashMapGet {
       default:
         throw new UnexpectedTagException;
     }
-    const indexPos = counted ? slotPtr.slot.value + 8n : slotPtr.slot.value;
+    const indexPos = counted ? Number(slotPtr.slot.value) + 8 : Number(slotPtr.slot.value);
     const hash = db.checkHash(this.target);
     const res = await db.readMapSlot(indexPos, hash, 0, writeMode, isTopLevel, this.target);
     if (writeMode === 1 /* READ_WRITE */ && counted && res.isEmpty) {
       const reader = db.core.reader();
       const writer = db.core.writer();
-      await db.core.seek(slotPtr.slot.value);
+      await db.core.seek(Number(slotPtr.slot.value));
       const mapCount = await reader.readLong();
-      await db.core.seek(slotPtr.slot.value);
-      await writer.writeLong(mapCount + 1n);
+      await db.core.seek(Number(slotPtr.slot.value));
+      await writer.writeLong(mapCount + 1);
     }
     return db.readSlotPointer(writeMode, path, pathI + 1, res.slotPtr);
   }
@@ -1571,7 +1591,7 @@ class HashMapRemove {
       default:
         throw new UnexpectedTagException;
     }
-    const indexPos = counted ? slotPtr.slot.value + 8n : slotPtr.slot.value;
+    const indexPos = counted ? Number(slotPtr.slot.value) + 8 : Number(slotPtr.slot.value);
     const hash = db.checkHashBytes(this.hash);
     let keyFound = true;
     try {
@@ -1586,10 +1606,10 @@ class HashMapRemove {
     if (writeMode === 1 /* READ_WRITE */ && counted && keyFound) {
       const reader = db.core.reader();
       const writer = db.core.writer();
-      await db.core.seek(slotPtr.slot.value);
+      await db.core.seek(Number(slotPtr.slot.value));
       const mapCount = await reader.readLong();
-      await db.core.seek(slotPtr.slot.value);
-      await writer.writeLong(mapCount - 1n);
+      await db.core.seek(Number(slotPtr.slot.value));
+      await writer.writeLong(mapCount - 1);
     }
     if (!keyFound)
       throw new KeyNotFoundException;
@@ -1617,7 +1637,7 @@ class WriteData {
     } else if (data instanceof Slot) {
       slot = data;
     } else if (data instanceof Uint) {
-      if (data.value < 0n) {
+      if (data.value < 0) {
         throw new Error("Uint must not be negative");
       }
       slot = new Slot(data.value, 8 /* UINT */);
@@ -1722,14 +1742,11 @@ function arraysEqual(a, b) {
   return true;
 }
 function checkLong(n) {
-  if (n < 0n) {
+  if (n < 0) {
     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++) {
@@ -1749,8 +1766,8 @@ class Database3 {
   }
   static async create(core, hasher) {
     const db = new Database3(core, hasher);
-    await core.seek(0n);
-    if (await core.length() === 0n) {
+    await core.seek(0);
+    if (await core.length() === 0) {
       db.header = new Header(hasher.id, hasher.digestLength, VERSION, 0 /* NONE */, MAGIC_NUMBER);
       await db.header.write(core);
       await core.flush();
@@ -1767,10 +1784,10 @@ class Database3 {
   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);
+      await this.core.seek(0);
       this.header = await Header.read(this.core);
     }
-    return new WriteCursor2(new SlotPointer(null, new Slot(BigInt(Header.LENGTH), this.header.tag)), this);
+    return new WriteCursor2(new SlotPointer(null, new Slot(Header.LENGTH, this.header.tag)), this);
   }
   async freeze() {
     if (this.txStart !== null) {
@@ -1784,12 +1801,12 @@ class Database3 {
       return;
     const rootCursor = await this.rootCursor();
     const listSize = await rootCursor.count();
-    if (listSize === 0n)
+    if (listSize === 0)
       return;
-    await this.core.seek(BigInt(Header.LENGTH + ArrayListHeader.LENGTH));
+    await this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
     const reader = this.core.reader();
     const headerFileSize = await reader.readLong();
-    if (headerFileSize === 0n)
+    if (headerFileSize === 0)
       return;
     const fileSize = await this.core.length();
     if (fileSize === headerFileSize)
@@ -1835,12 +1852,12 @@ class Database3 {
     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);
+    const slotPos = indexPos + Slot.LENGTH * i;
     await this.core.seek(slotPos);
     const slotBytes = new Uint8Array(Slot.LENGTH);
     await reader.readFully(slotBytes);
     const slot = Slot.fromBytes(slotBytes);
-    const ptr = slot.value;
+    const ptr = Number(slot.value);
     switch (slot.tag) {
       case 0 /* NONE */: {
         switch (writeMode) {
@@ -1849,8 +1866,8 @@ class Database3 {
           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 keySlotPos = hashPos + this.header.hashSize;
+            const valueSlotPos = keySlotPos + Slot.LENGTH;
             const kvPair = new KeyValuePair(new Slot, new Slot, keyHash);
             await writer.write(kvPair.toBytes());
             const nextSlot = new Slot(hashPos, 5 /* KV_PAIR */);
@@ -1901,8 +1918,8 @@ class Database3 {
               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);
+                const keySlotPos2 = hashPos + this.header.hashSize;
+                const valueSlotPos2 = keySlotPos2 + Slot.LENGTH;
                 await writer.write(kvPair.toBytes());
                 const nextSlot = new Slot(hashPos, 5 /* KV_PAIR */);
                 await this.core.seek(slotPos);
@@ -1921,8 +1938,8 @@ class Database3 {
               throw new ExpectedTxStartException;
             }
           }
-          const keySlotPos = ptr + BigInt(this.header.hashSize);
-          const valueSlotPos = keySlotPos + BigInt(Slot.LENGTH);
+          const keySlotPos = ptr + this.header.hashSize;
+          const valueSlotPos = keySlotPos + Slot.LENGTH;
           let nextSlotPtr;
           if (target.kind === "kv_pair") {
             nextSlotPtr = new SlotPointer(slotPos, slot);
@@ -1944,7 +1961,7 @@ class Database3 {
               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 this.core.seek(nextIndexPos + Slot.LENGTH * nextI);
               await writer.write(slot.toBytes());
               const res = await this.readMapSlot(nextIndexPos, keyHash, keyOffset + 1, writeMode, isTopLevel, target);
               await this.core.seek(slotPos);
@@ -1975,17 +1992,17 @@ class Database3 {
       slotBlock[i2] = Slot.fromBytes(slotBytes);
     }
     const i = Number(bigIntShiftRight(keyHash, keyOffset * BIT_COUNT) & MASK);
-    const slotPos = indexPos + BigInt(Slot.LENGTH * i);
+    const slotPos = indexPos + Slot.LENGTH * i;
     const slot = slotBlock[i];
     let nextSlot;
     switch (slot.tag) {
       case 0 /* NONE */:
         throw new KeyNotFoundException;
       case 1 /* INDEX */:
-        nextSlot = await this.removeMapSlot(slot.value, keyHash, keyOffset + 1, isTopLevel);
+        nextSlot = await this.removeMapSlot(Number(slot.value), keyHash, keyOffset + 1, isTopLevel);
         break;
       case 5 /* KV_PAIR */: {
-        await this.core.seek(slot.value);
+        await this.core.seek(Number(slot.value));
         const kvPairBytes = new Uint8Array(KeyValuePair.length(this.header.hashSize));
         await reader.readFully(kvPairBytes);
         const kvPair = KeyValuePair.fromBytes(kvPairBytes, this.header.hashSize);
@@ -2032,7 +2049,7 @@ class Database3 {
           const nextIndexPos = await this.core.length();
           await this.core.seek(nextIndexPos);
           await writer.write(indexBlock);
-          const nextSlotPos = nextIndexPos + BigInt(Slot.LENGTH * i);
+          const nextSlotPos = nextIndexPos + Slot.LENGTH * i;
           await this.core.seek(nextSlotPos);
           await writer.write(nextSlot.toBytes());
           return new Slot(nextIndexPos, 1 /* INDEX */);
@@ -2049,8 +2066,8 @@ class Database3 {
     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));
+    const prevShift = key < SLOT_COUNT ? 0 : Math.floor(Math.log(key - 1) / Math.log(SLOT_COUNT));
+    const nextShift = key < SLOT_COUNT ? 0 : Math.floor(Math.log(key) / Math.log(SLOT_COUNT));
     if (prevShift !== nextShift) {
       const nextIndexPos = await this.core.length();
       await this.core.seek(nextIndexPos);
@@ -2060,14 +2077,14 @@ class Database3 {
       indexPos = nextIndexPos;
     }
     const slotPtr = await this.readArrayListSlot(indexPos, key, nextShift, writeMode, isTopLevel);
-    return new ArrayListAppendResult(new ArrayListHeader(indexPos, header.size + 1n), slotPtr);
+    return new ArrayListAppendResult(new ArrayListHeader(indexPos, header.size + 1), slotPtr);
   }
   async readArrayListSlot(indexPos, key, shift, writeMode, isTopLevel) {
     if (shift >= MAX_BRANCH_LENGTH)
       throw new MaxShiftExceededException;
     const reader = this.core.reader();
-    const i = Number(key >> BigInt(shift * BIT_COUNT) & MASK);
-    const slotPos = indexPos + BigInt(Slot.LENGTH * i);
+    const i = key >>> shift * BIT_COUNT & SLOT_COUNT - 1;
+    const slotPos = indexPos + Slot.LENGTH * i;
     await this.core.seek(slotPos);
     const slotBytes = new Uint8Array(Slot.LENGTH);
     await reader.readFully(slotBytes);
@@ -2075,7 +2092,7 @@ class Database3 {
     if (shift === 0) {
       return new SlotPointer(slotPos, slot);
     }
-    const ptr = slot.value;
+    const ptr = Number(slot.value);
     switch (slot.tag) {
       case 0 /* NONE */: {
         switch (writeMode) {
@@ -2088,7 +2105,7 @@ class Database3 {
             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 this.core.seek(Header.LENGTH + ArrayListHeader.LENGTH);
               await writer.writeLong(fileSize);
             }
             await this.core.seek(slotPos);
@@ -2126,11 +2143,11 @@ class Database3 {
   }
   async readArrayListSlice(header, size) {
     const reader = this.core.reader();
-    if (size > header.size || size < 0n) {
+    if (size > header.size || size < 0) {
       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));
+    const prevShift = header.size < SLOT_COUNT + 1 ? 0 : Math.floor(Math.log(header.size - 1) / Math.log(SLOT_COUNT));
+    const nextShift = size < SLOT_COUNT + 1 ? 0 : Math.floor(Math.log(size - 1) / Math.log(SLOT_COUNT));
     if (prevShift === nextShift) {
       return new ArrayListHeader(header.ptr, size);
     } else {
@@ -2142,7 +2159,7 @@ class Database3 {
         await reader.readFully(slotBytes);
         const slot = Slot.fromBytes(slotBytes);
         shift -= 1;
-        indexPos = slot.value;
+        indexPos = Number(slot.value);
       }
       return new ArrayListHeader(indexPos, size);
     }
@@ -2169,25 +2186,25 @@ class Database3 {
         throw e;
       }
     }
-    const newSlot = new Slot(0n, 0 /* NONE */, true);
+    const newSlot = new Slot(0, 0 /* NONE */, true);
     slotPtr = slotPtr.withSlotPointer(slotPtr.slotPtr.withSlot(newSlot));
     if (slotPtr.slotPtr.position === null)
       throw new CursorNotWriteableException;
     const position = slotPtr.slotPtr.position;
     await this.core.seek(position);
-    await writer.write(new LinkedArrayListSlot2(0n, newSlot).toBytes());
-    if (header.size < BigInt(SLOT_COUNT) && shift > 0) {
+    await writer.write(new LinkedArrayListSlot2(0, newSlot).toBytes());
+    if (header.size < SLOT_COUNT && shift > 0) {
       throw new MustSetNewSlotsToFullException;
     }
-    return new LinkedArrayListAppendResult(new LinkedArrayListHeader(shift, ptr, header.size + 1n), slotPtr);
+    return new LinkedArrayListAppendResult(new LinkedArrayListHeader(shift, ptr, header.size + 1), slotPtr);
   }
   static blockLeafCount(block, shift, i) {
-    let n = 0n;
+    let n = 0;
     if (shift === 0) {
       for (let blockI = 0;blockI < block.length; blockI++) {
         const blockSlot = block[blockI];
         if (!blockSlot.slot.empty() || blockI === i) {
-          n += 1n;
+          n += 1;
         }
       }
     } else {
@@ -2200,9 +2217,9 @@ class Database3 {
   static slotLeafCount(slot, shift) {
     if (shift === 0) {
       if (slot.slot.empty()) {
-        return 0n;
+        return 0;
       } else {
-        return 1n;
+        return 1;
       }
     } else {
       return slot.size;
@@ -2211,7 +2228,7 @@ class Database3 {
   static keyAndIndexForLinkedArrayList(slotBlock, key, shift) {
     let nextKey = key;
     let i = 0;
-    const maxLeafCount = shift === 0 ? 1n : BigInt(Math.pow(SLOT_COUNT, shift));
+    const maxLeafCount = shift === 0 ? 1 : Math.pow(SLOT_COUNT, shift);
     while (true) {
       const slotLeafCount = Database3.slotLeafCount(slotBlock[i], shift);
       if (nextKey === slotLeafCount) {
@@ -2254,12 +2271,12 @@ class Database3 {
     const nextKey = keyAndIndex.key;
     const i = keyAndIndex.index;
     const slot = slotBlock[i];
-    const slotPos = indexPos + BigInt(LinkedArrayListSlot2.LENGTH * i);
+    const slotPos = indexPos + LinkedArrayListSlot2.LENGTH * i;
     if (shift === 0) {
       const leafCount = Database3.blockLeafCount(slotBlock, shift, i);
       return new LinkedArrayListSlotPointer(new SlotPointer(slotPos, slot.slot), leafCount);
     }
-    const ptr = slot.slot.value;
+    const ptr = Number(slot.slot.value);
     switch (slot.slot.tag) {
       case 0 /* NONE */: {
         switch (writeMode) {
@@ -2334,7 +2351,7 @@ class Database3 {
       case 0 /* NONE */:
         throw new EmptySlotException;
       case 1 /* INDEX */:
-        await this.readLinkedArrayListBlocks(slot.slot.value, nextKey, shift - 1, blocks);
+        await this.readLinkedArrayListBlocks(Number(slot.slot.value), nextKey, shift - 1, blocks);
         break;
       default:
         throw new UnexpectedTagException;
@@ -2342,7 +2359,7 @@ class Database3 {
   }
   populateArray(arr) {
     for (let i = 0;i < arr.length; i++) {
-      arr[i] = new LinkedArrayListSlot2(0n, new Slot);
+      arr[i] = new LinkedArrayListSlot2(0, new Slot);
     }
   }
   async readLinkedArrayListSlice(header, offset, size) {
@@ -2353,7 +2370,7 @@ class Database3 {
     const leftBlocks = [];
     await this.readLinkedArrayListBlocks(header.ptr, offset, header.shift, leftBlocks);
     const rightBlocks = [];
-    const rightKey = offset + size === 0n ? 0n : offset + size - 1n;
+    const rightKey = offset + size === 0 ? 0 : offset + size - 1;
     await this.readLinkedArrayListBlocks(header.ptr, rightKey, header.shift, rightBlocks);
     const blockCount = leftBlocks.length;
     let nextSlots = [null, null];
@@ -2368,7 +2385,7 @@ class Database3 {
         let slotI = 0;
         const newRootBlock = new Array(SLOT_COUNT);
         this.populateArray(newRootBlock);
-        if (size > 0n) {
+        if (size > 0) {
           if (nextSlots[0] !== null) {
             newRootBlock[slotI] = nextSlots[0];
           } else {
@@ -2376,7 +2393,7 @@ class Database3 {
           }
           slotI += 1;
         }
-        if (size > 1n) {
+        if (size > 1) {
           for (let j = leftBlock.i + 1;j < rightBlock.i; j++) {
             const middleSlot = leftBlock.block[j];
             newRootBlock[slotI] = middleSlot;
@@ -2440,13 +2457,13 @@ class Database3 {
             nextSlots[j] = origBlockInfo.parentSlot;
           } else {
             const nextPtr = await this.core.position();
-            let leafCount = 0n;
+            let leafCount = 0;
             for (let k = 0;k < blockMaybe.length; k++) {
               const blockSlot = blockMaybe[k];
               await writer.write(blockSlot.toBytes());
               if (isLeafNode) {
                 if (!blockSlot.slot.empty()) {
-                  leafCount += 1n;
+                  leafCount += 1;
                 }
               } else {
                 leafCount += blockSlot.size;
@@ -2463,15 +2480,15 @@ class Database3 {
     const rootSlot = nextSlots[0];
     if (rootSlot === null)
       throw new ExpectedRootNodeException;
-    return new LinkedArrayListHeader(nextShift, rootSlot.slot.value, size);
+    return new LinkedArrayListHeader(nextShift, Number(rootSlot.slot.value), size);
   }
   async readLinkedArrayListConcat(headerA, headerB) {
     const writer = this.core.writer();
     const blocksA = [];
-    const keyA = headerA.size === 0n ? 0n : headerA.size - 1n;
+    const keyA = headerA.size === 0 ? 0 : headerA.size - 1;
     await this.readLinkedArrayListBlocks(headerA.ptr, keyA, headerA.shift, blocksA);
     const blocksB = [];
-    await this.readLinkedArrayListBlocks(headerB.ptr, 0n, headerB.shift, blocksB);
+    await this.readLinkedArrayListBlocks(headerB.ptr, 0, headerB.shift, blocksB);
     let nextSlots = [null, null];
     let nextShift = 0;
     for (let i = 0;i < Math.max(blocksA.length, blocksB.length); i++) {
@@ -2565,12 +2582,12 @@ class Database3 {
           break;
         }
         const nextPtr = await this.core.position();
-        let leafCount = 0n;
+        let leafCount = 0;
         for (const blockSlot of block) {
           await writer.write(blockSlot.toBytes());
           if (isLeafNode) {
             if (!blockSlot.slot.empty()) {
-              leafCount += 1n;
+              leafCount += 1;
             }
           } else {
             leafCount += blockSlot.size;
@@ -2595,7 +2612,7 @@ class Database3 {
         nextShift += 1;
         rootPtr = newPtr;
       } else {
-        rootPtr = nextSlots[0].slot.value;
+        rootPtr = Number(nextSlots[0].slot.value);
       }
     } else {
       rootPtr = headerA.ptr;
@@ -2632,7 +2649,7 @@ var init_database = __esm(() => {
       const view = new DataView(buffer);
       const arr = new Uint8Array(buffer);
       arr.set(this.parent.toBytes(), 0);
-      view.setBigInt64(ArrayListHeader.LENGTH, this.fileSize, false);
+      view.setBigInt64(ArrayListHeader.LENGTH, BigInt(this.fileSize), false);
       return arr;
     }
   };
@@ -2652,14 +2669,15 @@ var init_database = __esm(() => {
       const view = new DataView(buffer);
       const arr = new Uint8Array(buffer);
       arr.set(this.slot.toBytes(), 0);
-      view.setBigInt64(Slot.LENGTH, this.size, false);
+      view.setBigInt64(Slot.LENGTH, BigInt(this.size), false);
       return arr;
     }
     static fromBytes(bytes) {
       const slotBytes = bytes.slice(0, Slot.LENGTH);
       const slot = Slot.fromBytes(slotBytes);
       const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-      const size = checkLong(view.getBigInt64(Slot.LENGTH, false));
+      const size = Number(view.getBigInt64(Slot.LENGTH, false));
+      checkLong(size);
       return new LinkedArrayListSlot2(size, slot);
     }
   };
@@ -2671,7 +2689,34 @@ init_slot();
 init_writeable_data();
 init_exceptions();
 
-// src/random-access-memory.ts
+// src/core-memory.ts
+class CoreMemory {
+  memory;
+  constructor() {
+    this.memory = new RandomAccessMemory;
+  }
+  reader() {
+    return this.memory;
+  }
+  writer() {
+    return this.memory;
+  }
+  async length() {
+    return this.memory.size();
+  }
+  async seek(pos) {
+    this.memory.seek(pos);
+  }
+  position() {
+    return this.memory.getPosition();
+  }
+  async setLength(len) {
+    this.memory.setLength(len);
+  }
+  async flush() {}
+  async sync() {}
+}
+
 class RandomAccessMemory {
   buffer;
   _position = 0;
@@ -2754,7 +2799,7 @@ class RandomAccessMemory {
   async writeLong(v) {
     const buffer = new ArrayBuffer(8);
     const view = new DataView(buffer);
-    view.setBigInt64(0, v, false);
+    view.setBigInt64(0, BigInt(v), false);
     await this.write(new Uint8Array(buffer));
   }
   async readFully(b) {
@@ -2786,58 +2831,68 @@ class RandomAccessMemory {
     const bytes = new Uint8Array(8);
     await this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getBigInt64(0, false);
+    return Number(view.getBigInt64(0, false));
   }
 }
-// src/core-memory.ts
-class CoreMemory {
-  memory;
-  constructor(memory) {
-    this.memory = memory;
+// src/core-file.ts
+import * as fs from "fs/promises";
+
+class CoreFile {
+  filePath;
+  _position = 0;
+  fileHandle;
+  constructor(filePath, fileHandle) {
+    this.filePath = filePath;
+    this.fileHandle = fileHandle;
+  }
+  static async create(filePath) {
+    try {
+      await fs.access(filePath);
+    } catch {
+      await fs.writeFile(filePath, new Uint8Array(0));
+    }
+    const fileHandle = await fs.open(filePath, "r+");
+    return new CoreFile(filePath, fileHandle);
   }
   reader() {
-    return this.memory;
+    return new FileDataReader(this);
   }
   writer() {
-    return this.memory;
+    return new FileDataWriter(this);
   }
   async length() {
-    return BigInt(this.memory.size());
+    const stats = await this.fileHandle.stat();
+    return stats.size;
   }
   async seek(pos) {
-    this.memory.seek(Number(pos));
+    this._position = pos;
   }
-  async position() {
-    return BigInt(this.memory.getPosition());
+  position() {
+    return this._position;
   }
   async setLength(len) {
-    this.memory.setLength(Number(len));
+    await this.fileHandle.truncate(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;
+  async sync() {
+    await this.fileHandle.sync();
   }
-  setPosition(pos) {
-    this.position = pos;
+  [Symbol.dispose]() {
+    import("fs").then((fs2) => {
+      fs2.closeSync(this.fileHandle.fd);
+    });
   }
-  getPosition() {
-    return this.position;
+}
+
+class FileDataReader {
+  core;
+  constructor(core) {
+    this.core = core;
   }
   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;
+    const position = this.core.position();
+    await this.core.fileHandle.readv([b], position);
+    this.core.seek(position + b.length);
   }
   async readByte() {
     const bytes = new Uint8Array(1);
@@ -2860,42 +2915,19 @@ class FileDataReader {
     const bytes = new Uint8Array(8);
     await this.readFully(bytes);
     const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-    return view.getBigInt64(0, false);
+    return Number(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;
+  core;
+  constructor(core) {
+    this.core = core;
   }
   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;
+    const position = this.core.position();
+    await this.core.fileHandle.writev([buffer], position);
+    this.core.seek(position + buffer.length);
   }
   async writeByte(v) {
     await this.write(new Uint8Array([v & 255]));
@@ -2909,54 +2941,185 @@ class FileDataWriter {
   async writeLong(v) {
     const buffer = new ArrayBuffer(8);
     const view = new DataView(buffer);
-    view.setBigInt64(0, v, false);
+    view.setBigInt64(0, BigInt(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);
+// src/core-buffered-file.ts
+class CoreBufferedFile {
+  file;
+  constructor(file) {
+    this.file = file;
   }
-  static async create(filePath) {
-    const file = Bun.file(filePath);
-    if (!await file.exists()) {
-      await Bun.write(filePath, new Uint8Array(0));
-    }
-    return new CoreFile(filePath);
+  static async create(filePath, bufferSize) {
+    const file = await RandomAccessBufferedFile.create(filePath, bufferSize);
+    return new CoreBufferedFile(file);
   }
   reader() {
-    return this._reader;
+    return this.file;
   }
   writer() {
-    return this._writer;
+    return this.file;
   }
   async length() {
-    const file = Bun.file(this.filePath);
-    return BigInt(file.size);
+    return await this.file.length();
   }
   async seek(pos) {
-    this._position = Number(pos);
-    this._reader.setPosition(this._position);
-    this._writer.setPosition(this._position);
+    await this.file.seek(pos);
   }
-  async position() {
-    return BigInt(this._reader.getPosition());
+  position() {
+    return this.file.position();
   }
   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);
+    await this.file.setLength(len);
+  }
+  async flush() {
+    await this.file.flush();
+  }
+  async sync() {
+    await this.file.sync();
+  }
+  [Symbol.dispose]() {
+    this.file.file[Symbol.dispose]();
+  }
+}
+var DEFAULT_BUFFER_SIZE = 8 * 1024 * 1024;
+
+class RandomAccessBufferedFile {
+  file;
+  memory;
+  bufferSize;
+  filePos;
+  memoryPos;
+  constructor(file, bufferSize) {
+    this.file = file;
+    this.memory = new CoreMemory;
+    this.bufferSize = bufferSize;
+    this.filePos = 0;
+    this.memoryPos = 0;
+  }
+  static async create(filePath, bufferSize = DEFAULT_BUFFER_SIZE) {
+    const file = await CoreFile.create(filePath);
+    return new RandomAccessBufferedFile(file, bufferSize);
+  }
+  async seek(pos) {
+    if (pos > this.memoryPos + await this.memory.length()) {
+      await this.flush();
+    }
+    this.filePos = pos;
+    if (await this.memory.length() === 0) {
+      this.memoryPos = pos;
+    }
+  }
+  async length() {
+    return Math.max(this.memoryPos + await this.memory.length(), await this.file.length());
+  }
+  position() {
+    return this.filePos;
+  }
+  async setLength(len) {
+    await this.flush();
+    await this.file.setLength(len);
+    this.filePos = Math.min(len, this.filePos);
+  }
+  async flush() {
+    if (await this.memory.length() > 0) {
+      await this.file.seek(this.memoryPos);
+      await this.file.writer().write(this.memory.memory.toByteArray());
+      this.memoryPos = 0;
+      this.memory.memory.reset();
+    }
+  }
+  async sync() {
+    await this.flush();
+    await this.file.sync();
+  }
+  async write(buffer) {
+    if (await this.memory.length() + buffer.length > this.bufferSize) {
+      await this.flush();
+    }
+    if (this.filePos >= this.memoryPos && this.filePos <= this.memoryPos + await this.memory.length()) {
+      this.memory.seek(this.filePos - this.memoryPos);
+      await this.memory.memory.write(buffer);
+    } else {
+      await this.file.seek(this.filePos);
+      await this.file.writer().write(buffer);
+    }
+    this.filePos += buffer.length;
+  }
+  async writeByte(v) {
+    await this.write(new Uint8Array([v & 255]));
+  }
+  async writeShort(v) {
+    const buffer = new ArrayBuffer(2);
+    const view = new DataView(buffer);
+    view.setInt16(0, v & 65535, false);
+    await this.write(new Uint8Array(buffer));
+  }
+  async writeLong(v) {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    view.setBigInt64(0, BigInt(v), false);
+    await this.write(new Uint8Array(buffer));
+  }
+  async readFully(buffer) {
+    let pos = 0;
+    if (this.filePos < this.memoryPos) {
+      const sizeBeforeMem = Math.min(this.memoryPos - this.filePos, buffer.length);
+      const tempBuffer = new Uint8Array(sizeBeforeMem);
+      await this.file.seek(this.filePos);
+      await this.file.reader().readFully(tempBuffer);
+      buffer.set(tempBuffer, pos);
+      pos += sizeBeforeMem;
+      this.filePos += sizeBeforeMem;
+    }
+    if (pos === buffer.length)
+      return;
+    if (this.filePos >= this.memoryPos && this.filePos < this.memoryPos + await this.memory.length()) {
+      const memPos = this.filePos - this.memoryPos;
+      const sizeInMem = Math.min(await this.memory.length() - memPos, buffer.length - pos);
+      this.memory.seek(memPos);
+      const memBuffer = new Uint8Array(sizeInMem);
+      await this.memory.memory.readFully(memBuffer);
+      buffer.set(memBuffer, pos);
+      pos += sizeInMem;
+      this.filePos += sizeInMem;
+    }
+    if (pos === buffer.length)
+      return;
+    if (this.filePos >= this.memoryPos + await this.memory.length()) {
+      const sizeAfterMem = buffer.length - pos;
+      const tempBuffer = new Uint8Array(sizeAfterMem);
+      await this.file.seek(this.filePos);
+      await this.file.reader().readFully(tempBuffer);
+      buffer.set(tempBuffer, pos);
+      pos += sizeAfterMem;
+      this.filePos += sizeAfterMem;
+    }
+  }
+  async readByte() {
+    const bytes = new Uint8Array(1);
+    await this.readFully(bytes);
+    return bytes[0];
+  }
+  async readShort() {
+    const bytes = new Uint8Array(2);
+    await this.readFully(bytes);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return view.getInt16(0, false);
+  }
+  async readInt() {
+    const bytes = new Uint8Array(4);
+    await this.readFully(bytes);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return view.getInt32(0, false);
+  }
+  async readLong() {
+    const bytes = new Uint8Array(8);
+    await this.readFully(bytes);
+    const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    return Number(view.getBigInt64(0, false));
   }
-  async flush() {}
-  async sync() {}
 }
 // src/hasher.ts
 class Hasher {
@@ -3637,7 +3800,6 @@ export {
   ReadCountedHashSet,
   ReadCountedHashMap,
   ReadArrayList,
-  RandomAccessMemory,
   PathPartMustBeAtEndException,
   NotImplementedException,
   NoAvailableSlotsException,
@@ -3690,6 +3852,7 @@ export {
   CursorIterator,
   CoreMemory,
   CoreFile,
+  CoreBufferedFile,
   Context,
   Bytes,
   BIT_COUNT,