@fireproof/core 0.17.6 → 0.17.8

package/dist/browser/fireproof.global.js

@@ -35,14 +35,14 @@ var Fireproof = (() => {
   var require_encode = __commonJS({
     "../../node_modules/.pnpm/varint@6.0.0/node_modules/varint/encode.js"(exports2, module2) {
       "use strict";
-      module2.exports = encode19;
+      module2.exports = encode20;
       var MSB4 = 128;
       var REST4 = 127;
       var MSBALL4 = ~REST4;
       var INT4 = Math.pow(2, 31);
-      function encode19(num, out, offset) {
+      function encode20(num, out, offset) {
         if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-          encode19.bytes = 0;
+          encode20.bytes = 0;
           throw new RangeError("Could not encode varint");
         }
         out = out || [];
@@ -57,7 +57,7 @@ var Fireproof = (() => {
           num >>>= 7;
         }
         out[offset] = num | 0;
-        encode19.bytes = offset - oldOffset + 1;
+        encode20.bytes = offset - oldOffset + 1;
         return out;
       }
     }
@@ -70,14 +70,14 @@ var Fireproof = (() => {
       module2.exports = read6;
       var MSB4 = 128;
       var REST4 = 127;
-      function read6(buf2, offset) {
-        var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
+      function read6(buf3, offset) {
+        var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf3.length;
         do {
           if (counter >= l || shift > 49) {
             read6.bytes = 0;
             throw new RangeError("Could not decode varint");
           }
-          b = buf2[counter++];
+          b = buf3[counter++];
           res += shift < 28 ? (b & REST4) << shift : (b & REST4) * Math.pow(2, shift);
           shift += 7;
         } while (b >= MSB4);
@@ -173,11 +173,11 @@ var Fireproof = (() => {
       for (i = 0; i < 64; )
         s64[b64[i] = i < 26 ? i + 65 : i < 52 ? i + 71 : i < 62 ? i - 4 : i - 59 | 43] = i++;
       var i;
-      base643.encode = function encode19(buffer2, start, end) {
+      base643.encode = function encode20(buffer3, start, end) {
         var parts = null, chunk = [];
         var i2 = 0, j = 0, t;
         while (start < end) {
-          var b = buffer2[start++];
+          var b = buffer3[start++];
           switch (j) {
             case 0:
               chunk[i2++] = b64[b >> 2];
@@ -214,7 +214,7 @@ var Fireproof = (() => {
         return String.fromCharCode.apply(String, chunk.slice(0, i2));
       };
       var invalidEncoding = "invalid encoding";
-      base643.decode = function decode23(string3, buffer2, offset) {
+      base643.decode = function decode24(string3, buffer3, offset) {
         var start = offset;
         var j = 0, t;
         for (var i2 = 0; i2 < string3.length; ) {
@@ -229,17 +229,17 @@ var Fireproof = (() => {
               j = 1;
               break;
             case 1:
-              buffer2[offset++] = t << 2 | (c & 48) >> 4;
+              buffer3[offset++] = t << 2 | (c & 48) >> 4;
               t = c;
               j = 2;
               break;
             case 2:
-              buffer2[offset++] = (t & 15) << 4 | (c & 60) >> 2;
+              buffer3[offset++] = (t & 15) << 4 | (c & 60) >> 2;
               t = c;
               j = 3;
               break;
             case 3:
-              buffer2[offset++] = (t & 3) << 6 | c;
+              buffer3[offset++] = (t & 3) << 6 | c;
               j = 0;
               break;
           }
@@ -309,34 +309,34 @@ var Fireproof = (() => {
         if (typeof Float32Array !== "undefined")
           (function() {
             var f322 = new Float32Array([-0]), f8b2 = new Uint8Array(f322.buffer), le = f8b2[3] === 128;
-            function writeFloat_f32_cpy(val, buf2, pos) {
+            function writeFloat_f32_cpy(val, buf3, pos) {
               f322[0] = val;
-              buf2[pos] = f8b2[0];
-              buf2[pos + 1] = f8b2[1];
-              buf2[pos + 2] = f8b2[2];
-              buf2[pos + 3] = f8b2[3];
+              buf3[pos] = f8b2[0];
+              buf3[pos + 1] = f8b2[1];
+              buf3[pos + 2] = f8b2[2];
+              buf3[pos + 3] = f8b2[3];
             }
-            function writeFloat_f32_rev(val, buf2, pos) {
+            function writeFloat_f32_rev(val, buf3, pos) {
               f322[0] = val;
-              buf2[pos] = f8b2[3];
-              buf2[pos + 1] = f8b2[2];
-              buf2[pos + 2] = f8b2[1];
-              buf2[pos + 3] = f8b2[0];
+              buf3[pos] = f8b2[3];
+              buf3[pos + 1] = f8b2[2];
+              buf3[pos + 2] = f8b2[1];
+              buf3[pos + 3] = f8b2[0];
             }
             exports3.writeFloatLE = le ? writeFloat_f32_cpy : writeFloat_f32_rev;
             exports3.writeFloatBE = le ? writeFloat_f32_rev : writeFloat_f32_cpy;
-            function readFloat_f32_cpy(buf2, pos) {
-              f8b2[0] = buf2[pos];
-              f8b2[1] = buf2[pos + 1];
-              f8b2[2] = buf2[pos + 2];
-              f8b2[3] = buf2[pos + 3];
+            function readFloat_f32_cpy(buf3, pos) {
+              f8b2[0] = buf3[pos];
+              f8b2[1] = buf3[pos + 1];
+              f8b2[2] = buf3[pos + 2];
+              f8b2[3] = buf3[pos + 3];
               return f322[0];
             }
-            function readFloat_f32_rev(buf2, pos) {
-              f8b2[3] = buf2[pos];
-              f8b2[2] = buf2[pos + 1];
-              f8b2[1] = buf2[pos + 2];
-              f8b2[0] = buf2[pos + 3];
+            function readFloat_f32_rev(buf3, pos) {
+              f8b2[3] = buf3[pos];
+              f8b2[2] = buf3[pos + 1];
+              f8b2[1] = buf3[pos + 2];
+              f8b2[0] = buf3[pos + 3];
               return f322[0];
             }
             exports3.readFloatLE = le ? readFloat_f32_cpy : readFloat_f32_rev;
@@ -344,7 +344,7 @@ var Fireproof = (() => {
           })();
         else
           (function() {
-            function writeFloat_ieee754(writeUint, val, buf2, pos) {
+            function writeFloat_ieee754(writeUint, val, buf3, pos) {
               var sign = val < 0 ? 1 : 0;
               if (sign)
                 val = -val;
@@ -355,22 +355,22 @@ var Fireproof = (() => {
                 ) : (
                   /* negative 0 */
                   2147483648
-                ), buf2, pos);
+                ), buf3, pos);
               else if (isNaN(val))
-                writeUint(2143289344, buf2, pos);
+                writeUint(2143289344, buf3, pos);
               else if (val > 34028234663852886e22)
-                writeUint((sign << 31 | 2139095040) >>> 0, buf2, pos);
+                writeUint((sign << 31 | 2139095040) >>> 0, buf3, pos);
               else if (val < 11754943508222875e-54)
-                writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf2, pos);
+                writeUint((sign << 31 | Math.round(val / 1401298464324817e-60)) >>> 0, buf3, pos);
               else {
                 var exponent = Math.floor(Math.log(val) / Math.LN2), mantissa = Math.round(val * Math.pow(2, -exponent) * 8388608) & 8388607;
-                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf2, pos);
+                writeUint((sign << 31 | exponent + 127 << 23 | mantissa) >>> 0, buf3, pos);
               }
             }
             exports3.writeFloatLE = writeFloat_ieee754.bind(null, writeUintLE);
             exports3.writeFloatBE = writeFloat_ieee754.bind(null, writeUintBE);
-            function readFloat_ieee754(readUint, buf2, pos) {
-              var uint = readUint(buf2, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
+            function readFloat_ieee754(readUint, buf3, pos) {
+              var uint = readUint(buf3, pos), sign = (uint >> 31) * 2 + 1, exponent = uint >>> 23 & 255, mantissa = uint & 8388607;
               return exponent === 255 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 1401298464324817e-60 * mantissa : sign * Math.pow(2, exponent - 150) * (mantissa + 8388608);
             }
             exports3.readFloatLE = readFloat_ieee754.bind(null, readUintLE);
@@ -379,50 +379,50 @@ var Fireproof = (() => {
         if (typeof Float64Array !== "undefined")
           (function() {
             var f642 = new Float64Array([-0]), f8b2 = new Uint8Array(f642.buffer), le = f8b2[7] === 128;
-            function writeDouble_f64_cpy(val, buf2, pos) {
+            function writeDouble_f64_cpy(val, buf3, pos) {
               f642[0] = val;
-              buf2[pos] = f8b2[0];
-              buf2[pos + 1] = f8b2[1];
-              buf2[pos + 2] = f8b2[2];
-              buf2[pos + 3] = f8b2[3];
-              buf2[pos + 4] = f8b2[4];
-              buf2[pos + 5] = f8b2[5];
-              buf2[pos + 6] = f8b2[6];
-              buf2[pos + 7] = f8b2[7];
+              buf3[pos] = f8b2[0];
+              buf3[pos + 1] = f8b2[1];
+              buf3[pos + 2] = f8b2[2];
+              buf3[pos + 3] = f8b2[3];
+              buf3[pos + 4] = f8b2[4];
+              buf3[pos + 5] = f8b2[5];
+              buf3[pos + 6] = f8b2[6];
+              buf3[pos + 7] = f8b2[7];
             }
-            function writeDouble_f64_rev(val, buf2, pos) {
+            function writeDouble_f64_rev(val, buf3, pos) {
               f642[0] = val;
-              buf2[pos] = f8b2[7];
-              buf2[pos + 1] = f8b2[6];
-              buf2[pos + 2] = f8b2[5];
-              buf2[pos + 3] = f8b2[4];
-              buf2[pos + 4] = f8b2[3];
-              buf2[pos + 5] = f8b2[2];
-              buf2[pos + 6] = f8b2[1];
-              buf2[pos + 7] = f8b2[0];
+              buf3[pos] = f8b2[7];
+              buf3[pos + 1] = f8b2[6];
+              buf3[pos + 2] = f8b2[5];
+              buf3[pos + 3] = f8b2[4];
+              buf3[pos + 4] = f8b2[3];
+              buf3[pos + 5] = f8b2[2];
+              buf3[pos + 6] = f8b2[1];
+              buf3[pos + 7] = f8b2[0];
             }
             exports3.writeDoubleLE = le ? writeDouble_f64_cpy : writeDouble_f64_rev;
             exports3.writeDoubleBE = le ? writeDouble_f64_rev : writeDouble_f64_cpy;
-            function readDouble_f64_cpy(buf2, pos) {
-              f8b2[0] = buf2[pos];
-              f8b2[1] = buf2[pos + 1];
-              f8b2[2] = buf2[pos + 2];
-              f8b2[3] = buf2[pos + 3];
-              f8b2[4] = buf2[pos + 4];
-              f8b2[5] = buf2[pos + 5];
-              f8b2[6] = buf2[pos + 6];
-              f8b2[7] = buf2[pos + 7];
+            function readDouble_f64_cpy(buf3, pos) {
+              f8b2[0] = buf3[pos];
+              f8b2[1] = buf3[pos + 1];
+              f8b2[2] = buf3[pos + 2];
+              f8b2[3] = buf3[pos + 3];
+              f8b2[4] = buf3[pos + 4];
+              f8b2[5] = buf3[pos + 5];
+              f8b2[6] = buf3[pos + 6];
+              f8b2[7] = buf3[pos + 7];
               return f642[0];
             }
-            function readDouble_f64_rev(buf2, pos) {
-              f8b2[7] = buf2[pos];
-              f8b2[6] = buf2[pos + 1];
-              f8b2[5] = buf2[pos + 2];
-              f8b2[4] = buf2[pos + 3];
-              f8b2[3] = buf2[pos + 4];
-              f8b2[2] = buf2[pos + 5];
-              f8b2[1] = buf2[pos + 6];
-              f8b2[0] = buf2[pos + 7];
+            function readDouble_f64_rev(buf3, pos) {
+              f8b2[7] = buf3[pos];
+              f8b2[6] = buf3[pos + 1];
+              f8b2[5] = buf3[pos + 2];
+              f8b2[4] = buf3[pos + 3];
+              f8b2[3] = buf3[pos + 4];
+              f8b2[2] = buf3[pos + 5];
+              f8b2[1] = buf3[pos + 6];
+              f8b2[0] = buf3[pos + 7];
               return f642[0];
             }
             exports3.readDoubleLE = le ? readDouble_f64_cpy : readDouble_f64_rev;
@@ -430,45 +430,45 @@ var Fireproof = (() => {
           })();
         else
           (function() {
-            function writeDouble_ieee754(writeUint, off0, off1, val, buf2, pos) {
+            function writeDouble_ieee754(writeUint, off0, off1, val, buf3, pos) {
               var sign = val < 0 ? 1 : 0;
               if (sign)
                 val = -val;
               if (val === 0) {
-                writeUint(0, buf2, pos + off0);
+                writeUint(0, buf3, pos + off0);
                 writeUint(1 / val > 0 ? (
                   /* positive */
                   0
                 ) : (
                   /* negative 0 */
                   2147483648
-                ), buf2, pos + off1);
+                ), buf3, pos + off1);
               } else if (isNaN(val)) {
-                writeUint(0, buf2, pos + off0);
-                writeUint(2146959360, buf2, pos + off1);
+                writeUint(0, buf3, pos + off0);
+                writeUint(2146959360, buf3, pos + off1);
               } else if (val > 17976931348623157e292) {
-                writeUint(0, buf2, pos + off0);
-                writeUint((sign << 31 | 2146435072) >>> 0, buf2, pos + off1);
+                writeUint(0, buf3, pos + off0);
+                writeUint((sign << 31 | 2146435072) >>> 0, buf3, pos + off1);
               } else {
                 var mantissa;
                 if (val < 22250738585072014e-324) {
                   mantissa = val / 5e-324;
-                  writeUint(mantissa >>> 0, buf2, pos + off0);
-                  writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf2, pos + off1);
+                  writeUint(mantissa >>> 0, buf3, pos + off0);
+                  writeUint((sign << 31 | mantissa / 4294967296) >>> 0, buf3, pos + off1);
                 } else {
                   var exponent = Math.floor(Math.log(val) / Math.LN2);
                   if (exponent === 1024)
                     exponent = 1023;
                   mantissa = val * Math.pow(2, -exponent);
-                  writeUint(mantissa * 4503599627370496 >>> 0, buf2, pos + off0);
-                  writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf2, pos + off1);
+                  writeUint(mantissa * 4503599627370496 >>> 0, buf3, pos + off0);
+                  writeUint((sign << 31 | exponent + 1023 << 20 | mantissa * 1048576 & 1048575) >>> 0, buf3, pos + off1);
                 }
               }
             }
             exports3.writeDoubleLE = writeDouble_ieee754.bind(null, writeUintLE, 0, 4);
             exports3.writeDoubleBE = writeDouble_ieee754.bind(null, writeUintBE, 4, 0);
-            function readDouble_ieee754(readUint, off0, off1, buf2, pos) {
-              var lo = readUint(buf2, pos + off0), hi = readUint(buf2, pos + off1);
+            function readDouble_ieee754(readUint, off0, off1, buf3, pos) {
+              var lo = readUint(buf3, pos + off0), hi = readUint(buf3, pos + off1);
               var sign = (hi >> 31) * 2 + 1, exponent = hi >>> 20 & 2047, mantissa = 4294967296 * (hi & 1048575) + lo;
               return exponent === 2047 ? mantissa ? NaN : sign * Infinity : exponent === 0 ? sign * 5e-324 * mantissa : sign * Math.pow(2, exponent - 1075) * (mantissa + 4503599627370496);
             }
@@ -477,23 +477,23 @@ var Fireproof = (() => {
           })();
         return exports3;
       }
-      function writeUintLE(val, buf2, pos) {
-        buf2[pos] = val & 255;
-        buf2[pos + 1] = val >>> 8 & 255;
-        buf2[pos + 2] = val >>> 16 & 255;
-        buf2[pos + 3] = val >>> 24;
+      function writeUintLE(val, buf3, pos) {
+        buf3[pos] = val & 255;
+        buf3[pos + 1] = val >>> 8 & 255;
+        buf3[pos + 2] = val >>> 16 & 255;
+        buf3[pos + 3] = val >>> 24;
       }
-      function writeUintBE(val, buf2, pos) {
-        buf2[pos] = val >>> 24;
-        buf2[pos + 1] = val >>> 16 & 255;
-        buf2[pos + 2] = val >>> 8 & 255;
-        buf2[pos + 3] = val & 255;
+      function writeUintBE(val, buf3, pos) {
+        buf3[pos] = val >>> 24;
+        buf3[pos + 1] = val >>> 16 & 255;
+        buf3[pos + 2] = val >>> 8 & 255;
+        buf3[pos + 3] = val & 255;
       }
-      function readUintLE(buf2, pos) {
-        return (buf2[pos] | buf2[pos + 1] << 8 | buf2[pos + 2] << 16 | buf2[pos + 3] << 24) >>> 0;
+      function readUintLE(buf3, pos) {
+        return (buf3[pos] | buf3[pos + 1] << 8 | buf3[pos + 2] << 16 | buf3[pos + 3] << 24) >>> 0;
       }
-      function readUintBE(buf2, pos) {
-        return (buf2[pos] << 24 | buf2[pos + 1] << 16 | buf2[pos + 2] << 8 | buf2[pos + 3]) >>> 0;
+      function readUintBE(buf3, pos) {
+        return (buf3[pos] << 24 | buf3[pos + 1] << 16 | buf3[pos + 2] << 8 | buf3[pos + 3]) >>> 0;
       }
     }
   });
@@ -536,23 +536,23 @@ var Fireproof = (() => {
         }
         return len;
       };
-      utf84.read = function utf8_read(buffer2, start, end) {
+      utf84.read = function utf8_read(buffer3, start, end) {
         var len = end - start;
         if (len < 1)
           return "";
         var parts = null, chunk = [], i = 0, t;
         while (start < end) {
-          t = buffer2[start++];
+          t = buffer3[start++];
           if (t < 128)
             chunk[i++] = t;
           else if (t > 191 && t < 224)
-            chunk[i++] = (t & 31) << 6 | buffer2[start++] & 63;
+            chunk[i++] = (t & 31) << 6 | buffer3[start++] & 63;
           else if (t > 239 && t < 365) {
-            t = ((t & 7) << 18 | (buffer2[start++] & 63) << 12 | (buffer2[start++] & 63) << 6 | buffer2[start++] & 63) - 65536;
+            t = ((t & 7) << 18 | (buffer3[start++] & 63) << 12 | (buffer3[start++] & 63) << 6 | buffer3[start++] & 63) - 65536;
             chunk[i++] = 55296 + (t >> 10);
             chunk[i++] = 56320 + (t & 1023);
           } else
-            chunk[i++] = (t & 15) << 12 | (buffer2[start++] & 63) << 6 | buffer2[start++] & 63;
+            chunk[i++] = (t & 15) << 12 | (buffer3[start++] & 63) << 6 | buffer3[start++] & 63;
           if (i > 8191) {
             (parts || (parts = [])).push(String.fromCharCode.apply(String, chunk));
             i = 0;
@@ -565,26 +565,26 @@ var Fireproof = (() => {
         }
         return String.fromCharCode.apply(String, chunk.slice(0, i));
       };
-      utf84.write = function utf8_write(string3, buffer2, offset) {
+      utf84.write = function utf8_write(string3, buffer3, offset) {
         var start = offset, c1, c2;
         for (var i = 0; i < string3.length; ++i) {
           c1 = string3.charCodeAt(i);
           if (c1 < 128) {
-            buffer2[offset++] = c1;
+            buffer3[offset++] = c1;
           } else if (c1 < 2048) {
-            buffer2[offset++] = c1 >> 6 | 192;
-            buffer2[offset++] = c1 & 63 | 128;
+            buffer3[offset++] = c1 >> 6 | 192;
+            buffer3[offset++] = c1 & 63 | 128;
           } else if ((c1 & 64512) === 55296 && ((c2 = string3.charCodeAt(i + 1)) & 64512) === 56320) {
             c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
             ++i;
-            buffer2[offset++] = c1 >> 18 | 240;
-            buffer2[offset++] = c1 >> 12 & 63 | 128;
-            buffer2[offset++] = c1 >> 6 & 63 | 128;
-            buffer2[offset++] = c1 & 63 | 128;
+            buffer3[offset++] = c1 >> 18 | 240;
+            buffer3[offset++] = c1 >> 12 & 63 | 128;
+            buffer3[offset++] = c1 >> 6 & 63 | 128;
+            buffer3[offset++] = c1 & 63 | 128;
           } else {
-            buffer2[offset++] = c1 >> 12 | 224;
-            buffer2[offset++] = c1 >> 6 & 63 | 128;
-            buffer2[offset++] = c1 & 63 | 128;
+            buffer3[offset++] = c1 >> 12 | 224;
+            buffer3[offset++] = c1 >> 6 & 63 | 128;
+            buffer3[offset++] = c1 & 63 | 128;
           }
         }
         return offset - start;
@@ -597,22 +597,22 @@ var Fireproof = (() => {
     "../../node_modules/.pnpm/@protobufjs+pool@1.1.0/node_modules/@protobufjs/pool/index.js"(exports2, module2) {
       "use strict";
       module2.exports = pool2;
-      function pool2(alloc3, slice3, size) {
+      function pool2(alloc4, slice4, size) {
         var SIZE = size || 8192;
         var MAX = SIZE >>> 1;
         var slab = null;
         var offset = SIZE;
         return function pool_alloc(size2) {
           if (size2 < 1 || size2 > MAX)
-            return alloc3(size2);
+            return alloc4(size2);
           if (offset + size2 > SIZE) {
-            slab = alloc3(SIZE);
+            slab = alloc4(SIZE);
             offset = 0;
           }
-          var buf2 = slice3.call(slab, offset, offset += size2);
+          var buf3 = slice4.call(slab, offset, offset += size2);
           if (offset & 7)
             offset = (offset | 7) + 1;
-          return buf2;
+          return buf3;
         };
       }
     }
@@ -935,7 +935,7 @@ var Fireproof = (() => {
         };
       };
       Writer.create = create18();
-      Writer.alloc = function alloc3(size) {
+      Writer.alloc = function alloc4(size) {
         return new util.Array(size);
       };
       if (util.Array !== Array)
@@ -945,15 +945,15 @@ var Fireproof = (() => {
         this.len += len;
         return this;
       };
-      function writeByte2(val, buf2, pos) {
-        buf2[pos] = val & 255;
+      function writeByte2(val, buf3, pos) {
+        buf3[pos] = val & 255;
       }
-      function writeVarint322(val, buf2, pos) {
+      function writeVarint322(val, buf3, pos) {
         while (val > 127) {
-          buf2[pos++] = val & 127 | 128;
+          buf3[pos++] = val & 127 | 128;
           val >>>= 7;
         }
-        buf2[pos] = val;
+        buf3[pos] = val;
       }
       function VarintOp2(len, val) {
         this.len = len;
@@ -975,17 +975,17 @@ var Fireproof = (() => {
       Writer.prototype.sint32 = function write_sint32(value) {
         return this.uint32((value << 1 ^ value >> 31) >>> 0);
       };
-      function writeVarint642(val, buf2, pos) {
+      function writeVarint642(val, buf3, pos) {
         while (val.hi) {
-          buf2[pos++] = val.lo & 127 | 128;
+          buf3[pos++] = val.lo & 127 | 128;
           val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
           val.hi >>>= 7;
         }
         while (val.lo > 127) {
-          buf2[pos++] = val.lo & 127 | 128;
+          buf3[pos++] = val.lo & 127 | 128;
           val.lo = val.lo >>> 7;
         }
-        buf2[pos++] = val.lo;
+        buf3[pos++] = val.lo;
       }
       Writer.prototype.uint64 = function write_uint64(value) {
         var bits = LongBits2.from(value);
@@ -999,11 +999,11 @@ var Fireproof = (() => {
       Writer.prototype.bool = function write_bool(value) {
         return this._push(writeByte2, 1, value ? 1 : 0);
       };
-      function writeFixed322(val, buf2, pos) {
-        buf2[pos] = val & 255;
-        buf2[pos + 1] = val >>> 8 & 255;
-        buf2[pos + 2] = val >>> 16 & 255;
-        buf2[pos + 3] = val >>> 24;
+      function writeFixed322(val, buf3, pos) {
+        buf3[pos] = val & 255;
+        buf3[pos + 1] = val >>> 8 & 255;
+        buf3[pos + 2] = val >>> 16 & 255;
+        buf3[pos + 3] = val >>> 24;
       }
       Writer.prototype.fixed32 = function write_fixed32(value) {
         return this._push(writeFixed322, 4, value >>> 0);
@@ -1020,20 +1020,20 @@ var Fireproof = (() => {
       Writer.prototype.double = function write_double(value) {
         return this._push(util.float.writeDoubleLE, 8, value);
       };
-      var writeBytes3 = util.Array.prototype.set ? function writeBytes_set(val, buf2, pos) {
-        buf2.set(val, pos);
-      } : function writeBytes_for(val, buf2, pos) {
+      var writeBytes3 = util.Array.prototype.set ? function writeBytes_set(val, buf3, pos) {
+        buf3.set(val, pos);
+      } : function writeBytes_for(val, buf3, pos) {
         for (var i = 0; i < val.length; ++i)
-          buf2[pos + i] = val[i];
+          buf3[pos + i] = val[i];
       };
       Writer.prototype.bytes = function write_bytes(value) {
         var len = value.length >>> 0;
         if (!len)
           return this._push(writeByte2, 1, 0);
         if (util.isString(value)) {
-          var buf2 = Writer.alloc(len = base643.length(value));
-          base643.decode(value, buf2, 0);
-          value = buf2;
+          var buf3 = Writer.alloc(len = base643.length(value));
+          base643.decode(value, buf3, 0);
+          value = buf3;
         }
         return this.uint32(len)._push(writeBytes3, len, value);
       };
@@ -1070,13 +1070,13 @@ var Fireproof = (() => {
         return this;
       };
       Writer.prototype.finish = function finish() {
-        var head = this.head.next, buf2 = this.constructor.alloc(this.len), pos = 0;
+        var head = this.head.next, buf3 = this.constructor.alloc(this.len), pos = 0;
         while (head) {
-          head.fn(head.val, buf2, pos);
+          head.fn(head.val, buf3, pos);
           pos += head.len;
           head = head.next;
         }
-        return buf2;
+        return buf3;
       };
       Writer._configure = function(BufferWriter_) {
         BufferWriter = BufferWriter_;
@@ -1099,14 +1099,14 @@ var Fireproof = (() => {
       }
       BufferWriter._configure = function() {
         BufferWriter.alloc = util._Buffer_allocUnsafe;
-        BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf2, pos) {
-          buf2.set(val, pos);
-        } : function writeBytesBuffer_copy(val, buf2, pos) {
+        BufferWriter.writeBytesBuffer = util.Buffer && util.Buffer.prototype instanceof Uint8Array && util.Buffer.prototype.set.name === "set" ? function writeBytesBuffer_set(val, buf3, pos) {
+          buf3.set(val, pos);
+        } : function writeBytesBuffer_copy(val, buf3, pos) {
           if (val.copy)
-            val.copy(buf2, pos, 0, val.length);
+            val.copy(buf3, pos, 0, val.length);
           else
             for (var i = 0; i < val.length; )
-              buf2[pos++] = val[i++];
+              buf3[pos++] = val[i++];
         };
       };
       BufferWriter.prototype.bytes = function write_bytes_buffer(value) {
@@ -1118,13 +1118,13 @@ var Fireproof = (() => {
           this._push(BufferWriter.writeBytesBuffer, len, value);
         return this;
       };
-      function writeStringBuffer2(val, buf2, pos) {
+      function writeStringBuffer2(val, buf3, pos) {
         if (val.length < 40)
-          util.utf8.write(val, buf2, pos);
-        else if (buf2.utf8Write)
-          buf2.utf8Write(val, pos);
+          util.utf8.write(val, buf3, pos);
+        else if (buf3.utf8Write)
+          buf3.utf8Write(val, pos);
         else
-          buf2.write(val, pos);
+          buf3.write(val, pos);
       }
       BufferWriter.prototype.string = function write_string_buffer(value) {
         var len = util.Buffer.byteLength(value);
@@ -1149,25 +1149,25 @@ var Fireproof = (() => {
       function indexOutOfRange2(reader, writeLength) {
         return RangeError("index out of range: " + reader.pos + " + " + (writeLength || 1) + " > " + reader.len);
       }
-      function Reader(buffer2) {
-        this.buf = buffer2;
+      function Reader(buffer3) {
+        this.buf = buffer3;
         this.pos = 0;
-        this.len = buffer2.length;
+        this.len = buffer3.length;
       }
-      var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer2) {
-        if (buffer2 instanceof Uint8Array || Array.isArray(buffer2))
-          return new Reader(buffer2);
+      var create_array = typeof Uint8Array !== "undefined" ? function create_typed_array(buffer3) {
+        if (buffer3 instanceof Uint8Array || Array.isArray(buffer3))
+          return new Reader(buffer3);
         throw Error("illegal buffer");
-      } : function create_array2(buffer2) {
-        if (Array.isArray(buffer2))
-          return new Reader(buffer2);
+      } : function create_array2(buffer3) {
+        if (Array.isArray(buffer3))
+          return new Reader(buffer3);
         throw Error("illegal buffer");
       };
       var create18 = function create19() {
-        return util.Buffer ? function create_buffer_setup(buffer2) {
-          return (Reader.create = function create_buffer(buffer3) {
-            return util.Buffer.isBuffer(buffer3) ? new BufferReader(buffer3) : create_array(buffer3);
-          })(buffer2);
+        return util.Buffer ? function create_buffer_setup(buffer3) {
+          return (Reader.create = function create_buffer(buffer4) {
+            return util.Buffer.isBuffer(buffer4) ? new BufferReader(buffer4) : create_array(buffer4);
+          })(buffer3);
         } : create_array;
       };
       Reader.create = create18();
@@ -1250,8 +1250,8 @@ var Fireproof = (() => {
       Reader.prototype.bool = function read_bool() {
         return this.uint32() !== 0;
       };
-      function readFixed32_end(buf2, end) {
-        return (buf2[end - 4] | buf2[end - 3] << 8 | buf2[end - 2] << 16 | buf2[end - 1] << 24) >>> 0;
+      function readFixed32_end(buf3, end) {
+        return (buf3[end - 4] | buf3[end - 3] << 8 | buf3[end - 2] << 16 | buf3[end - 1] << 24) >>> 0;
       }
       Reader.prototype.fixed32 = function read_fixed32() {
         if (this.pos + 4 > this.len)
@@ -1373,8 +1373,8 @@ var Fireproof = (() => {
       var Reader = require_reader();
       (BufferReader.prototype = Object.create(Reader.prototype)).constructor = BufferReader;
       var util = require_minimal();
-      function BufferReader(buffer2) {
-        Reader.call(this, buffer2);
+      function BufferReader(buffer3) {
+        Reader.call(this, buffer3);
       }
       BufferReader._configure = function() {
         if (util.Buffer)
@@ -2429,10 +2429,10 @@ var Fireproof = (() => {
       }
       exports2.factory = function(codec) {
         return {
-          encode: encode19,
-          decode: decode23
+          encode: encode20,
+          decode: decode24
         };
-        function encode19(array) {
+        function encode20(array) {
           if (array === null) {
             return "A";
           }
@@ -2451,11 +2451,11 @@ var Fireproof = (() => {
         }
         function encodeItem(item) {
           if (typeof item === "object") {
-            return encode19(item);
+            return encode20(item);
           }
           return escape(codec.encode(item));
         }
-        function decode23(encoded) {
+        function decode24(encoded) {
           if (encoded === "A") {
             return null;
           }
@@ -2992,7 +2992,7 @@ var Fireproof = (() => {
     var LEADER = ALPHABET.charAt(0);
     var FACTOR = Math.log(BASE) / Math.log(256);
     var iFACTOR = Math.log(256) / Math.log(BASE);
-    function encode19(source) {
+    function encode20(source) {
       if (source instanceof Uint8Array)
         ;
       else if (ArrayBuffer.isView(source)) {
@@ -3090,17 +3090,17 @@ var Fireproof = (() => {
       }
       return vch;
     }
-    function decode23(string3) {
-      var buffer2 = decodeUnsafe(string3);
-      if (buffer2) {
-        return buffer2;
+    function decode24(string3) {
+      var buffer3 = decodeUnsafe(string3);
+      if (buffer3) {
+        return buffer3;
       }
       throw new Error(`Non-${name7} character`);
     }
     return {
-      encode: encode19,
+      encode: encode20,
       decodeUnsafe,
-      decode: decode23
+      decode: decode24
     };
   }
   var src = base;
@@ -3287,17 +3287,17 @@ var Fireproof = (() => {
       return this.decoder.decode(input);
     }
   };
-  var from = ({ name: name7, prefix, encode: encode19, decode: decode23 }) => new Codec(name7, prefix, encode19, decode23);
+  var from = ({ name: name7, prefix, encode: encode20, decode: decode24 }) => new Codec(name7, prefix, encode20, decode24);
   var baseX = ({ prefix, name: name7, alphabet: alphabet3 }) => {
-    const { encode: encode19, decode: decode23 } = base_x_default(alphabet3, name7);
+    const { encode: encode20, decode: decode24 } = base_x_default(alphabet3, name7);
     return from({
       prefix,
       name: name7,
-      encode: encode19,
+      encode: encode20,
       /**
        * @param {string} text
        */
-      decode: (text) => coerce(decode23(text))
+      decode: (text) => coerce(decode24(text))
     });
   };
   var decode = (string3, alphabet3, bitsPerChar, name7) => {
@@ -3311,21 +3311,21 @@ var Fireproof = (() => {
     }
     const out = new Uint8Array(end * bitsPerChar / 8 | 0);
     let bits = 0;
-    let buffer2 = 0;
+    let buffer3 = 0;
     let written = 0;
     for (let i = 0; i < end; ++i) {
       const value = codes[string3[i]];
       if (value === void 0) {
         throw new SyntaxError(`Non-${name7} character`);
       }
-      buffer2 = buffer2 << bitsPerChar | value;
+      buffer3 = buffer3 << bitsPerChar | value;
       bits += bitsPerChar;
       if (bits >= 8) {
         bits -= 8;
-        out[written++] = 255 & buffer2 >> bits;
+        out[written++] = 255 & buffer3 >> bits;
       }
     }
-    if (bits >= bitsPerChar || 255 & buffer2 << 8 - bits) {
+    if (bits >= bitsPerChar || 255 & buffer3 << 8 - bits) {
       throw new SyntaxError("Unexpected end of data");
     }
     return out;
@@ -3335,17 +3335,17 @@ var Fireproof = (() => {
     const mask = (1 << bitsPerChar) - 1;
     let out = "";
     let bits = 0;
-    let buffer2 = 0;
+    let buffer3 = 0;
     for (let i = 0; i < data.length; ++i) {
-      buffer2 = buffer2 << 8 | data[i];
+      buffer3 = buffer3 << 8 | data[i];
       bits += 8;
       while (bits > bitsPerChar) {
         bits -= bitsPerChar;
-        out += alphabet3[mask & buffer2 >> bits];
+        out += alphabet3[mask & buffer3 >> bits];
       }
     }
     if (bits) {
-      out += alphabet3[mask & buffer2 << bitsPerChar - bits];
+      out += alphabet3[mask & buffer3 << bitsPerChar - bits];
     }
     if (pad) {
       while (out.length * bitsPerChar & 7) {
@@ -3465,14 +3465,14 @@ var Fireproof = (() => {
   var decode2 = read;
   var MSB$1 = 128;
   var REST$1 = 127;
-  function read(buf2, offset) {
-    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
+  function read(buf3, offset) {
+    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf3.length;
     do {
       if (counter >= l) {
         read.bytes = 0;
         throw new RangeError("Could not decode varint");
       }
-      b = buf2[counter++];
+      b = buf3[counter++];
       res += shift < 28 ? (b & REST$1) << shift : (b & REST$1) * Math.pow(2, shift);
       shift += 7;
     } while (b >= MSB$1);
@@ -4082,7 +4082,7 @@ var Fireproof = (() => {
   };
   var parse = (source, base4) => CID.parse(source, base4);
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/block.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/block.js
   var MemoryBlockstore = class {
     /** @type {Map<string, Uint8Array>} */
     #blocks = /* @__PURE__ */ new Map();
@@ -4405,14 +4405,14 @@ var Fireproof = (() => {
   typeof globalThis.Buffer.isBuffer === "function";
   var textDecoder = new TextDecoder();
   var textEncoder = new TextEncoder();
-  function isBuffer2(buf2) {
-    return useBuffer && globalThis.Buffer.isBuffer(buf2);
+  function isBuffer2(buf3) {
+    return useBuffer && globalThis.Buffer.isBuffer(buf3);
   }
-  function asU8A(buf2) {
-    if (!(buf2 instanceof Uint8Array)) {
-      return Uint8Array.from(buf2);
+  function asU8A(buf3) {
+    if (!(buf3 instanceof Uint8Array)) {
+      return Uint8Array.from(buf3);
     }
-    return isBuffer2(buf2) ? new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength) : buf2;
+    return isBuffer2(buf3) ? new Uint8Array(buf3.buffer, buf3.byteOffset, buf3.byteLength) : buf3;
   }
   var toString2 = useBuffer ? (
     // eslint-disable-line operator-linebreak
@@ -4577,10 +4577,10 @@ var Fireproof = (() => {
     }
     return out;
   }
-  function utf8Slice(buf2, offset, end) {
+  function utf8Slice(buf3, offset, end) {
     const res = [];
     while (offset < end) {
-      const firstByte = buf2[offset];
+      const firstByte = buf3[offset];
       let codePoint = null;
       let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
       if (offset + bytesPerSequence <= end) {
@@ -4592,7 +4592,7 @@ var Fireproof = (() => {
             }
             break;
           case 2:
-            secondByte = buf2[offset + 1];
+            secondByte = buf3[offset + 1];
             if ((secondByte & 192) === 128) {
               tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
               if (tempCodePoint > 127) {
@@ -4601,8 +4601,8 @@ var Fireproof = (() => {
             }
             break;
           case 3:
-            secondByte = buf2[offset + 1];
-            thirdByte = buf2[offset + 2];
+            secondByte = buf3[offset + 1];
+            thirdByte = buf3[offset + 2];
             if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
               tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
               if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
@@ -4611,9 +4611,9 @@ var Fireproof = (() => {
             }
             break;
           case 4:
-            secondByte = buf2[offset + 1];
-            thirdByte = buf2[offset + 2];
-            fourthByte = buf2[offset + 3];
+            secondByte = buf3[offset + 1];
+            thirdByte = buf3[offset + 2];
+            fourthByte = buf3[offset + 3];
             if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
               tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
               if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
@@ -4802,22 +4802,22 @@ var Fireproof = (() => {
   function decodeUint64(data, pos, _minor, options) {
     return new Token(Type.uint, readUint64(data, pos + 1, options), 9);
   }
-  function encodeUint(buf2, token) {
-    return encodeUintValue(buf2, 0, token.value);
+  function encodeUint(buf3, token) {
+    return encodeUintValue(buf3, 0, token.value);
   }
-  function encodeUintValue(buf2, major, uint) {
+  function encodeUintValue(buf3, major, uint) {
     if (uint < uintBoundaries[0]) {
       const nuint = Number(uint);
-      buf2.push([major | nuint]);
+      buf3.push([major | nuint]);
     } else if (uint < uintBoundaries[1]) {
       const nuint = Number(uint);
-      buf2.push([major | 24, nuint]);
+      buf3.push([major | 24, nuint]);
     } else if (uint < uintBoundaries[2]) {
       const nuint = Number(uint);
-      buf2.push([major | 25, nuint >>> 8, nuint & 255]);
+      buf3.push([major | 25, nuint >>> 8, nuint & 255]);
     } else if (uint < uintBoundaries[3]) {
       const nuint = Number(uint);
-      buf2.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
+      buf3.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
     } else {
       const buint = BigInt(uint);
       if (buint < uintBoundaries[4]) {
@@ -4838,7 +4838,7 @@ var Fireproof = (() => {
         set3[2] = hi & 255;
         hi = hi >> 8;
         set3[1] = hi & 255;
-        buf2.push(set3);
+        buf3.push(set3);
       } else {
         throw new Error(`${decodeErrPrefix} encountered BigInt larger than allowable range`);
       }
@@ -4894,10 +4894,10 @@ var Fireproof = (() => {
     }
     return new Token(Type.negint, neg1b - BigInt(int), 9);
   }
-  function encodeNegint(buf2, token) {
+  function encodeNegint(buf3, token) {
     const negint = token.value;
     const unsigned = typeof negint === "bigint" ? negint * neg1b - pos1b : negint * -1 - 1;
-    encodeUintValue(buf2, token.type.majorEncoded, unsigned);
+    encodeUintValue(buf3, token.type.majorEncoded, unsigned);
   }
   encodeNegint.encodedSize = function encodedSize3(token) {
     const negint = token.value;
@@ -4926,8 +4926,8 @@ var Fireproof = (() => {
   // ../../node_modules/.pnpm/cborg@4.0.7/node_modules/cborg/lib/2bytes.js
   function toToken(data, pos, prefix, length5) {
     assertEnoughData(data, pos, prefix + length5);
-    const buf2 = slice(data, pos + prefix, pos + prefix + length5);
-    return new Token(Type.bytes, buf2, prefix + length5);
+    const buf3 = slice(data, pos + prefix, pos + prefix + length5);
+    return new Token(Type.bytes, buf3, prefix + length5);
   }
   function decodeBytesCompact(data, pos, minor, _options) {
     return toToken(data, pos, 1, minor);
@@ -4954,10 +4954,10 @@ var Fireproof = (() => {
     }
     return token.encodedBytes;
   }
-  function encodeBytes(buf2, token) {
+  function encodeBytes(buf3, token) {
     const bytes = tokenBytes(token);
-    encodeUintValue(buf2, token.type.majorEncoded, bytes.length);
-    buf2.push(bytes);
+    encodeUintValue(buf3, token.type.majorEncoded, bytes.length);
+    buf3.push(bytes);
   }
   encodeBytes.encodedSize = function encodedSize4(token) {
     const bytes = tokenBytes(token);
@@ -5030,8 +5030,8 @@ var Fireproof = (() => {
     }
     return toToken3(data, pos, 1, Infinity);
   }
-  function encodeArray(buf2, token) {
-    encodeUintValue(buf2, Type.array.majorEncoded, token.value);
+  function encodeArray(buf3, token) {
+    encodeUintValue(buf3, Type.array.majorEncoded, token.value);
   }
   encodeArray.compareTokens = encodeUint.compareTokens;
   encodeArray.encodedSize = function encodedSize5(token) {
@@ -5067,8 +5067,8 @@ var Fireproof = (() => {
     }
     return toToken4(data, pos, 1, Infinity);
   }
-  function encodeMap(buf2, token) {
-    encodeUintValue(buf2, Type.map.majorEncoded, token.value);
+  function encodeMap(buf3, token) {
+    encodeUintValue(buf3, Type.map.majorEncoded, token.value);
   }
   encodeMap.compareTokens = encodeUint.compareTokens;
   encodeMap.encodedSize = function encodedSize6(token) {
@@ -5091,8 +5091,8 @@ var Fireproof = (() => {
   function decodeTag64(data, pos, _minor, options) {
     return new Token(Type.tag, readUint64(data, pos + 1, options), 9);
   }
-  function encodeTag(buf2, token) {
-    encodeUintValue(buf2, Type.tag.majorEncoded, token.value);
+  function encodeTag(buf3, token) {
+    encodeUintValue(buf3, Type.tag.majorEncoded, token.value);
   }
   encodeTag.compareTokens = encodeUint.compareTokens;
   encodeTag.encodedSize = function encodedSize7(token) {
@@ -5138,16 +5138,16 @@ var Fireproof = (() => {
   function decodeFloat64(data, pos, _minor, options) {
     return createToken(readFloat64(data, pos + 1), 9, options);
   }
-  function encodeFloat(buf2, token, options) {
+  function encodeFloat(buf3, token, options) {
     const float = token.value;
     if (float === false) {
-      buf2.push([Type.float.majorEncoded | MINOR_FALSE]);
+      buf3.push([Type.float.majorEncoded | MINOR_FALSE]);
     } else if (float === true) {
-      buf2.push([Type.float.majorEncoded | MINOR_TRUE]);
+      buf3.push([Type.float.majorEncoded | MINOR_TRUE]);
     } else if (float === null) {
-      buf2.push([Type.float.majorEncoded | MINOR_NULL]);
+      buf3.push([Type.float.majorEncoded | MINOR_NULL]);
     } else if (float === void 0) {
-      buf2.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
+      buf3.push([Type.float.majorEncoded | MINOR_UNDEFINED]);
     } else {
       let decoded;
       let success = false;
@@ -5156,14 +5156,14 @@ var Fireproof = (() => {
         decoded = readFloat16(ui8a, 1);
         if (float === decoded || Number.isNaN(float)) {
           ui8a[0] = 249;
-          buf2.push(ui8a.slice(0, 3));
+          buf3.push(ui8a.slice(0, 3));
           success = true;
         } else {
           encodeFloat32(float);
           decoded = readFloat32(ui8a, 1);
           if (float === decoded) {
             ui8a[0] = 250;
-            buf2.push(ui8a.slice(0, 5));
+            buf3.push(ui8a.slice(0, 5));
             success = true;
           }
         }
@@ -5172,7 +5172,7 @@ var Fireproof = (() => {
         encodeFloat64(float);
         decoded = readFloat64(ui8a, 1);
         ui8a[0] = 251;
-        buf2.push(ui8a.slice(0, 9));
+        buf3.push(ui8a.slice(0, 9));
       }
     }
   }
@@ -5227,11 +5227,11 @@ var Fireproof = (() => {
       }
     }
   }
-  function readFloat16(ui8a2, pos) {
-    if (ui8a2.length - pos < 2) {
+  function readFloat16(ui8a3, pos) {
+    if (ui8a3.length - pos < 2) {
       throw new Error(`${decodeErrPrefix} not enough data for float16`);
     }
-    const half = (ui8a2[pos] << 8) + ui8a2[pos + 1];
+    const half = (ui8a3[pos] << 8) + ui8a3[pos + 1];
     if (half === 31744) {
       return Infinity;
     }
@@ -5256,22 +5256,22 @@ var Fireproof = (() => {
   function encodeFloat32(inp) {
     dataView.setFloat32(0, inp, false);
   }
-  function readFloat32(ui8a2, pos) {
-    if (ui8a2.length - pos < 4) {
+  function readFloat32(ui8a3, pos) {
+    if (ui8a3.length - pos < 4) {
       throw new Error(`${decodeErrPrefix} not enough data for float32`);
     }
-    const offset = (ui8a2.byteOffset || 0) + pos;
-    return new DataView(ui8a2.buffer, offset, 4).getFloat32(0, false);
+    const offset = (ui8a3.byteOffset || 0) + pos;
+    return new DataView(ui8a3.buffer, offset, 4).getFloat32(0, false);
   }
   function encodeFloat64(inp) {
     dataView.setFloat64(0, inp, false);
   }
-  function readFloat64(ui8a2, pos) {
-    if (ui8a2.length - pos < 8) {
+  function readFloat64(ui8a3, pos) {
+    if (ui8a3.length - pos < 8) {
       throw new Error(`${decodeErrPrefix} not enough data for float64`);
     }
-    const offset = (ui8a2.byteOffset || 0) + pos;
-    return new DataView(ui8a2.buffer, offset, 8).getFloat64(0, false);
+    const offset = (ui8a3.byteOffset || 0) + pos;
+    return new DataView(ui8a3.buffer, offset, 8).getFloat64(0, false);
   }
   encodeFloat.compareTokens = encodeUint.compareTokens;
 
@@ -5691,13 +5691,13 @@ var Fireproof = (() => {
     }
     return tcmp;
   }
-  function tokensToEncoded(buf2, tokens, encoders, options) {
+  function tokensToEncoded(buf3, tokens, encoders, options) {
     if (Array.isArray(tokens)) {
       for (const token of tokens) {
-        tokensToEncoded(buf2, token, encoders, options);
+        tokensToEncoded(buf3, token, encoders, options);
       }
     } else {
-      encoders[tokens.type.major](buf2, tokens, options);
+      encoders[tokens.type.major](buf3, tokens, options);
     }
   }
   function encodeCustom(data, encoders, options) {
@@ -5710,12 +5710,12 @@ var Fireproof = (() => {
       const encoder = encoders[tokens.type.major];
       if (encoder.encodedSize) {
         const size = encoder.encodedSize(tokens, options);
-        const buf2 = new Bl(size);
-        encoder(buf2, tokens, options);
-        if (buf2.chunks.length !== 1) {
+        const buf3 = new Bl(size);
+        encoder(buf3, tokens, options);
+        if (buf3.chunks.length !== 1) {
           throw new Error(`Unexpected error: pre-calculated length for ${tokens} was wrong`);
         }
-        return asU8A(buf2.chunks[0]);
+        return asU8A(buf3.chunks[0]);
       }
     }
     buf.reset();
@@ -5956,7 +5956,7 @@ var Fireproof = (() => {
     var LEADER = ALPHABET.charAt(0);
     var FACTOR = Math.log(BASE) / Math.log(256);
     var iFACTOR = Math.log(256) / Math.log(BASE);
-    function encode19(source) {
+    function encode20(source) {
       if (source instanceof Uint8Array)
         ;
       else if (ArrayBuffer.isView(source)) {
@@ -6054,17 +6054,17 @@ var Fireproof = (() => {
       }
       return vch;
     }
-    function decode23(string3) {
-      var buffer2 = decodeUnsafe(string3);
-      if (buffer2) {
-        return buffer2;
+    function decode24(string3) {
+      var buffer3 = decodeUnsafe(string3);
+      if (buffer3) {
+        return buffer3;
       }
       throw new Error(`Non-${name7} character`);
     }
     return {
-      encode: encode19,
+      encode: encode20,
       decodeUnsafe,
-      decode: decode23
+      decode: decode24
     };
   }
   var src2 = base2;
@@ -6163,16 +6163,16 @@ var Fireproof = (() => {
       return this.decoder.decode(input);
     }
   };
-  function from2({ name: name7, prefix, encode: encode19, decode: decode23 }) {
-    return new Codec2(name7, prefix, encode19, decode23);
+  function from2({ name: name7, prefix, encode: encode20, decode: decode24 }) {
+    return new Codec2(name7, prefix, encode20, decode24);
   }
   function baseX2({ name: name7, prefix, alphabet: alphabet3 }) {
-    const { encode: encode19, decode: decode23 } = base_x_default2(alphabet3, name7);
+    const { encode: encode20, decode: decode24 } = base_x_default2(alphabet3, name7);
     return from2({
       prefix,
       name: name7,
-      encode: encode19,
-      decode: (text) => coerce2(decode23(text))
+      encode: encode20,
+      decode: (text) => coerce2(decode24(text))
     });
   }
   function decode6(string3, alphabet3, bitsPerChar, name7) {
@@ -6186,21 +6186,21 @@ var Fireproof = (() => {
     }
     const out = new Uint8Array(end * bitsPerChar / 8 | 0);
     let bits = 0;
-    let buffer2 = 0;
+    let buffer3 = 0;
     let written = 0;
     for (let i = 0; i < end; ++i) {
       const value = codes[string3[i]];
       if (value === void 0) {
         throw new SyntaxError(`Non-${name7} character`);
       }
-      buffer2 = buffer2 << bitsPerChar | value;
+      buffer3 = buffer3 << bitsPerChar | value;
       bits += bitsPerChar;
       if (bits >= 8) {
         bits -= 8;
-        out[written++] = 255 & buffer2 >> bits;
+        out[written++] = 255 & buffer3 >> bits;
       }
     }
-    if (bits >= bitsPerChar || (255 & buffer2 << 8 - bits) !== 0) {
+    if (bits >= bitsPerChar || (255 & buffer3 << 8 - bits) !== 0) {
       throw new SyntaxError("Unexpected end of data");
     }
     return out;
@@ -6210,17 +6210,17 @@ var Fireproof = (() => {
     const mask = (1 << bitsPerChar) - 1;
     let out = "";
     let bits = 0;
-    let buffer2 = 0;
+    let buffer3 = 0;
     for (let i = 0; i < data.length; ++i) {
-      buffer2 = buffer2 << 8 | data[i];
+      buffer3 = buffer3 << 8 | data[i];
       bits += 8;
       while (bits > bitsPerChar) {
         bits -= bitsPerChar;
-        out += alphabet3[mask & buffer2 >> bits];
+        out += alphabet3[mask & buffer3 >> bits];
       }
     }
     if (bits !== 0) {
-      out += alphabet3[mask & buffer2 << bitsPerChar - bits];
+      out += alphabet3[mask & buffer3 << bitsPerChar - bits];
     }
     if (pad) {
       while ((out.length * bitsPerChar & 7) !== 0) {
@@ -6340,14 +6340,14 @@ var Fireproof = (() => {
   var decode7 = read2;
   var MSB$12 = 128;
   var REST$12 = 127;
-  function read2(buf2, offset) {
-    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
+  function read2(buf3, offset) {
+    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf3.length;
     do {
       if (counter >= l) {
         read2.bytes = 0;
         throw new RangeError("Could not decode varint");
       }
-      b = buf2[counter++];
+      b = buf3[counter++];
       res += shift < 28 ? (b & REST$12) << shift : (b & REST$12) * Math.pow(2, shift);
       shift += 7;
     } while (b >= MSB$12);
@@ -7256,14 +7256,14 @@ You can use close({ resize: true }) to resize header`);
     return import_varint4.default.encodingLength(length5) + length5;
   };
   var headerLength = ({ roots }) => calculateHeaderLength(roots.map((cid) => cid.bytes.byteLength));
-  var createWriter = (buffer2, options = {}) => {
+  var createWriter = (buffer3, options = {}) => {
     const {
       roots = [],
       byteOffset = 0,
-      byteLength = buffer2.byteLength,
+      byteLength = buffer3.byteLength,
       headerSize = headerLength({ roots })
     } = options;
-    const bytes = new Uint8Array(buffer2, byteOffset, byteLength);
+    const bytes = new Uint8Array(buffer3, byteOffset, byteLength);
     const writer = new CarBufferWriter(bytes, headerSize);
     for (const root2 of roots) {
       writer.addRoot(root2);
@@ -7640,7 +7640,7 @@ You can use close({ resize: true }) to resize header`);
   var import_varint5 = __toESM(require_varint(), 1);
 
   // ../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/hashes/hasher.js
-  var from3 = ({ name: name7, code: code8, encode: encode19 }) => new Hasher(name7, code8, encode19);
+  var from3 = ({ name: name7, code: code8, encode: encode20 }) => new Hasher(name7, code8, encode20);
   var Hasher = class {
     /**
      *
@@ -7648,10 +7648,10 @@ You can use close({ resize: true }) to resize header`);
      * @param {Code} code
      * @param {(input: Uint8Array) => Await<Uint8Array>} encode
      */
-    constructor(name7, code8, encode19) {
+    constructor(name7, code8, encode20) {
       this.name = name7;
       this.code = code8;
-      this.encode = encode19;
+      this.encode = encode20;
     }
     /**
      * @param {Uint8Array} input
@@ -7884,9 +7884,9 @@ You can use close({ resize: true }) to resize header`);
   var decode12 = (data) => coerce(data);
 
   // ../../node_modules/.pnpm/prolly-trees@1.0.4/node_modules/prolly-trees/esm/src/utils.js
-  var readUInt32LE = (buffer2) => {
-    const offset = buffer2.byteLength - 4;
-    return (buffer2[offset] | buffer2[offset + 1] << 8 | buffer2[offset + 2] << 16) + buffer2[offset + 3] * 16777216;
+  var readUInt32LE = (buffer3) => {
+    const offset = buffer3.byteLength - 4;
+    return (buffer3[offset] | buffer3[offset + 1] << 8 | buffer3[offset + 2] << 16) + buffer3[offset + 3] * 16777216;
   };
   var MAX_UINT32 = 4294967295;
   var bf = (factor) => {
@@ -7978,11 +7978,11 @@ You can use close({ resize: true }) to resize header`);
       this.closed = closed;
       this.startKey = entries3[0].key;
     }
-    find(key, compare5) {
+    find(key, compare6) {
       const { entries: entries3 } = this;
       for (let i = entries3.length - 1; i > -1; i--) {
         const entry = entries3[i];
-        const comp = compare5(key, entry.key);
+        const comp = compare6(key, entry.key);
         if (comp > -1) {
           return [
             i,
@@ -7992,11 +7992,11 @@ You can use close({ resize: true }) to resize header`);
       }
       return null;
     }
-    findMany(keys, compare5, sorted = false, strict = false) {
+    findMany(keys, compare6, sorted = false, strict = false) {
       const { entries: entries3 } = this;
       const results = /* @__PURE__ */ new Map();
       if (!sorted) {
-        keys = keys.sort(compare5);
+        keys = keys.sort(compare6);
       } else {
         keys = [...keys];
       }
@@ -8008,7 +8008,7 @@ You can use close({ resize: true }) to resize header`);
         while (keys.length) {
           let key = keys[keys.length - 1];
           key = key.key ? key.key : key;
-          const comp = compare5(key, entry.key);
+          const comp = compare6(key, entry.key);
           if (!strict) {
             if (comp > -1) {
               found.push(keys.pop());
@@ -8034,13 +8034,13 @@ You can use close({ resize: true }) to resize header`);
       }
       return results;
     }
-    findRange(start, end, compare5) {
+    findRange(start, end, compare6) {
       const { entries: entries3 } = this;
       let last2;
       let first = 0;
       for (let i = entries3.length - 1; i > -1; i--) {
         const entry = entries3[i];
-        const comp = compare5(end, entry.key);
+        const comp = compare6(end, entry.key);
         if (comp > 0) {
           last2 = i;
           break;
@@ -8048,7 +8048,7 @@ You can use close({ resize: true }) to resize header`);
       }
       for (let i = 0; i < entries3.length; i++) {
         const entry = entries3[i];
-        const comp = compare5(start, entry.key);
+        const comp = compare6(start, entry.key);
         if (comp === 0) {
           first = i;
           break;
@@ -8068,11 +8068,11 @@ You can use close({ resize: true }) to resize header`);
   function sortBulk(bulk, opts) {
     return bulk.sort(({ key: a }, { key: b }) => opts.compare(a, b));
   }
-  async function filterLeftmostInserts(first, bulk, compare5) {
+  async function filterLeftmostInserts(first, bulk, compare6) {
     const inserts = [];
     for (const b of bulk) {
       const { key, del: del2 } = b;
-      if (compare5(key, first) < 0) {
+      if (compare6(key, first) < 0) {
         if (!del2)
           inserts.push(b);
       } else {
@@ -8081,9 +8081,9 @@ You can use close({ resize: true }) to resize header`);
     }
     return inserts;
   }
-  async function generateNewLeaves(inserts, opts, { chunker: chunker3, compare: compare5 }) {
+  async function generateNewLeaves(inserts, opts, { chunker: chunker3, compare: compare6 }) {
     return await Node2.from({
-      entries: inserts.map((insert) => new opts.LeafEntryClass(insert, opts)).sort((a, b) => compare5(a.key, b.key)),
+      entries: inserts.map((insert) => new opts.LeafEntryClass(insert, opts)).sort((a, b) => compare6(a.key, b.key)),
       chunker: chunker3,
       NodeClass: opts.LeafClass,
       distance: 0,
@@ -8168,12 +8168,12 @@ You can use close({ resize: true }) to resize header`);
     }
   }
   var Node2 = class _Node {
-    constructor({ entryList, chunker: chunker3, distance, getNode, compare: compare5, cache: cache4 }) {
+    constructor({ entryList, chunker: chunker3, distance, getNode, compare: compare6, cache: cache4 }) {
       this.entryList = entryList;
       this.chunker = chunker3;
       this.distance = distance;
       this.getNode = getNode;
-      this.compare = compare5;
+      this.compare = compare6;
       this.cache = cache4;
     }
     get closed() {
@@ -8754,9 +8754,9 @@ You can use close({ resize: true }) to resize header`);
     }
   };
   var create5 = async function* (obj) {
-    let { LeafClass: LeafClass2, LeafEntryClass, BranchClass: BranchClass2, BranchEntryClass, list, chunker: chunker3, compare: compare5, ...opts } = obj;
+    let { LeafClass: LeafClass2, LeafEntryClass, BranchClass: BranchClass2, BranchEntryClass, list, chunker: chunker3, compare: compare6, ...opts } = obj;
     list = list.map((value) => new LeafEntryClass(value, opts));
-    opts.compare = compare5;
+    opts.compare = compare6;
     let nodes = await Node2.from({
       entries: list,
       chunker: chunker3,
@@ -8798,8 +8798,8 @@ You can use close({ resize: true }) to resize header`);
       return this.cid;
     }
     identity() {
-      const buffer2 = this.cid.multihash.bytes;
-      return readUInt32LE(buffer2);
+      const buffer3 = this.cid.multihash.bytes;
+      return readUInt32LE(buffer3);
     }
   };
   var CIDNodeEntry = class extends Entry {
@@ -8894,22 +8894,22 @@ You can use close({ resize: true }) to resize header`);
     /**
      * @param {Bl} buf
      */
-    prefix(buf2) {
+    prefix(buf3) {
       const recurs = this.inRecursive[this.inRecursive.length - 1];
       if (recurs) {
         if (recurs.type === Type.array) {
           recurs.elements++;
           if (recurs.elements !== 1) {
-            buf2.push([44]);
+            buf3.push([44]);
           }
         }
         if (recurs.type === Type.map) {
           recurs.elements++;
           if (recurs.elements !== 1) {
             if (recurs.elements % 2 === 1) {
-              buf2.push([44]);
+              buf3.push([44]);
             } else {
-              buf2.push([58]);
+              buf3.push([58]);
             }
           }
         }
@@ -8919,21 +8919,21 @@ You can use close({ resize: true }) to resize header`);
      * @param {Bl} buf
      * @param {Token} token
      */
-    [Type.uint.major](buf2, token) {
-      this.prefix(buf2);
-      const is2 = String(token.value);
+    [Type.uint.major](buf3, token) {
+      this.prefix(buf3);
+      const is3 = String(token.value);
       const isa = [];
-      for (let i = 0; i < is2.length; i++) {
-        isa[i] = is2.charCodeAt(i);
+      for (let i = 0; i < is3.length; i++) {
+        isa[i] = is3.charCodeAt(i);
       }
-      buf2.push(isa);
+      buf3.push(isa);
     }
     /**
      * @param {Bl} buf
      * @param {Token} token
      */
-    [Type.negint.major](buf2, token) {
-      this[Type.uint.major](buf2, token);
+    [Type.negint.major](buf3, token) {
+      this[Type.uint.major](buf3, token);
     }
     /**
      * @param {Bl} _buf
@@ -8946,28 +8946,28 @@ You can use close({ resize: true }) to resize header`);
      * @param {Bl} buf
      * @param {Token} token
      */
-    [Type.string.major](buf2, token) {
-      this.prefix(buf2);
+    [Type.string.major](buf3, token) {
+      this.prefix(buf3);
       const byts = fromString2(JSON.stringify(token.value));
-      buf2.push(byts.length > 32 ? asU8A(byts) : byts);
+      buf3.push(byts.length > 32 ? asU8A(byts) : byts);
     }
     /**
      * @param {Bl} buf
      * @param {Token} _token
      */
-    [Type.array.major](buf2, _token) {
-      this.prefix(buf2);
+    [Type.array.major](buf3, _token) {
+      this.prefix(buf3);
       this.inRecursive.push({ type: Type.array, elements: 0 });
-      buf2.push([91]);
+      buf3.push([91]);
     }
     /**
      * @param {Bl} buf
      * @param {Token} _token
      */
-    [Type.map.major](buf2, _token) {
-      this.prefix(buf2);
+    [Type.map.major](buf3, _token) {
+      this.prefix(buf3);
       this.inRecursive.push({ type: Type.map, elements: 0 });
-      buf2.push([123]);
+      buf3.push([123]);
     }
     /**
      * @param {Bl} _buf
@@ -8979,14 +8979,14 @@ You can use close({ resize: true }) to resize header`);
      * @param {Bl} buf
      * @param {Token} token
      */
-    [Type.float.major](buf2, token) {
+    [Type.float.major](buf3, token) {
       if (token.type.name === "break") {
         const recurs = this.inRecursive.pop();
         if (recurs) {
           if (recurs.type === Type.array) {
-            buf2.push([93]);
+            buf3.push([93]);
           } else if (recurs.type === Type.map) {
-            buf2.push([125]);
+            buf3.push([125]);
           } else {
             throw new Error("Unexpected recursive type; this should not happen!");
           }
@@ -8997,22 +8997,22 @@ You can use close({ resize: true }) to resize header`);
       if (token.value === void 0) {
         throw new Error(`${encodeErrPrefix} unsupported type: undefined`);
       }
-      this.prefix(buf2);
+      this.prefix(buf3);
       if (token.type.name === "true") {
-        buf2.push([116, 114, 117, 101]);
+        buf3.push([116, 114, 117, 101]);
         return;
       } else if (token.type.name === "false") {
-        buf2.push([102, 97, 108, 115, 101]);
+        buf3.push([102, 97, 108, 115, 101]);
         return;
       } else if (token.type.name === "null") {
-        buf2.push([110, 117, 108, 108]);
+        buf3.push([110, 117, 108, 108]);
         return;
       }
-      const is2 = String(token.value);
+      const is3 = String(token.value);
       const isa = [];
       let dp = false;
-      for (let i = 0; i < is2.length; i++) {
-        isa[i] = is2.charCodeAt(i);
+      for (let i = 0; i < is3.length; i++) {
+        isa[i] = is3.charCodeAt(i);
         if (!dp && (isa[i] === 46 || isa[i] === 101 || isa[i] === 69)) {
           dp = true;
         }
@@ -9021,7 +9021,7 @@ You can use close({ resize: true }) to resize header`);
         isa.push(46);
         isa.push(48);
       }
-      buf2.push(isa);
+      buf3.push(isa);
     }
   };
   function mapSorter2(e1, e2) {
@@ -9431,17 +9431,17 @@ You can use close({ resize: true }) to resize header`);
   }
 
   // ../../node_modules/.pnpm/multiformats@13.0.1/node_modules/multiformats/dist/src/hashes/hasher.js
-  function from4({ name: name7, code: code8, encode: encode19 }) {
-    return new Hasher2(name7, code8, encode19);
+  function from4({ name: name7, code: code8, encode: encode20 }) {
+    return new Hasher2(name7, code8, encode20);
   }
   var Hasher2 = class {
     name;
     code;
     encode;
-    constructor(name7, code8, encode19) {
+    constructor(name7, code8, encode20) {
       this.name = name7;
       this.code = code8;
-      this.encode = encode19;
+      this.encode = encode20;
     }
     digest(input) {
       if (input instanceof Uint8Array) {
@@ -9661,8 +9661,8 @@ You can use close({ resize: true }) to resize header`);
     for (const { cid, bytes } of t.entries()) {
       size += blockLength({ cid, bytes });
     }
-    const buffer2 = new Uint8Array(size);
-    const writer = createWriter(buffer2, { headerSize });
+    const buffer3 = new Uint8Array(size);
+    const writer = createWriter(buffer3, { headerSize });
     for (const r of roots) {
       writer.addRoot(r);
     }
@@ -9700,11 +9700,11 @@ You can use close({ resize: true }) to resize header`);
       buff[0] = value & 255;
       return buff;
     };
-    const readUInt32LE2 = (buffer2) => {
-      const offset = buffer2.byteLength - 4;
-      return (buffer2[offset] | buffer2[offset + 1] << 8 | buffer2[offset + 2] << 16) + buffer2[offset + 3] * 16777216;
+    const readUInt32LE2 = (buffer3) => {
+      const offset = buffer3.byteLength - 4;
+      return (buffer3[offset] | buffer3[offset + 1] << 8 | buffer3[offset + 2] << 16) + buffer3[offset + 3] * 16777216;
     };
-    const concat3 = (buffers) => {
+    const concat4 = (buffers) => {
       const uint8Arrays = buffers.map((b) => b instanceof ArrayBuffer ? new Uint8Array(b) : b);
       const totalLength = uint8Arrays.reduce((sum, arr) => sum + arr.length, 0);
       const result = new Uint8Array(totalLength);
@@ -9715,7 +9715,7 @@ You can use close({ resize: true }) to resize header`);
       }
       return result;
     };
-    const encode32 = ({ iv, bytes }) => concat3([iv, bytes]);
+    const encode32 = ({ iv, bytes }) => concat4([iv, bytes]);
     const decode32 = (bytes) => {
       const iv = bytes.subarray(0, 12);
       bytes = bytes.slice(12);
@@ -9762,7 +9762,7 @@ You can use close({ resize: true }) to resize header`);
     }) => {
       const len = enc32(cid.bytes.byteLength);
       const iv = randomBytes22(12);
-      const msg = concat3([len, cid.bytes, bytes]);
+      const msg = concat4([len, cid.bytes, bytes]);
       try {
         const cryKey = await subtleKey(key);
         const deBytes = await crypto2.subtle.encrypt(
@@ -9968,7 +9968,7 @@ You can use close({ resize: true }) to resize header`);
     }
     return bytes;
   }
-  var PACKAGE_VERSION = "0.17.5";
+  var PACKAGE_VERSION = "0.17.7";
   var match = PACKAGE_VERSION.match(/^([^.]*\.[^.]*)/);
   if (!match)
     throw new Error("invalid version: " + PACKAGE_VERSION);
@@ -10771,7 +10771,7 @@ You can use close({ resize: true }) to resize header`);
   }));
 
   // ../encrypted-blockstore/dist/lib/store-web.js
-  var PACKAGE_VERSION2 = "0.17.5";
+  var PACKAGE_VERSION2 = "0.17.7";
   var match2 = PACKAGE_VERSION2.match(/^([^.]*\.[^.]*)/);
   if (!match2)
     throw new Error("invalid version: " + PACKAGE_VERSION2);
@@ -11069,7 +11069,7 @@ You can use close({ resize: true }) to resize header`);
     makeRemoteWAL
   };
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/clock/index.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/clock/index.js
   var advance = async (blocks, head, event) => {
     const events = new EventFetcher(blocks);
     const headmap = new Map(head.map((cid) => [cid.toString(), cid]));
@@ -11195,10 +11195,1452 @@ You can use close({ resize: true }) to resize header`);
   };
   var shortLink = (l) => `${String(l).slice(0, 4)}..${String(l).slice(-4)}`;
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/shard.js
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/is.js
+  var typeofs2 = [
+    "string",
+    "number",
+    "bigint",
+    "symbol"
+  ];
+  var objectTypeNames2 = [
+    "Function",
+    "Generator",
+    "AsyncGenerator",
+    "GeneratorFunction",
+    "AsyncGeneratorFunction",
+    "AsyncFunction",
+    "Observable",
+    "Array",
+    "Buffer",
+    "Object",
+    "RegExp",
+    "Date",
+    "Error",
+    "Map",
+    "Set",
+    "WeakMap",
+    "WeakSet",
+    "ArrayBuffer",
+    "SharedArrayBuffer",
+    "DataView",
+    "Promise",
+    "URL",
+    "HTMLElement",
+    "Int8Array",
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Int16Array",
+    "Uint16Array",
+    "Int32Array",
+    "Uint32Array",
+    "Float32Array",
+    "Float64Array",
+    "BigInt64Array",
+    "BigUint64Array"
+  ];
+  function is2(value) {
+    if (value === null) {
+      return "null";
+    }
+    if (value === void 0) {
+      return "undefined";
+    }
+    if (value === true || value === false) {
+      return "boolean";
+    }
+    const typeOf = typeof value;
+    if (typeofs2.includes(typeOf)) {
+      return typeOf;
+    }
+    if (typeOf === "function") {
+      return "Function";
+    }
+    if (Array.isArray(value)) {
+      return "Array";
+    }
+    if (isBuffer3(value)) {
+      return "Buffer";
+    }
+    const objectType = getObjectType2(value);
+    if (objectType) {
+      return objectType;
+    }
+    return "Object";
+  }
+  function isBuffer3(value) {
+    return value && value.constructor && value.constructor.isBuffer && value.constructor.isBuffer.call(null, value);
+  }
+  function getObjectType2(value) {
+    const objectTypeName = Object.prototype.toString.call(value).slice(8, -1);
+    if (objectTypeNames2.includes(objectTypeName)) {
+      return objectTypeName;
+    }
+    return void 0;
+  }
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/token.js
+  var Type2 = class {
+    /**
+     * @param {number} major
+     * @param {string} name
+     * @param {boolean} terminal
+     */
+    constructor(major, name7, terminal) {
+      this.major = major;
+      this.majorEncoded = major << 5;
+      this.name = name7;
+      this.terminal = terminal;
+    }
+    /* c8 ignore next 3 */
+    toString() {
+      return `Type[${this.major}].${this.name}`;
+    }
+    /**
+     * @param {Type} typ
+     * @returns {number}
+     */
+    compare(typ) {
+      return this.major < typ.major ? -1 : this.major > typ.major ? 1 : 0;
+    }
+  };
+  Type2.uint = new Type2(0, "uint", true);
+  Type2.negint = new Type2(1, "negint", true);
+  Type2.bytes = new Type2(2, "bytes", true);
+  Type2.string = new Type2(3, "string", true);
+  Type2.array = new Type2(4, "array", false);
+  Type2.map = new Type2(5, "map", false);
+  Type2.tag = new Type2(6, "tag", false);
+  Type2.float = new Type2(7, "float", true);
+  Type2.false = new Type2(7, "false", true);
+  Type2.true = new Type2(7, "true", true);
+  Type2.null = new Type2(7, "null", true);
+  Type2.undefined = new Type2(7, "undefined", true);
+  Type2.break = new Type2(7, "break", true);
+  var Token2 = class {
+    /**
+     * @param {Type} type
+     * @param {any} [value]
+     * @param {number} [encodedLength]
+     */
+    constructor(type2, value, encodedLength2) {
+      this.type = type2;
+      this.value = value;
+      this.encodedLength = encodedLength2;
+      this.encodedBytes = void 0;
+      this.byteValue = void 0;
+    }
+    /* c8 ignore next 3 */
+    toString() {
+      return `Token[${this.type}].${this.value}`;
+    }
+  };
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/byte-utils.js
+  var useBuffer2 = globalThis.process && // @ts-ignore
+  !globalThis.process.browser && // @ts-ignore
+  globalThis.Buffer && // @ts-ignore
+  typeof globalThis.Buffer.isBuffer === "function";
+  var textDecoder2 = new TextDecoder();
+  var textEncoder2 = new TextEncoder();
+  function isBuffer4(buf3) {
+    return useBuffer2 && globalThis.Buffer.isBuffer(buf3);
+  }
+  function asU8A2(buf3) {
+    if (!(buf3 instanceof Uint8Array)) {
+      return Uint8Array.from(buf3);
+    }
+    return isBuffer4(buf3) ? new Uint8Array(buf3.buffer, buf3.byteOffset, buf3.byteLength) : buf3;
+  }
+  var toString4 = useBuffer2 ? (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      return end - start > 64 ? (
+        // eslint-disable-line operator-linebreak
+        // @ts-ignore
+        globalThis.Buffer.from(bytes.subarray(start, end)).toString("utf8")
+      ) : utf8Slice2(bytes, start, end);
+    }
+  ) : (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      return end - start > 64 ? textDecoder2.decode(bytes.subarray(start, end)) : utf8Slice2(bytes, start, end);
+    }
+  );
+  var fromString4 = useBuffer2 ? (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {string} string
+     */
+    (string3) => {
+      return string3.length > 64 ? (
+        // eslint-disable-line operator-linebreak
+        // @ts-ignore
+        globalThis.Buffer.from(string3)
+      ) : utf8ToBytes2(string3);
+    }
+  ) : (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {string} string
+     */
+    (string3) => {
+      return string3.length > 64 ? textEncoder2.encode(string3) : utf8ToBytes2(string3);
+    }
+  );
+  var fromArray2 = (arr) => {
+    return Uint8Array.from(arr);
+  };
+  var slice2 = useBuffer2 ? (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      if (isBuffer4(bytes)) {
+        return new Uint8Array(bytes.subarray(start, end));
+      }
+      return bytes.slice(start, end);
+    }
+  ) : (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array} bytes
+     * @param {number} start
+     * @param {number} end
+     */
+    (bytes, start, end) => {
+      return bytes.slice(start, end);
+    }
+  );
+  var concat2 = useBuffer2 ? (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array[]} chunks
+     * @param {number} length
+     * @returns {Uint8Array}
+     */
+    (chunks, length5) => {
+      chunks = chunks.map((c) => c instanceof Uint8Array ? c : (
+        // eslint-disable-line operator-linebreak
+        // @ts-ignore
+        globalThis.Buffer.from(c)
+      ));
+      return asU8A2(globalThis.Buffer.concat(chunks, length5));
+    }
+  ) : (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {Uint8Array[]} chunks
+     * @param {number} length
+     * @returns {Uint8Array}
+     */
+    (chunks, length5) => {
+      const out = new Uint8Array(length5);
+      let off = 0;
+      for (let b of chunks) {
+        if (off + b.length > out.length) {
+          b = b.subarray(0, out.length - off);
+        }
+        out.set(b, off);
+        off += b.length;
+      }
+      return out;
+    }
+  );
+  var alloc2 = useBuffer2 ? (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {number} size
+     * @returns {Uint8Array}
+     */
+    (size) => {
+      return globalThis.Buffer.allocUnsafe(size);
+    }
+  ) : (
+    // eslint-disable-line operator-linebreak
+    /**
+     * @param {number} size
+     * @returns {Uint8Array}
+     */
+    (size) => {
+      return new Uint8Array(size);
+    }
+  );
+  function compare3(b1, b2) {
+    if (isBuffer4(b1) && isBuffer4(b2)) {
+      return b1.compare(b2);
+    }
+    for (let i = 0; i < b1.length; i++) {
+      if (b1[i] === b2[i]) {
+        continue;
+      }
+      return b1[i] < b2[i] ? -1 : 1;
+    }
+    return 0;
+  }
+  function utf8ToBytes2(str) {
+    const out = [];
+    let p = 0;
+    for (let i = 0; i < str.length; i++) {
+      let c = str.charCodeAt(i);
+      if (c < 128) {
+        out[p++] = c;
+      } else if (c < 2048) {
+        out[p++] = c >> 6 | 192;
+        out[p++] = c & 63 | 128;
+      } else if ((c & 64512) === 55296 && i + 1 < str.length && (str.charCodeAt(i + 1) & 64512) === 56320) {
+        c = 65536 + ((c & 1023) << 10) + (str.charCodeAt(++i) & 1023);
+        out[p++] = c >> 18 | 240;
+        out[p++] = c >> 12 & 63 | 128;
+        out[p++] = c >> 6 & 63 | 128;
+        out[p++] = c & 63 | 128;
+      } else {
+        out[p++] = c >> 12 | 224;
+        out[p++] = c >> 6 & 63 | 128;
+        out[p++] = c & 63 | 128;
+      }
+    }
+    return out;
+  }
+  function utf8Slice2(buf3, offset, end) {
+    const res = [];
+    while (offset < end) {
+      const firstByte = buf3[offset];
+      let codePoint = null;
+      let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+      if (offset + bytesPerSequence <= end) {
+        let secondByte, thirdByte, fourthByte, tempCodePoint;
+        switch (bytesPerSequence) {
+          case 1:
+            if (firstByte < 128) {
+              codePoint = firstByte;
+            }
+            break;
+          case 2:
+            secondByte = buf3[offset + 1];
+            if ((secondByte & 192) === 128) {
+              tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+              if (tempCodePoint > 127) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 3:
+            secondByte = buf3[offset + 1];
+            thirdByte = buf3[offset + 2];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+              if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                codePoint = tempCodePoint;
+              }
+            }
+            break;
+          case 4:
+            secondByte = buf3[offset + 1];
+            thirdByte = buf3[offset + 2];
+            fourthByte = buf3[offset + 3];
+            if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+              tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+              if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                codePoint = tempCodePoint;
+              }
+            }
+        }
+      }
+      if (codePoint === null) {
+        codePoint = 65533;
+        bytesPerSequence = 1;
+      } else if (codePoint > 65535) {
+        codePoint -= 65536;
+        res.push(codePoint >>> 10 & 1023 | 55296);
+        codePoint = 56320 | codePoint & 1023;
+      }
+      res.push(codePoint);
+      offset += bytesPerSequence;
+    }
+    return decodeCodePointsArray2(res);
+  }
+  var MAX_ARGUMENTS_LENGTH2 = 4096;
+  function decodeCodePointsArray2(codePoints) {
+    const len = codePoints.length;
+    if (len <= MAX_ARGUMENTS_LENGTH2) {
+      return String.fromCharCode.apply(String, codePoints);
+    }
+    let res = "";
+    let i = 0;
+    while (i < len) {
+      res += String.fromCharCode.apply(
+        String,
+        codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH2)
+      );
+    }
+    return res;
+  }
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/bl.js
+  var defaultChunkSize2 = 256;
+  var Bl2 = class {
+    /**
+     * @param {number} [chunkSize]
+     */
+    constructor(chunkSize = defaultChunkSize2) {
+      this.chunkSize = chunkSize;
+      this.cursor = 0;
+      this.maxCursor = -1;
+      this.chunks = [];
+      this._initReuseChunk = null;
+    }
+    reset() {
+      this.cursor = 0;
+      this.maxCursor = -1;
+      if (this.chunks.length) {
+        this.chunks = [];
+      }
+      if (this._initReuseChunk !== null) {
+        this.chunks.push(this._initReuseChunk);
+        this.maxCursor = this._initReuseChunk.length - 1;
+      }
+    }
+    /**
+     * @param {Uint8Array|number[]} bytes
+     */
+    push(bytes) {
+      let topChunk = this.chunks[this.chunks.length - 1];
+      const newMax = this.cursor + bytes.length;
+      if (newMax <= this.maxCursor + 1) {
+        const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+        topChunk.set(bytes, chunkPos);
+      } else {
+        if (topChunk) {
+          const chunkPos = topChunk.length - (this.maxCursor - this.cursor) - 1;
+          if (chunkPos < topChunk.length) {
+            this.chunks[this.chunks.length - 1] = topChunk.subarray(0, chunkPos);
+            this.maxCursor = this.cursor - 1;
+          }
+        }
+        if (bytes.length < 64 && bytes.length < this.chunkSize) {
+          topChunk = alloc2(this.chunkSize);
+          this.chunks.push(topChunk);
+          this.maxCursor += topChunk.length;
+          if (this._initReuseChunk === null) {
+            this._initReuseChunk = topChunk;
+          }
+          topChunk.set(bytes, 0);
+        } else {
+          this.chunks.push(bytes);
+          this.maxCursor += bytes.length;
+        }
+      }
+      this.cursor += bytes.length;
+    }
+    /**
+     * @param {boolean} [reset]
+     * @returns {Uint8Array}
+     */
+    toBytes(reset = false) {
+      let byts;
+      if (this.chunks.length === 1) {
+        const chunk = this.chunks[0];
+        if (reset && this.cursor > chunk.length / 2) {
+          byts = this.cursor === chunk.length ? chunk : chunk.subarray(0, this.cursor);
+          this._initReuseChunk = null;
+          this.chunks = [];
+        } else {
+          byts = slice2(chunk, 0, this.cursor);
+        }
+      } else {
+        byts = concat2(this.chunks, this.cursor);
+      }
+      if (reset) {
+        this.reset();
+      }
+      return byts;
+    }
+  };
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/common.js
+  var decodeErrPrefix2 = "CBOR decode error:";
+  var encodeErrPrefix2 = "CBOR encode error:";
+  var uintMinorPrefixBytes2 = [];
+  uintMinorPrefixBytes2[23] = 1;
+  uintMinorPrefixBytes2[24] = 2;
+  uintMinorPrefixBytes2[25] = 3;
+  uintMinorPrefixBytes2[26] = 5;
+  uintMinorPrefixBytes2[27] = 9;
+  function assertEnoughData2(data, pos, need) {
+    if (data.length - pos < need) {
+      throw new Error(`${decodeErrPrefix2} not enough data for type`);
+    }
+  }
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/0uint.js
+  var uintBoundaries2 = [24, 256, 65536, 4294967296, BigInt("18446744073709551616")];
+  function readUint82(data, offset, options) {
+    assertEnoughData2(data, offset, 1);
+    const value = data[offset];
+    if (options.strict === true && value < uintBoundaries2[0]) {
+      throw new Error(`${decodeErrPrefix2} integer encoded in more bytes than necessary (strict decode)`);
+    }
+    return value;
+  }
+  function readUint162(data, offset, options) {
+    assertEnoughData2(data, offset, 2);
+    const value = data[offset] << 8 | data[offset + 1];
+    if (options.strict === true && value < uintBoundaries2[1]) {
+      throw new Error(`${decodeErrPrefix2} integer encoded in more bytes than necessary (strict decode)`);
+    }
+    return value;
+  }
+  function readUint322(data, offset, options) {
+    assertEnoughData2(data, offset, 4);
+    const value = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
+    if (options.strict === true && value < uintBoundaries2[2]) {
+      throw new Error(`${decodeErrPrefix2} integer encoded in more bytes than necessary (strict decode)`);
+    }
+    return value;
+  }
+  function readUint642(data, offset, options) {
+    assertEnoughData2(data, offset, 8);
+    const hi = data[offset] * 16777216 + (data[offset + 1] << 16) + (data[offset + 2] << 8) + data[offset + 3];
+    const lo = data[offset + 4] * 16777216 + (data[offset + 5] << 16) + (data[offset + 6] << 8) + data[offset + 7];
+    const value = (BigInt(hi) << BigInt(32)) + BigInt(lo);
+    if (options.strict === true && value < uintBoundaries2[3]) {
+      throw new Error(`${decodeErrPrefix2} integer encoded in more bytes than necessary (strict decode)`);
+    }
+    if (value <= Number.MAX_SAFE_INTEGER) {
+      return Number(value);
+    }
+    if (options.allowBigInt === true) {
+      return value;
+    }
+    throw new Error(`${decodeErrPrefix2} integers outside of the safe integer range are not supported`);
+  }
+  function decodeUint82(data, pos, _minor, options) {
+    return new Token2(Type2.uint, readUint82(data, pos + 1, options), 2);
+  }
+  function decodeUint162(data, pos, _minor, options) {
+    return new Token2(Type2.uint, readUint162(data, pos + 1, options), 3);
+  }
+  function decodeUint322(data, pos, _minor, options) {
+    return new Token2(Type2.uint, readUint322(data, pos + 1, options), 5);
+  }
+  function decodeUint642(data, pos, _minor, options) {
+    return new Token2(Type2.uint, readUint642(data, pos + 1, options), 9);
+  }
+  function encodeUint2(buf3, token) {
+    return encodeUintValue2(buf3, 0, token.value);
+  }
+  function encodeUintValue2(buf3, major, uint) {
+    if (uint < uintBoundaries2[0]) {
+      const nuint = Number(uint);
+      buf3.push([major | nuint]);
+    } else if (uint < uintBoundaries2[1]) {
+      const nuint = Number(uint);
+      buf3.push([major | 24, nuint]);
+    } else if (uint < uintBoundaries2[2]) {
+      const nuint = Number(uint);
+      buf3.push([major | 25, nuint >>> 8, nuint & 255]);
+    } else if (uint < uintBoundaries2[3]) {
+      const nuint = Number(uint);
+      buf3.push([major | 26, nuint >>> 24 & 255, nuint >>> 16 & 255, nuint >>> 8 & 255, nuint & 255]);
+    } else {
+      const buint = BigInt(uint);
+      if (buint < uintBoundaries2[4]) {
+        const set3 = [major | 27, 0, 0, 0, 0, 0, 0, 0];
+        let lo = Number(buint & BigInt(4294967295));
+        let hi = Number(buint >> BigInt(32) & BigInt(4294967295));
+        set3[8] = lo & 255;
+        lo = lo >> 8;
+        set3[7] = lo & 255;
+        lo = lo >> 8;
+        set3[6] = lo & 255;
+        lo = lo >> 8;
+        set3[5] = lo & 255;
+        set3[4] = hi & 255;
+        hi = hi >> 8;
+        set3[3] = hi & 255;
+        hi = hi >> 8;
+        set3[2] = hi & 255;
+        hi = hi >> 8;
+        set3[1] = hi & 255;
+        buf3.push(set3);
+      } else {
+        throw new Error(`${decodeErrPrefix2} encountered BigInt larger than allowable range`);
+      }
+    }
+  }
+  encodeUint2.encodedSize = function encodedSize9(token) {
+    return encodeUintValue2.encodedSize(token.value);
+  };
+  encodeUintValue2.encodedSize = function encodedSize10(uint) {
+    if (uint < uintBoundaries2[0]) {
+      return 1;
+    }
+    if (uint < uintBoundaries2[1]) {
+      return 2;
+    }
+    if (uint < uintBoundaries2[2]) {
+      return 3;
+    }
+    if (uint < uintBoundaries2[3]) {
+      return 5;
+    }
+    return 9;
+  };
+  encodeUint2.compareTokens = function compareTokens4(tok1, tok2) {
+    return tok1.value < tok2.value ? -1 : tok1.value > tok2.value ? 1 : (
+      /* c8 ignore next */
+      0
+    );
+  };
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/1negint.js
+  function decodeNegint82(data, pos, _minor, options) {
+    return new Token2(Type2.negint, -1 - readUint82(data, pos + 1, options), 2);
+  }
+  function decodeNegint162(data, pos, _minor, options) {
+    return new Token2(Type2.negint, -1 - readUint162(data, pos + 1, options), 3);
+  }
+  function decodeNegint322(data, pos, _minor, options) {
+    return new Token2(Type2.negint, -1 - readUint322(data, pos + 1, options), 5);
+  }
+  var neg1b2 = BigInt(-1);
+  var pos1b2 = BigInt(1);
+  function decodeNegint642(data, pos, _minor, options) {
+    const int = readUint642(data, pos + 1, options);
+    if (typeof int !== "bigint") {
+      const value = -1 - int;
+      if (value >= Number.MIN_SAFE_INTEGER) {
+        return new Token2(Type2.negint, value, 9);
+      }
+    }
+    if (options.allowBigInt !== true) {
+      throw new Error(`${decodeErrPrefix2} integers outside of the safe integer range are not supported`);
+    }
+    return new Token2(Type2.negint, neg1b2 - BigInt(int), 9);
+  }
+  function encodeNegint2(buf3, token) {
+    const negint = token.value;
+    const unsigned = typeof negint === "bigint" ? negint * neg1b2 - pos1b2 : negint * -1 - 1;
+    encodeUintValue2(buf3, token.type.majorEncoded, unsigned);
+  }
+  encodeNegint2.encodedSize = function encodedSize11(token) {
+    const negint = token.value;
+    const unsigned = typeof negint === "bigint" ? negint * neg1b2 - pos1b2 : negint * -1 - 1;
+    if (unsigned < uintBoundaries2[0]) {
+      return 1;
+    }
+    if (unsigned < uintBoundaries2[1]) {
+      return 2;
+    }
+    if (unsigned < uintBoundaries2[2]) {
+      return 3;
+    }
+    if (unsigned < uintBoundaries2[3]) {
+      return 5;
+    }
+    return 9;
+  };
+  encodeNegint2.compareTokens = function compareTokens5(tok1, tok2) {
+    return tok1.value < tok2.value ? 1 : tok1.value > tok2.value ? -1 : (
+      /* c8 ignore next */
+      0
+    );
+  };
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/2bytes.js
+  function toToken5(data, pos, prefix, length5) {
+    assertEnoughData2(data, pos, prefix + length5);
+    const buf3 = slice2(data, pos + prefix, pos + prefix + length5);
+    return new Token2(Type2.bytes, buf3, prefix + length5);
+  }
+  function decodeBytesCompact2(data, pos, minor, _options) {
+    return toToken5(data, pos, 1, minor);
+  }
+  function decodeBytes82(data, pos, _minor, options) {
+    return toToken5(data, pos, 2, readUint82(data, pos + 1, options));
+  }
+  function decodeBytes162(data, pos, _minor, options) {
+    return toToken5(data, pos, 3, readUint162(data, pos + 1, options));
+  }
+  function decodeBytes322(data, pos, _minor, options) {
+    return toToken5(data, pos, 5, readUint322(data, pos + 1, options));
+  }
+  function decodeBytes642(data, pos, _minor, options) {
+    const l = readUint642(data, pos + 1, options);
+    if (typeof l === "bigint") {
+      throw new Error(`${decodeErrPrefix2} 64-bit integer bytes lengths not supported`);
+    }
+    return toToken5(data, pos, 9, l);
+  }
+  function tokenBytes2(token) {
+    if (token.encodedBytes === void 0) {
+      token.encodedBytes = token.type === Type2.string ? fromString4(token.value) : token.value;
+    }
+    return token.encodedBytes;
+  }
+  function encodeBytes2(buf3, token) {
+    const bytes = tokenBytes2(token);
+    encodeUintValue2(buf3, token.type.majorEncoded, bytes.length);
+    buf3.push(bytes);
+  }
+  encodeBytes2.encodedSize = function encodedSize12(token) {
+    const bytes = tokenBytes2(token);
+    return encodeUintValue2.encodedSize(bytes.length) + bytes.length;
+  };
+  encodeBytes2.compareTokens = function compareTokens6(tok1, tok2) {
+    return compareBytes2(tokenBytes2(tok1), tokenBytes2(tok2));
+  };
+  function compareBytes2(b1, b2) {
+    return b1.length < b2.length ? -1 : b1.length > b2.length ? 1 : compare3(b1, b2);
+  }
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/3string.js
+  function toToken6(data, pos, prefix, length5, options) {
+    const totLength = prefix + length5;
+    assertEnoughData2(data, pos, totLength);
+    const tok = new Token2(Type2.string, toString4(data, pos + prefix, pos + totLength), totLength);
+    if (options.retainStringBytes === true) {
+      tok.byteValue = slice2(data, pos + prefix, pos + totLength);
+    }
+    return tok;
+  }
+  function decodeStringCompact2(data, pos, minor, options) {
+    return toToken6(data, pos, 1, minor, options);
+  }
+  function decodeString82(data, pos, _minor, options) {
+    return toToken6(data, pos, 2, readUint82(data, pos + 1, options), options);
+  }
+  function decodeString162(data, pos, _minor, options) {
+    return toToken6(data, pos, 3, readUint162(data, pos + 1, options), options);
+  }
+  function decodeString322(data, pos, _minor, options) {
+    return toToken6(data, pos, 5, readUint322(data, pos + 1, options), options);
+  }
+  function decodeString642(data, pos, _minor, options) {
+    const l = readUint642(data, pos + 1, options);
+    if (typeof l === "bigint") {
+      throw new Error(`${decodeErrPrefix2} 64-bit integer string lengths not supported`);
+    }
+    return toToken6(data, pos, 9, l, options);
+  }
+  var encodeString2 = encodeBytes2;
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/4array.js
+  function toToken7(_data, _pos, prefix, length5) {
+    return new Token2(Type2.array, length5, prefix);
+  }
+  function decodeArrayCompact2(data, pos, minor, _options) {
+    return toToken7(data, pos, 1, minor);
+  }
+  function decodeArray82(data, pos, _minor, options) {
+    return toToken7(data, pos, 2, readUint82(data, pos + 1, options));
+  }
+  function decodeArray162(data, pos, _minor, options) {
+    return toToken7(data, pos, 3, readUint162(data, pos + 1, options));
+  }
+  function decodeArray322(data, pos, _minor, options) {
+    return toToken7(data, pos, 5, readUint322(data, pos + 1, options));
+  }
+  function decodeArray642(data, pos, _minor, options) {
+    const l = readUint642(data, pos + 1, options);
+    if (typeof l === "bigint") {
+      throw new Error(`${decodeErrPrefix2} 64-bit integer array lengths not supported`);
+    }
+    return toToken7(data, pos, 9, l);
+  }
+  function decodeArrayIndefinite2(data, pos, _minor, options) {
+    if (options.allowIndefinite === false) {
+      throw new Error(`${decodeErrPrefix2} indefinite length items not allowed`);
+    }
+    return toToken7(data, pos, 1, Infinity);
+  }
+  function encodeArray2(buf3, token) {
+    encodeUintValue2(buf3, Type2.array.majorEncoded, token.value);
+  }
+  encodeArray2.compareTokens = encodeUint2.compareTokens;
+  encodeArray2.encodedSize = function encodedSize13(token) {
+    return encodeUintValue2.encodedSize(token.value);
+  };
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/5map.js
+  function toToken8(_data, _pos, prefix, length5) {
+    return new Token2(Type2.map, length5, prefix);
+  }
+  function decodeMapCompact2(data, pos, minor, _options) {
+    return toToken8(data, pos, 1, minor);
+  }
+  function decodeMap82(data, pos, _minor, options) {
+    return toToken8(data, pos, 2, readUint82(data, pos + 1, options));
+  }
+  function decodeMap162(data, pos, _minor, options) {
+    return toToken8(data, pos, 3, readUint162(data, pos + 1, options));
+  }
+  function decodeMap322(data, pos, _minor, options) {
+    return toToken8(data, pos, 5, readUint322(data, pos + 1, options));
+  }
+  function decodeMap642(data, pos, _minor, options) {
+    const l = readUint642(data, pos + 1, options);
+    if (typeof l === "bigint") {
+      throw new Error(`${decodeErrPrefix2} 64-bit integer map lengths not supported`);
+    }
+    return toToken8(data, pos, 9, l);
+  }
+  function decodeMapIndefinite2(data, pos, _minor, options) {
+    if (options.allowIndefinite === false) {
+      throw new Error(`${decodeErrPrefix2} indefinite length items not allowed`);
+    }
+    return toToken8(data, pos, 1, Infinity);
+  }
+  function encodeMap2(buf3, token) {
+    encodeUintValue2(buf3, Type2.map.majorEncoded, token.value);
+  }
+  encodeMap2.compareTokens = encodeUint2.compareTokens;
+  encodeMap2.encodedSize = function encodedSize14(token) {
+    return encodeUintValue2.encodedSize(token.value);
+  };
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/6tag.js
+  function decodeTagCompact2(_data, _pos, minor, _options) {
+    return new Token2(Type2.tag, minor, 1);
+  }
+  function decodeTag82(data, pos, _minor, options) {
+    return new Token2(Type2.tag, readUint82(data, pos + 1, options), 2);
+  }
+  function decodeTag162(data, pos, _minor, options) {
+    return new Token2(Type2.tag, readUint162(data, pos + 1, options), 3);
+  }
+  function decodeTag322(data, pos, _minor, options) {
+    return new Token2(Type2.tag, readUint322(data, pos + 1, options), 5);
+  }
+  function decodeTag642(data, pos, _minor, options) {
+    return new Token2(Type2.tag, readUint642(data, pos + 1, options), 9);
+  }
+  function encodeTag2(buf3, token) {
+    encodeUintValue2(buf3, Type2.tag.majorEncoded, token.value);
+  }
+  encodeTag2.compareTokens = encodeUint2.compareTokens;
+  encodeTag2.encodedSize = function encodedSize15(token) {
+    return encodeUintValue2.encodedSize(token.value);
+  };
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/7float.js
+  var MINOR_FALSE2 = 20;
+  var MINOR_TRUE2 = 21;
+  var MINOR_NULL2 = 22;
+  var MINOR_UNDEFINED2 = 23;
+  function decodeUndefined2(_data, _pos, _minor, options) {
+    if (options.allowUndefined === false) {
+      throw new Error(`${decodeErrPrefix2} undefined values are not supported`);
+    } else if (options.coerceUndefinedToNull === true) {
+      return new Token2(Type2.null, null, 1);
+    }
+    return new Token2(Type2.undefined, void 0, 1);
+  }
+  function decodeBreak2(_data, _pos, _minor, options) {
+    if (options.allowIndefinite === false) {
+      throw new Error(`${decodeErrPrefix2} indefinite length items not allowed`);
+    }
+    return new Token2(Type2.break, void 0, 1);
+  }
+  function createToken2(value, bytes, options) {
+    if (options) {
+      if (options.allowNaN === false && Number.isNaN(value)) {
+        throw new Error(`${decodeErrPrefix2} NaN values are not supported`);
+      }
+      if (options.allowInfinity === false && (value === Infinity || value === -Infinity)) {
+        throw new Error(`${decodeErrPrefix2} Infinity values are not supported`);
+      }
+    }
+    return new Token2(Type2.float, value, bytes);
+  }
+  function decodeFloat162(data, pos, _minor, options) {
+    return createToken2(readFloat162(data, pos + 1), 3, options);
+  }
+  function decodeFloat322(data, pos, _minor, options) {
+    return createToken2(readFloat322(data, pos + 1), 5, options);
+  }
+  function decodeFloat642(data, pos, _minor, options) {
+    return createToken2(readFloat642(data, pos + 1), 9, options);
+  }
+  function encodeFloat2(buf3, token, options) {
+    const float = token.value;
+    if (float === false) {
+      buf3.push([Type2.float.majorEncoded | MINOR_FALSE2]);
+    } else if (float === true) {
+      buf3.push([Type2.float.majorEncoded | MINOR_TRUE2]);
+    } else if (float === null) {
+      buf3.push([Type2.float.majorEncoded | MINOR_NULL2]);
+    } else if (float === void 0) {
+      buf3.push([Type2.float.majorEncoded | MINOR_UNDEFINED2]);
+    } else {
+      let decoded;
+      let success = false;
+      if (!options || options.float64 !== true) {
+        encodeFloat162(float);
+        decoded = readFloat162(ui8a2, 1);
+        if (float === decoded || Number.isNaN(float)) {
+          ui8a2[0] = 249;
+          buf3.push(ui8a2.slice(0, 3));
+          success = true;
+        } else {
+          encodeFloat322(float);
+          decoded = readFloat322(ui8a2, 1);
+          if (float === decoded) {
+            ui8a2[0] = 250;
+            buf3.push(ui8a2.slice(0, 5));
+            success = true;
+          }
+        }
+      }
+      if (!success) {
+        encodeFloat642(float);
+        decoded = readFloat642(ui8a2, 1);
+        ui8a2[0] = 251;
+        buf3.push(ui8a2.slice(0, 9));
+      }
+    }
+  }
+  encodeFloat2.encodedSize = function encodedSize16(token, options) {
+    const float = token.value;
+    if (float === false || float === true || float === null || float === void 0) {
+      return 1;
+    }
+    if (!options || options.float64 !== true) {
+      encodeFloat162(float);
+      let decoded = readFloat162(ui8a2, 1);
+      if (float === decoded || Number.isNaN(float)) {
+        return 3;
+      }
+      encodeFloat322(float);
+      decoded = readFloat322(ui8a2, 1);
+      if (float === decoded) {
+        return 5;
+      }
+    }
+    return 9;
+  };
+  var buffer2 = new ArrayBuffer(9);
+  var dataView2 = new DataView(buffer2, 1);
+  var ui8a2 = new Uint8Array(buffer2, 0);
+  function encodeFloat162(inp) {
+    if (inp === Infinity) {
+      dataView2.setUint16(0, 31744, false);
+    } else if (inp === -Infinity) {
+      dataView2.setUint16(0, 64512, false);
+    } else if (Number.isNaN(inp)) {
+      dataView2.setUint16(0, 32256, false);
+    } else {
+      dataView2.setFloat32(0, inp);
+      const valu32 = dataView2.getUint32(0);
+      const exponent = (valu32 & 2139095040) >> 23;
+      const mantissa = valu32 & 8388607;
+      if (exponent === 255) {
+        dataView2.setUint16(0, 31744, false);
+      } else if (exponent === 0) {
+        dataView2.setUint16(0, (inp & 2147483648) >> 16 | mantissa >> 13, false);
+      } else {
+        const logicalExponent = exponent - 127;
+        if (logicalExponent < -24) {
+          dataView2.setUint16(0, 0);
+        } else if (logicalExponent < -14) {
+          dataView2.setUint16(0, (valu32 & 2147483648) >> 16 | /* sign bit */
+          1 << 24 + logicalExponent, false);
+        } else {
+          dataView2.setUint16(0, (valu32 & 2147483648) >> 16 | logicalExponent + 15 << 10 | mantissa >> 13, false);
+        }
+      }
+    }
+  }
+  function readFloat162(ui8a3, pos) {
+    if (ui8a3.length - pos < 2) {
+      throw new Error(`${decodeErrPrefix2} not enough data for float16`);
+    }
+    const half = (ui8a3[pos] << 8) + ui8a3[pos + 1];
+    if (half === 31744) {
+      return Infinity;
+    }
+    if (half === 64512) {
+      return -Infinity;
+    }
+    if (half === 32256) {
+      return NaN;
+    }
+    const exp = half >> 10 & 31;
+    const mant = half & 1023;
+    let val;
+    if (exp === 0) {
+      val = mant * 2 ** -24;
+    } else if (exp !== 31) {
+      val = (mant + 1024) * 2 ** (exp - 25);
+    } else {
+      val = mant === 0 ? Infinity : NaN;
+    }
+    return half & 32768 ? -val : val;
+  }
+  function encodeFloat322(inp) {
+    dataView2.setFloat32(0, inp, false);
+  }
+  function readFloat322(ui8a3, pos) {
+    if (ui8a3.length - pos < 4) {
+      throw new Error(`${decodeErrPrefix2} not enough data for float32`);
+    }
+    const offset = (ui8a3.byteOffset || 0) + pos;
+    return new DataView(ui8a3.buffer, offset, 4).getFloat32(0, false);
+  }
+  function encodeFloat642(inp) {
+    dataView2.setFloat64(0, inp, false);
+  }
+  function readFloat642(ui8a3, pos) {
+    if (ui8a3.length - pos < 8) {
+      throw new Error(`${decodeErrPrefix2} not enough data for float64`);
+    }
+    const offset = (ui8a3.byteOffset || 0) + pos;
+    return new DataView(ui8a3.buffer, offset, 8).getFloat64(0, false);
+  }
+  encodeFloat2.compareTokens = encodeUint2.compareTokens;
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/jump.js
+  function invalidMinor2(data, pos, minor) {
+    throw new Error(`${decodeErrPrefix2} encountered invalid minor (${minor}) for major ${data[pos] >>> 5}`);
+  }
+  function errorer2(msg) {
+    return () => {
+      throw new Error(`${decodeErrPrefix2} ${msg}`);
+    };
+  }
+  var jump2 = [];
+  for (let i = 0; i <= 23; i++) {
+    jump2[i] = invalidMinor2;
+  }
+  jump2[24] = decodeUint82;
+  jump2[25] = decodeUint162;
+  jump2[26] = decodeUint322;
+  jump2[27] = decodeUint642;
+  jump2[28] = invalidMinor2;
+  jump2[29] = invalidMinor2;
+  jump2[30] = invalidMinor2;
+  jump2[31] = invalidMinor2;
+  for (let i = 32; i <= 55; i++) {
+    jump2[i] = invalidMinor2;
+  }
+  jump2[56] = decodeNegint82;
+  jump2[57] = decodeNegint162;
+  jump2[58] = decodeNegint322;
+  jump2[59] = decodeNegint642;
+  jump2[60] = invalidMinor2;
+  jump2[61] = invalidMinor2;
+  jump2[62] = invalidMinor2;
+  jump2[63] = invalidMinor2;
+  for (let i = 64; i <= 87; i++) {
+    jump2[i] = decodeBytesCompact2;
+  }
+  jump2[88] = decodeBytes82;
+  jump2[89] = decodeBytes162;
+  jump2[90] = decodeBytes322;
+  jump2[91] = decodeBytes642;
+  jump2[92] = invalidMinor2;
+  jump2[93] = invalidMinor2;
+  jump2[94] = invalidMinor2;
+  jump2[95] = errorer2("indefinite length bytes/strings are not supported");
+  for (let i = 96; i <= 119; i++) {
+    jump2[i] = decodeStringCompact2;
+  }
+  jump2[120] = decodeString82;
+  jump2[121] = decodeString162;
+  jump2[122] = decodeString322;
+  jump2[123] = decodeString642;
+  jump2[124] = invalidMinor2;
+  jump2[125] = invalidMinor2;
+  jump2[126] = invalidMinor2;
+  jump2[127] = errorer2("indefinite length bytes/strings are not supported");
+  for (let i = 128; i <= 151; i++) {
+    jump2[i] = decodeArrayCompact2;
+  }
+  jump2[152] = decodeArray82;
+  jump2[153] = decodeArray162;
+  jump2[154] = decodeArray322;
+  jump2[155] = decodeArray642;
+  jump2[156] = invalidMinor2;
+  jump2[157] = invalidMinor2;
+  jump2[158] = invalidMinor2;
+  jump2[159] = decodeArrayIndefinite2;
+  for (let i = 160; i <= 183; i++) {
+    jump2[i] = decodeMapCompact2;
+  }
+  jump2[184] = decodeMap82;
+  jump2[185] = decodeMap162;
+  jump2[186] = decodeMap322;
+  jump2[187] = decodeMap642;
+  jump2[188] = invalidMinor2;
+  jump2[189] = invalidMinor2;
+  jump2[190] = invalidMinor2;
+  jump2[191] = decodeMapIndefinite2;
+  for (let i = 192; i <= 215; i++) {
+    jump2[i] = decodeTagCompact2;
+  }
+  jump2[216] = decodeTag82;
+  jump2[217] = decodeTag162;
+  jump2[218] = decodeTag322;
+  jump2[219] = decodeTag642;
+  jump2[220] = invalidMinor2;
+  jump2[221] = invalidMinor2;
+  jump2[222] = invalidMinor2;
+  jump2[223] = invalidMinor2;
+  for (let i = 224; i <= 243; i++) {
+    jump2[i] = errorer2("simple values are not supported");
+  }
+  jump2[244] = invalidMinor2;
+  jump2[245] = invalidMinor2;
+  jump2[246] = invalidMinor2;
+  jump2[247] = decodeUndefined2;
+  jump2[248] = errorer2("simple values are not supported");
+  jump2[249] = decodeFloat162;
+  jump2[250] = decodeFloat322;
+  jump2[251] = decodeFloat642;
+  jump2[252] = invalidMinor2;
+  jump2[253] = invalidMinor2;
+  jump2[254] = invalidMinor2;
+  jump2[255] = decodeBreak2;
+  var quick2 = [];
+  for (let i = 0; i < 24; i++) {
+    quick2[i] = new Token2(Type2.uint, i, 1);
+  }
+  for (let i = -1; i >= -24; i--) {
+    quick2[31 - i] = new Token2(Type2.negint, i, 1);
+  }
+  quick2[64] = new Token2(Type2.bytes, new Uint8Array(0), 1);
+  quick2[96] = new Token2(Type2.string, "", 1);
+  quick2[128] = new Token2(Type2.array, 0, 1);
+  quick2[160] = new Token2(Type2.map, 0, 1);
+  quick2[244] = new Token2(Type2.false, false, 1);
+  quick2[245] = new Token2(Type2.true, true, 1);
+  quick2[246] = new Token2(Type2.null, null, 1);
+  function quickEncodeToken2(token) {
+    switch (token.type) {
+      case Type2.false:
+        return fromArray2([244]);
+      case Type2.true:
+        return fromArray2([245]);
+      case Type2.null:
+        return fromArray2([246]);
+      case Type2.bytes:
+        if (!token.value.length) {
+          return fromArray2([64]);
+        }
+        return;
+      case Type2.string:
+        if (token.value === "") {
+          return fromArray2([96]);
+        }
+        return;
+      case Type2.array:
+        if (token.value === 0) {
+          return fromArray2([128]);
+        }
+        return;
+      case Type2.map:
+        if (token.value === 0) {
+          return fromArray2([160]);
+        }
+        return;
+      case Type2.uint:
+        if (token.value < 24) {
+          return fromArray2([Number(token.value)]);
+        }
+        return;
+      case Type2.negint:
+        if (token.value >= -24) {
+          return fromArray2([31 - Number(token.value)]);
+        }
+    }
+  }
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/encode.js
+  function makeCborEncoders2() {
+    const encoders = [];
+    encoders[Type2.uint.major] = encodeUint2;
+    encoders[Type2.negint.major] = encodeNegint2;
+    encoders[Type2.bytes.major] = encodeBytes2;
+    encoders[Type2.string.major] = encodeString2;
+    encoders[Type2.array.major] = encodeArray2;
+    encoders[Type2.map.major] = encodeMap2;
+    encoders[Type2.tag.major] = encodeTag2;
+    encoders[Type2.float.major] = encodeFloat2;
+    return encoders;
+  }
+  var cborEncoders3 = makeCborEncoders2();
+  var buf2 = new Bl2();
+  var Ref2 = class _Ref {
+    /**
+     * @param {object|any[]} obj
+     * @param {Reference|undefined} parent
+     */
+    constructor(obj, parent) {
+      this.obj = obj;
+      this.parent = parent;
+    }
+    /**
+     * @param {object|any[]} obj
+     * @returns {boolean}
+     */
+    includes(obj) {
+      let p = this;
+      do {
+        if (p.obj === obj) {
+          return true;
+        }
+      } while (p = p.parent);
+      return false;
+    }
+    /**
+     * @param {Reference|undefined} stack
+     * @param {object|any[]} obj
+     * @returns {Reference}
+     */
+    static createCheck(stack, obj) {
+      if (stack && stack.includes(obj)) {
+        throw new Error(`${encodeErrPrefix2} object contains circular references`);
+      }
+      return new _Ref(obj, stack);
+    }
+  };
+  var simpleTokens2 = {
+    null: new Token2(Type2.null, null),
+    undefined: new Token2(Type2.undefined, void 0),
+    true: new Token2(Type2.true, true),
+    false: new Token2(Type2.false, false),
+    emptyArray: new Token2(Type2.array, 0),
+    emptyMap: new Token2(Type2.map, 0)
+  };
+  var typeEncoders2 = {
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    number(obj, _typ, _options, _refStack) {
+      if (!Number.isInteger(obj) || !Number.isSafeInteger(obj)) {
+        return new Token2(Type2.float, obj);
+      } else if (obj >= 0) {
+        return new Token2(Type2.uint, obj);
+      } else {
+        return new Token2(Type2.negint, obj);
+      }
+    },
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    bigint(obj, _typ, _options, _refStack) {
+      if (obj >= BigInt(0)) {
+        return new Token2(Type2.uint, obj);
+      } else {
+        return new Token2(Type2.negint, obj);
+      }
+    },
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    Uint8Array(obj, _typ, _options, _refStack) {
+      return new Token2(Type2.bytes, obj);
+    },
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    string(obj, _typ, _options, _refStack) {
+      return new Token2(Type2.string, obj);
+    },
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    boolean(obj, _typ, _options, _refStack) {
+      return obj ? simpleTokens2.true : simpleTokens2.false;
+    },
+    /**
+     * @param {any} _obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    null(_obj, _typ, _options, _refStack) {
+      return simpleTokens2.null;
+    },
+    /**
+     * @param {any} _obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    undefined(_obj, _typ, _options, _refStack) {
+      return simpleTokens2.undefined;
+    },
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    ArrayBuffer(obj, _typ, _options, _refStack) {
+      return new Token2(Type2.bytes, new Uint8Array(obj));
+    },
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} _options
+     * @param {Reference} [_refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    DataView(obj, _typ, _options, _refStack) {
+      return new Token2(Type2.bytes, new Uint8Array(obj.buffer, obj.byteOffset, obj.byteLength));
+    },
+    /**
+     * @param {any} obj
+     * @param {string} _typ
+     * @param {EncodeOptions} options
+     * @param {Reference} [refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    Array(obj, _typ, options, refStack) {
+      if (!obj.length) {
+        if (options.addBreakTokens === true) {
+          return [simpleTokens2.emptyArray, new Token2(Type2.break)];
+        }
+        return simpleTokens2.emptyArray;
+      }
+      refStack = Ref2.createCheck(refStack, obj);
+      const entries3 = [];
+      let i = 0;
+      for (const e of obj) {
+        entries3[i++] = objectToTokens2(e, options, refStack);
+      }
+      if (options.addBreakTokens) {
+        return [new Token2(Type2.array, obj.length), entries3, new Token2(Type2.break)];
+      }
+      return [new Token2(Type2.array, obj.length), entries3];
+    },
+    /**
+     * @param {any} obj
+     * @param {string} typ
+     * @param {EncodeOptions} options
+     * @param {Reference} [refStack]
+     * @returns {TokenOrNestedTokens}
+     */
+    Object(obj, typ, options, refStack) {
+      const isMap = typ !== "Object";
+      const keys = isMap ? obj.keys() : Object.keys(obj);
+      const length5 = isMap ? obj.size : keys.length;
+      if (!length5) {
+        if (options.addBreakTokens === true) {
+          return [simpleTokens2.emptyMap, new Token2(Type2.break)];
+        }
+        return simpleTokens2.emptyMap;
+      }
+      refStack = Ref2.createCheck(refStack, obj);
+      const entries3 = [];
+      let i = 0;
+      for (const key of keys) {
+        entries3[i++] = [
+          objectToTokens2(key, options, refStack),
+          objectToTokens2(isMap ? obj.get(key) : obj[key], options, refStack)
+        ];
+      }
+      sortMapEntries2(entries3, options);
+      if (options.addBreakTokens) {
+        return [new Token2(Type2.map, length5), entries3, new Token2(Type2.break)];
+      }
+      return [new Token2(Type2.map, length5), entries3];
+    }
+  };
+  typeEncoders2.Map = typeEncoders2.Object;
+  typeEncoders2.Buffer = typeEncoders2.Uint8Array;
+  for (const typ of "Uint8Clamped Uint16 Uint32 Int8 Int16 Int32 BigUint64 BigInt64 Float32 Float64".split(" ")) {
+    typeEncoders2[`${typ}Array`] = typeEncoders2.DataView;
+  }
+  function objectToTokens2(obj, options = {}, refStack) {
+    const typ = is2(obj);
+    const customTypeEncoder = options && options.typeEncoders && /** @type {OptionalTypeEncoder} */
+    options.typeEncoders[typ] || typeEncoders2[typ];
+    if (typeof customTypeEncoder === "function") {
+      const tokens = customTypeEncoder(obj, typ, options, refStack);
+      if (tokens != null) {
+        return tokens;
+      }
+    }
+    const typeEncoder = typeEncoders2[typ];
+    if (!typeEncoder) {
+      throw new Error(`${encodeErrPrefix2} unsupported type: ${typ}`);
+    }
+    return typeEncoder(obj, typ, options, refStack);
+  }
+  function sortMapEntries2(entries3, options) {
+    if (options.mapSorter) {
+      entries3.sort(options.mapSorter);
+    }
+  }
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/length.js
+  var cborEncoders4 = makeCborEncoders2();
+  var defaultEncodeOptions4 = {
+    float64: false,
+    quickEncodeToken: quickEncodeToken2
+  };
+  function tokensToLength2(tokens, encoders = cborEncoders4, options = defaultEncodeOptions4) {
+    if (Array.isArray(tokens)) {
+      let len = 0;
+      for (const token of tokens) {
+        len += tokensToLength2(token, encoders, options);
+      }
+      return len;
+    } else {
+      const encoder = encoders[tokens.type.major];
+      if (encoder.encodedSize === void 0 || typeof encoder.encodedSize !== "function") {
+        throw new Error(`Encoder for ${tokens.type.name} does not have an encodedSize()`);
+      }
+      return encoder.encodedSize(tokens, options);
+    }
+  }
+
+  // ../../node_modules/.pnpm/cborg@4.1.3/node_modules/cborg/lib/decode.js
+  var DONE2 = Symbol.for("DONE");
+  var BREAK2 = Symbol.for("BREAK");
+
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/shard.js
   var MaxKeyLength = 64;
   var MaxShardSize = 512 * 1024;
-  var CID_TAG2 = new Token(Type.tag, 42);
+  var CID_TAG2 = new Token2(Type2.tag, 42);
   var ShardBlock = class extends Block {
     /**
      * @param {object} config
@@ -11327,7 +12769,7 @@ You can use close({ resize: true }) to resize header`);
     }
   };
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/index.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/index.js
   var put = async (blocks, root2, key, value) => {
     const shards = new ShardFetcher(blocks);
     const rshard = await shards.get(root2);
@@ -11485,7 +12927,7 @@ You can use close({ resize: true }) to resize header`);
     return { root: additions[additions.length - 1].cid, additions, removals };
   };
   var entries = async function* (blocks, root2, options = {}) {
-    const { prefix } = options;
+    const { prefix, gt, gte } = options;
     const shards = new ShardFetcher(blocks);
     const rshard = await shards.get(root2);
     yield* (
@@ -11495,7 +12937,7 @@ You can use close({ resize: true }) to resize header`);
           const key = shard.prefix + entry[0];
           if (Array.isArray(entry[1])) {
             if (entry[1][1]) {
-              if (!prefix || prefix && key.startsWith(prefix)) {
+              if (prefix && key.startsWith(prefix) || gt && key > gt || gte && key >= gte || !prefix && !gt && !gte) {
                 yield [key, entry[1][1]];
               }
             }
@@ -11506,13 +12948,26 @@ You can use close({ resize: true }) to resize header`);
               if (prefix.length > key.length && !prefix.startsWith(key)) {
                 continue;
               }
+            } else if (gt) {
+              if (gt.length <= key.length && !key.startsWith(gt)) {
+                continue;
+              }
+              if (gt.length > key.length && !gt.startsWith(key)) {
+                continue;
+              }
+            } else if (gte) {
+              if (gte.length <= key.length && !key.startsWith(gte)) {
+                continue;
+              }
+              if (gte.length > key.length && !gte.startsWith(key)) {
+                continue;
+              }
             }
             yield* ents(await shards.get(entry[1][0], key));
           } else {
-            if (prefix && !key.startsWith(prefix)) {
-              continue;
+            if (prefix && key.startsWith(prefix) || gt && key > gt || gte && key >= gte || !prefix && !gt && !gte) {
+              yield [key, entry[1]];
             }
-            yield [key, entry[1]];
           }
         }
       }(rshard)
@@ -11530,9 +12985,9 @@ You can use close({ resize: true }) to resize header`);
     return [shard];
   };
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/batch/shard.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/batch/shard.js
   var ShardLinkByteLength = 36;
-  var CID_TAG3 = new Token(Type.tag, 42);
+  var CID_TAG3 = new Token2(Type2.tag, 42);
   var create8 = (init2) => ({
     base: init2?.base,
     prefix: init2?.prefix ?? "",
@@ -11545,39 +13000,39 @@ You can use close({ resize: true }) to resize header`);
       entriesLength += entryEncodedLength(entry);
     }
     const tokens = [
-      new Token(Type.map, 3),
-      new Token(Type.string, "entries"),
-      new Token(Type.array, shard.entries.length),
-      new Token(Type.string, "maxKeyLength"),
-      new Token(Type.uint, shard.maxKeyLength),
-      new Token(Type.string, "maxSize"),
-      new Token(Type.uint, shard.maxSize)
+      new Token2(Type2.map, 3),
+      new Token2(Type2.string, "entries"),
+      new Token2(Type2.array, shard.entries.length),
+      new Token2(Type2.string, "maxKeyLength"),
+      new Token2(Type2.uint, shard.maxKeyLength),
+      new Token2(Type2.string, "maxSize"),
+      new Token2(Type2.uint, shard.maxSize)
     ];
-    return tokensToLength(tokens) + entriesLength;
+    return tokensToLength2(tokens) + entriesLength;
   };
   var entryEncodedLength = (entry) => {
     const tokens = [
-      new Token(Type.array, entry.length),
-      new Token(Type.string, entry[0])
+      new Token2(Type2.array, entry.length),
+      new Token2(Type2.string, entry[0])
     ];
     if (Array.isArray(entry[1])) {
-      tokens.push(new Token(Type.array, entry[1].length));
+      tokens.push(new Token2(Type2.array, entry[1].length));
       for (const item of entry[1]) {
         tokens.push(CID_TAG3);
         if (isLink(item)) {
-          tokens.push(new Token(Type.bytes, { length: item.byteLength + 1 }));
+          tokens.push(new Token2(Type2.bytes, { length: item.byteLength + 1 }));
         } else {
-          tokens.push(new Token(Type.bytes, { length: ShardLinkByteLength + 1 }));
+          tokens.push(new Token2(Type2.bytes, { length: ShardLinkByteLength + 1 }));
         }
       }
     } else {
       tokens.push(CID_TAG3);
-      tokens.push(new Token(Type.bytes, { length: entry[1].byteLength + 1 }));
+      tokens.push(new Token2(Type2.bytes, { length: entry[1].byteLength + 1 }));
     }
-    return tokensToLength(tokens);
+    return tokensToLength2(tokens);
   };
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/batch/index.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/batch/index.js
   var Batcher = class _Batcher {
     #committed = false;
     /**
@@ -11759,7 +13214,7 @@ You can use close({ resize: true }) to resize header`);
     static code = "ERR_BATCH_COMMITTED";
   };
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/crdt/index.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/crdt/index.js
   var put3 = async (blocks, head, key, value) => {
     const mblocks = new MemoryBlockstore();
     blocks = new MultiBlockFetcher(mblocks, blocks);
@@ -11997,7 +13452,7 @@ You can use close({ resize: true }) to resize header`);
     return acc.concat(...rest);
   };
 
-  // ../../node_modules/.pnpm/@web3-storage+pail@0.4.2/node_modules/@web3-storage/pail/src/crdt/batch/index.js
+  // ../../node_modules/.pnpm/@web3-storage+pail@0.5.0/node_modules/@web3-storage/pail/src/crdt/batch/index.js
   var Batcher2 = class _Batcher {
     #committed = false;
     /**
@@ -12138,9 +13593,9 @@ You can use close({ resize: true }) to resize header`);
     createSymlink: () => createSymlink,
     cumulativeContentByteLength: () => cumulativeContentByteLength,
     cumulativeDagByteLength: () => cumulativeDagByteLength,
-    decode: () => decode16,
+    decode: () => decode17,
     decodeMetadata: () => decodeMetadata,
-    encode: () => encode12,
+    encode: () => encode13,
     encodeAdvancedFile: () => encodeAdvancedFile,
     encodeComplexFile: () => encodeComplexFile,
     encodeDirectory: () => encodeDirectory,
@@ -12161,7 +13616,7 @@ You can use close({ resize: true }) to resize header`);
   });
 
   // ../../node_modules/.pnpm/@ipld+dag-pb@4.0.8/node_modules/@ipld/dag-pb/src/pb-decode.js
-  var textDecoder2 = new TextDecoder();
+  var textDecoder3 = new TextDecoder();
   function decodeVarint2(bytes, offset) {
     let v = 0;
     for (let shift = 0; ; shift += 7) {
@@ -12229,7 +13684,7 @@ You can use close({ resize: true }) to resize header`);
         }
         let byts;
         [byts, index2] = decodeBytes(bytes, index2);
-        link2.Name = textDecoder2.decode(byts);
+        link2.Name = textDecoder3.decode(byts);
       } else if (fieldNum === 3) {
         if (link2.Tsize !== void 0) {
           throw new Error("protobuf: (PBLink) duplicate Tsize section");
@@ -12292,7 +13747,7 @@ You can use close({ resize: true }) to resize header`);
   }
 
   // ../../node_modules/.pnpm/@ipld+dag-pb@4.0.8/node_modules/@ipld/dag-pb/src/pb-encode.js
-  var textEncoder2 = new TextEncoder();
+  var textEncoder3 = new TextEncoder();
   var maxInt32 = 2 ** 32;
   var maxUInt32 = 2 ** 31;
   function encodeLink(link2, bytes) {
@@ -12308,7 +13763,7 @@ You can use close({ resize: true }) to resize header`);
       bytes[i] = 24;
     }
     if (typeof link2.Name === "string") {
-      const nameBytes = textEncoder2.encode(link2.Name);
+      const nameBytes = textEncoder3.encode(link2.Name);
       i -= nameBytes.length;
       bytes.set(nameBytes, i);
       i = encodeVarint(bytes, i, nameBytes.length) - 1;
@@ -12349,7 +13804,7 @@ You can use close({ resize: true }) to resize header`);
       n += 1 + l + sov(l);
     }
     if (typeof link2.Name === "string") {
-      const l = textEncoder2.encode(link2.Name).length;
+      const l = textEncoder3.encode(link2.Name).length;
       n += 1 + l + sov(l);
     }
     if (typeof link2.Tsize === "number") {
@@ -12669,13 +14124,13 @@ You can use close({ resize: true }) to resize header`);
   // ../../node_modules/.pnpm/@ipld+dag-pb@4.0.8/node_modules/@ipld/dag-pb/src/util.js
   var pbNodeProperties = ["Data", "Links"];
   var pbLinkProperties = ["Hash", "Name", "Tsize"];
-  var textEncoder3 = new TextEncoder();
+  var textEncoder4 = new TextEncoder();
   function linkComparator(a, b) {
     if (a === b) {
       return 0;
     }
-    const abuf = a.Name ? textEncoder3.encode(a.Name) : [];
-    const bbuf = b.Name ? textEncoder3.encode(b.Name) : [];
+    const abuf = a.Name ? textEncoder4.encode(a.Name) : [];
+    const bbuf = b.Name ? textEncoder4.encode(b.Name) : [];
     let x = abuf.length;
     let y = bbuf.length;
     for (let i = 0, len = Math.min(x, y); i < len; ++i) {
@@ -12740,7 +14195,7 @@ You can use close({ resize: true }) to resize header`);
     const pbn = {};
     if (node.Data !== void 0) {
       if (typeof node.Data === "string") {
-        pbn.Data = textEncoder3.encode(node.Data);
+        pbn.Data = textEncoder4.encode(node.Data);
       } else if (node.Data instanceof Uint8Array) {
         pbn.Data = node.Data;
       } else {
@@ -12805,7 +14260,7 @@ You can use close({ resize: true }) to resize header`);
 
   // ../../node_modules/.pnpm/@ipld+dag-pb@4.0.8/node_modules/@ipld/dag-pb/src/index.js
   var code3 = 112;
-  function encode11(node) {
+  function encode12(node) {
     validate(node);
     const pbn = {};
     if (node.Links) {
@@ -12828,7 +14283,7 @@ You can use close({ resize: true }) to resize header`);
     }
     return encodeNode(pbn);
   }
-  function decode15(bytes) {
+  function decode16(bytes) {
     const pbn = decodeNode(bytes);
     const node = {};
     if (pbn.Data) {
@@ -12879,7 +14334,7 @@ You can use close({ resize: true }) to resize header`);
     Data3.prototype.fanout = $util.Long ? $util.Long.fromBits(0, 0, true) : 0;
     Data3.prototype.mode = 0;
     Data3.prototype.mtime = null;
-    Data3.encode = function encode19(m, w) {
+    Data3.encode = function encode20(m, w) {
       if (!w)
         w = $Writer.create();
       w.uint32(8).int32(m.Type);
@@ -12901,7 +14356,7 @@ You can use close({ resize: true }) to resize header`);
         $root.UnixTime.encode(m.mtime, w.uint32(66).fork()).ldelim();
       return w;
     };
-    Data3.decode = function decode23(r, l) {
+    Data3.decode = function decode24(r, l) {
       if (!(r instanceof $Reader))
         r = $Reader.create(r);
       var c = l === void 0 ? r.len : r.pos + l, m = new $root.Data();
@@ -13139,7 +14594,7 @@ You can use close({ resize: true }) to resize header`);
     }
     UnixTime3.prototype.Seconds = $util.Long ? $util.Long.fromBits(0, 0, false) : 0;
     UnixTime3.prototype.FractionalNanoseconds = 0;
-    UnixTime3.encode = function encode19(m, w) {
+    UnixTime3.encode = function encode20(m, w) {
       if (!w)
         w = $Writer.create();
       w.uint32(8).int64(m.Seconds);
@@ -13147,7 +14602,7 @@ You can use close({ resize: true }) to resize header`);
         w.uint32(21).fixed32(m.FractionalNanoseconds);
       return w;
     };
-    UnixTime3.decode = function decode23(r, l) {
+    UnixTime3.decode = function decode24(r, l) {
       if (!(r instanceof $Reader))
         r = $Reader.create(r);
       var c = l === void 0 ? r.len : r.pos + l, m = new $root.UnixTime();
@@ -13225,14 +14680,14 @@ You can use close({ resize: true }) to resize header`);
       }
     }
     Metadata3.prototype.MimeType = "";
-    Metadata3.encode = function encode19(m, w) {
+    Metadata3.encode = function encode20(m, w) {
       if (!w)
         w = $Writer.create();
       if (m.MimeType != null && Object.hasOwnProperty.call(m, "MimeType"))
         w.uint32(10).string(m.MimeType);
       return w;
     };
-    Metadata3.decode = function decode23(r, l) {
+    Metadata3.decode = function decode24(r, l) {
       if (!(r instanceof $Reader))
         r = $Reader.create(r);
       var c = l === void 0 ? r.len : r.pos + l, m = new $root.Metadata();
@@ -13289,7 +14744,7 @@ You can use close({ resize: true }) to resize header`);
   var name3 = "UnixFS";
   var encodePB = (data, links3) => {
     Object(globalThis).debug && console.log({ data, links: links3 });
-    return encode11(
+    return encode12(
       // We run through prepare as links need to be sorted by name which it will
       // do.
       prepare({
@@ -13483,7 +14938,7 @@ You can use close({ resize: true }) to resize header`);
       []
     );
   };
-  var encode12 = (node, root2 = true) => {
+  var encode13 = (node, root2 = true) => {
     switch (node.type) {
       case NodeType.Raw:
         return encodeRaw(node.content);
@@ -13499,8 +14954,8 @@ You can use close({ resize: true }) to resize header`);
         throw new Error(`Unknown node type ${Object(node).type}`);
     }
   };
-  var decode16 = (bytes) => {
-    const pb = decode15(bytes);
+  var decode17 = (bytes) => {
+    const pb = decode16(bytes);
     const message2 = Data.decode(
       /** @type {Uint8Array} */
       pb.Data
@@ -14312,19 +15767,19 @@ You can use close({ resize: true }) to resize header`);
 
   // ../../node_modules/.pnpm/@ipld+unixfs@2.1.2/node_modules/@ipld/unixfs/src/file/chunker/buffer.js
   var empty3 = () => new BufferView();
-  var slice2 = (buffer2, startOffset = 0, endOffset = buffer2.byteLength) => {
+  var slice3 = (buffer3, startOffset = 0, endOffset = buffer3.byteLength) => {
     const segments = [];
-    const start = startOffset < 0 ? buffer2.byteLength - startOffset : startOffset;
-    const end = endOffset < 0 ? buffer2.byteLength - endOffset : endOffset;
-    if (start === 0 && end >= buffer2.byteLength) {
-      return buffer2;
+    const start = startOffset < 0 ? buffer3.byteLength - startOffset : startOffset;
+    const end = endOffset < 0 ? buffer3.byteLength - endOffset : endOffset;
+    if (start === 0 && end >= buffer3.byteLength) {
+      return buffer3;
     }
-    if (start > end || start > buffer2.byteLength || end <= 0) {
+    if (start > end || start > buffer3.byteLength || end <= 0) {
       return empty3();
     }
     let byteLength = 0;
     let offset = 0;
-    for (const segment of buffer2.segments) {
+    for (const segment of buffer3.segments) {
       const nextOffset = offset + segment.byteLength;
       if (byteLength === 0) {
         if (end <= nextOffset) {
@@ -14348,24 +15803,24 @@ You can use close({ resize: true }) to resize header`);
       }
       offset = nextOffset;
     }
-    return new BufferView(segments, buffer2.byteOffset + start, byteLength);
+    return new BufferView(segments, buffer3.byteOffset + start, byteLength);
   };
-  var push = (buffer2, part) => {
+  var push = (buffer3, part) => {
     if (part.byteLength > 0) {
-      buffer2.segments.push(part);
+      buffer3.segments.push(part);
       return new BufferView(
-        buffer2.segments,
-        buffer2.byteOffset,
-        buffer2.byteLength + part.byteLength
+        buffer3.segments,
+        buffer3.byteOffset,
+        buffer3.byteLength + part.byteLength
       );
     } else {
-      return buffer2;
+      return buffer3;
     }
   };
-  var get4 = (buffer2, n) => {
-    if (n < buffer2.byteLength) {
+  var get4 = (buffer3, n) => {
+    if (n < buffer3.byteLength) {
       let offset = 0;
-      for (const segment of buffer2.segments) {
+      for (const segment of buffer3.segments) {
         if (n < offset + segment.byteLength) {
           return segment[n - offset];
         } else {
@@ -14375,16 +15830,16 @@ You can use close({ resize: true }) to resize header`);
     }
     return void 0;
   };
-  var copyTo = (buffer2, target, byteOffset) => {
+  var copyTo = (buffer3, target, byteOffset) => {
     let offset = byteOffset;
-    for (const segment of buffer2.segments) {
+    for (const segment of buffer3.segments) {
       target.set(segment, offset);
       offset += segment.byteLength;
     }
     return target;
   };
-  function* iterate(buffer2) {
-    for (const part of buffer2.segments) {
+  function* iterate(buffer3) {
+    for (const part of buffer3.segments) {
       yield* part;
     }
   }
@@ -14411,7 +15866,7 @@ You can use close({ resize: true }) to resize header`);
     slice(start, end) {
       return (
         /** @type {BufferView} */
-        slice2(this, start, end)
+        slice3(this, start, end)
       );
     }
     /**
@@ -14421,7 +15876,7 @@ You can use close({ resize: true }) to resize header`);
     subarray(start, end) {
       return (
         /** @type {BufferView} */
-        slice2(this, start, end)
+        slice3(this, start, end)
       );
     }
     /**
@@ -14465,18 +15920,18 @@ You can use close({ resize: true }) to resize header`);
   });
   var write = (state, bytes) => bytes.byteLength > 0 ? split(state.config, state.buffer.push(bytes), false) : { ...state, chunks: EMPTY2 };
   var close2 = (state) => split(state.config, state.buffer, true);
-  var split = (config2, buffer2, end) => {
+  var split = (config2, buffer3, end) => {
     const chunker3 = config2.chunker;
     const chunks = [];
     let offset = 0;
-    for (const size of chunker3.cut(chunker3.context, buffer2, end)) {
+    for (const size of chunker3.cut(chunker3.context, buffer3, end)) {
       if (size > 0) {
-        const chunk = buffer2.subarray(offset, offset + size);
+        const chunk = buffer3.subarray(offset, offset + size);
         chunks.push(chunk);
         offset += size;
       }
     }
-    return { config: config2, chunks, buffer: buffer2.subarray(offset) };
+    return { config: config2, chunks, buffer: buffer3.subarray(offset) };
   };
 
   // ../../node_modules/.pnpm/@ipld+unixfs@2.1.2/node_modules/@ipld/unixfs/src/file/layout/queue.js
@@ -14789,7 +16244,7 @@ You can use close({ resize: true }) to resize header`);
     }
     writer.write(block);
   };
-  var asUint8Array = (buffer2) => buffer2 instanceof Uint8Array ? buffer2 : buffer2.copyTo(new Uint8Array(buffer2.byteLength), 0);
+  var asUint8Array = (buffer3) => buffer3 instanceof Uint8Array ? buffer3 : buffer3.copyTo(new Uint8Array(buffer3.byteLength), 0);
   var isLeafNode = (node) => node.children == null;
 
   // ../../node_modules/.pnpm/@ipld+unixfs@2.1.2/node_modules/@ipld/unixfs/src/file/chunker/fixed.js
@@ -14849,12 +16304,12 @@ You can use close({ resize: true }) to resize header`);
   };
 
   // ../../node_modules/.pnpm/multiformats@11.0.2/node_modules/multiformats/vendor/varint.js
-  var encode_13 = encode13;
+  var encode_13 = encode14;
   var MSB3 = 128;
   var REST3 = 127;
   var MSBALL3 = ~REST3;
   var INT3 = Math.pow(2, 31);
-  function encode13(num, out, offset) {
+  function encode14(num, out, offset) {
     out = out || [];
     offset = offset || 0;
     var oldOffset = offset;
@@ -14867,20 +16322,20 @@ You can use close({ resize: true }) to resize header`);
       num >>>= 7;
     }
     out[offset] = num | 0;
-    encode13.bytes = offset - oldOffset + 1;
+    encode14.bytes = offset - oldOffset + 1;
     return out;
   }
-  var decode17 = read3;
+  var decode18 = read3;
   var MSB$13 = 128;
   var REST$13 = 127;
-  function read3(buf2, offset) {
-    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf2.length;
+  function read3(buf3, offset) {
+    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf3.length;
     do {
       if (counter >= l) {
         read3.bytes = 0;
         throw new RangeError("Could not decode varint");
       }
-      b = buf2[counter++];
+      b = buf3[counter++];
       res += shift < 28 ? (b & REST$13) << shift : (b & REST$13) * Math.pow(2, shift);
       shift += 7;
     } while (b >= MSB$13);
@@ -14901,14 +16356,14 @@ You can use close({ resize: true }) to resize header`);
   };
   var varint6 = {
     encode: encode_13,
-    decode: decode17,
+    decode: decode18,
     encodingLength: length3
   };
   var _brrp_varint3 = varint6;
   var varint_default3 = _brrp_varint3;
 
   // ../../node_modules/.pnpm/multiformats@11.0.2/node_modules/multiformats/src/varint.js
-  var decode18 = (data, offset = 0) => {
+  var decode19 = (data, offset = 0) => {
     const code8 = varint_default3.decode(data, offset);
     return [code8, varint_default3.decode.bytes];
   };
@@ -14931,10 +16386,10 @@ You can use close({ resize: true }) to resize header`);
     bytes.set(digest3, digestOffset);
     return new Digest3(code8, size, digest3, bytes);
   };
-  var decode19 = (multihash) => {
+  var decode20 = (multihash) => {
     const bytes = coerce3(multihash);
-    const [code8, sizeOffset] = decode18(bytes);
-    const [size, digestOffset] = decode18(bytes.subarray(sizeOffset));
+    const [code8, sizeOffset] = decode19(bytes);
+    const [size, digestOffset] = decode19(bytes.subarray(sizeOffset));
     const digest3 = bytes.subarray(sizeOffset + digestOffset);
     if (digest3.byteLength !== size) {
       throw new Error("Incorrect length");
@@ -14970,7 +16425,7 @@ You can use close({ resize: true }) to resize header`);
   };
 
   // ../../node_modules/.pnpm/multiformats@11.0.2/node_modules/multiformats/src/hashes/hasher.js
-  var from5 = ({ name: name7, code: code8, encode: encode19 }) => new Hasher3(name7, code8, encode19);
+  var from5 = ({ name: name7, code: code8, encode: encode20 }) => new Hasher3(name7, code8, encode20);
   var Hasher3 = class {
     /**
      *
@@ -14978,10 +16433,10 @@ You can use close({ resize: true }) to resize header`);
      * @param {Code} code
      * @param {(input: Uint8Array) => Await<Uint8Array>} encode
      */
-    constructor(name7, code8, encode19) {
+    constructor(name7, code8, encode20) {
       this.name = name7;
       this.code = code8;
-      this.encode = encode19;
+      this.encode = encode20;
     }
     /**
      * @param {Uint8Array} input
@@ -15036,7 +16491,7 @@ You can use close({ resize: true }) to resize header`);
     var LEADER = ALPHABET.charAt(0);
     var FACTOR = Math.log(BASE) / Math.log(256);
     var iFACTOR = Math.log(256) / Math.log(BASE);
-    function encode19(source) {
+    function encode20(source) {
       if (source instanceof Uint8Array)
         ;
       else if (ArrayBuffer.isView(source)) {
@@ -15134,17 +16589,17 @@ You can use close({ resize: true }) to resize header`);
       }
       return vch;
     }
-    function decode23(string3) {
-      var buffer2 = decodeUnsafe(string3);
-      if (buffer2) {
-        return buffer2;
+    function decode24(string3) {
+      var buffer3 = decodeUnsafe(string3);
+      if (buffer3) {
+        return buffer3;
       }
       throw new Error(`Non-${name7} character`);
     }
     return {
-      encode: encode19,
+      encode: encode20,
       decodeUnsafe,
-      decode: decode23
+      decode: decode24
     };
   }
   var src3 = base3;
@@ -15286,20 +16741,20 @@ You can use close({ resize: true }) to resize header`);
       return this.decoder.decode(input);
     }
   };
-  var from6 = ({ name: name7, prefix, encode: encode19, decode: decode23 }) => new Codec3(name7, prefix, encode19, decode23);
+  var from6 = ({ name: name7, prefix, encode: encode20, decode: decode24 }) => new Codec3(name7, prefix, encode20, decode24);
   var baseX3 = ({ prefix, name: name7, alphabet: alphabet3 }) => {
-    const { encode: encode19, decode: decode23 } = base_x_default3(alphabet3, name7);
+    const { encode: encode20, decode: decode24 } = base_x_default3(alphabet3, name7);
     return from6({
       prefix,
       name: name7,
-      encode: encode19,
+      encode: encode20,
       /**
        * @param {string} text
        */
-      decode: (text) => coerce3(decode23(text))
+      decode: (text) => coerce3(decode24(text))
     });
   };
-  var decode20 = (string3, alphabet3, bitsPerChar, name7) => {
+  var decode21 = (string3, alphabet3, bitsPerChar, name7) => {
     const codes = {};
     for (let i = 0; i < alphabet3.length; ++i) {
       codes[alphabet3[i]] = i;
@@ -15310,41 +16765,41 @@ You can use close({ resize: true }) to resize header`);
     }
     const out = new Uint8Array(end * bitsPerChar / 8 | 0);
     let bits = 0;
-    let buffer2 = 0;
+    let buffer3 = 0;
     let written = 0;
     for (let i = 0; i < end; ++i) {
       const value = codes[string3[i]];
       if (value === void 0) {
         throw new SyntaxError(`Non-${name7} character`);
       }
-      buffer2 = buffer2 << bitsPerChar | value;
+      buffer3 = buffer3 << bitsPerChar | value;
       bits += bitsPerChar;
       if (bits >= 8) {
         bits -= 8;
-        out[written++] = 255 & buffer2 >> bits;
+        out[written++] = 255 & buffer3 >> bits;
       }
     }
-    if (bits >= bitsPerChar || 255 & buffer2 << 8 - bits) {
+    if (bits >= bitsPerChar || 255 & buffer3 << 8 - bits) {
       throw new SyntaxError("Unexpected end of data");
     }
     return out;
   };
-  var encode14 = (data, alphabet3, bitsPerChar) => {
+  var encode15 = (data, alphabet3, bitsPerChar) => {
     const pad = alphabet3[alphabet3.length - 1] === "=";
     const mask = (1 << bitsPerChar) - 1;
     let out = "";
     let bits = 0;
-    let buffer2 = 0;
+    let buffer3 = 0;
     for (let i = 0; i < data.length; ++i) {
-      buffer2 = buffer2 << 8 | data[i];
+      buffer3 = buffer3 << 8 | data[i];
       bits += 8;
       while (bits > bitsPerChar) {
         bits -= bitsPerChar;
-        out += alphabet3[mask & buffer2 >> bits];
+        out += alphabet3[mask & buffer3 >> bits];
       }
     }
     if (bits) {
-      out += alphabet3[mask & buffer2 << bitsPerChar - bits];
+      out += alphabet3[mask & buffer3 << bitsPerChar - bits];
     }
     if (pad) {
       while (out.length * bitsPerChar & 7) {
@@ -15358,10 +16813,10 @@ You can use close({ resize: true }) to resize header`);
       prefix,
       name: name7,
       encode(input) {
-        return encode14(input, alphabet3, bitsPerChar);
+        return encode15(input, alphabet3, bitsPerChar);
       },
       decode(input) {
-        return decode20(input, alphabet3, bitsPerChar, name7);
+        return decode21(input, alphabet3, bitsPerChar, name7);
       }
     });
   };
@@ -15640,7 +17095,7 @@ You can use close({ resize: true }) to resize header`);
         const { version, multihash, code: code8 } = value;
         const digest3 = (
           /** @type {API.MultihashDigest<Alg>} */
-          decode19(multihash)
+          decode20(multihash)
         );
         return _CID.create(version, code8, digest3);
       } else {
@@ -15791,7 +17246,7 @@ You can use close({ resize: true }) to resize header`);
     static inspectBytes(initialBytes) {
       let offset = 0;
       const next = () => {
-        const [i, length5] = decode18(initialBytes.subarray(offset));
+        const [i, length5] = decode19(initialBytes.subarray(offset));
         offset += length5;
         return i;
       };
@@ -16474,11 +17929,11 @@ You can use close({ resize: true }) to resize header`);
   });
   var code6 = 0;
   var name5 = "identity";
-  var encode15 = coerce2;
+  var encode16 = coerce2;
   function digest(input) {
-    return create2(code6, encode15(input));
+    return create2(code6, encode16(input));
   }
-  var identity = { code: code6, name: name5, encode: encode15, digest };
+  var identity = { code: code6, name: name5, encode: encode16, digest };
 
   // ../../node_modules/.pnpm/ipfs-unixfs-exporter@13.2.5/node_modules/ipfs-unixfs-exporter/dist/src/resolvers/dag-cbor.js
   var import_err_code = __toESM(require_err_code(), 1);
@@ -16600,13 +18055,13 @@ You can use close({ resize: true }) to resize header`);
   var rawContent = (node) => {
     async function* contentGenerator(options = {}) {
       const { start, end } = validate_offset_and_length_default(node.length, options.offset, options.length);
-      const buf2 = extract_data_from_block_default(node, 0n, start, end);
+      const buf3 = extract_data_from_block_default(node, 0n, start, end);
       options.onProgress?.(new CustomProgressEvent("unixfs:exporter:progress:identity", {
-        bytesRead: BigInt(buf2.byteLength),
+        bytesRead: BigInt(buf3.byteLength),
         totalBytes: end - start,
         fileSize: BigInt(node.byteLength)
       }));
-      yield buf2;
+      yield buf3;
     }
     return contentGenerator;
   };
@@ -16614,17 +18069,17 @@ You can use close({ resize: true }) to resize header`);
     if (toResolve.length > 0) {
       throw (0, import_err_code3.default)(new Error(`No link named ${path} found in raw node ${cid}`), "ERR_NOT_FOUND");
     }
-    const buf2 = decode9(cid.multihash.bytes);
+    const buf3 = decode9(cid.multihash.bytes);
     return {
       entry: {
         type: "identity",
         name: name7,
         path,
         cid,
-        content: rawContent(buf2.digest),
+        content: rawContent(buf3.digest),
         depth,
-        size: BigInt(buf2.digest.length),
-        node: buf2.digest
+        size: BigInt(buf3.digest.length),
+        node: buf3.digest
       }
     };
   };
@@ -16635,13 +18090,13 @@ You can use close({ resize: true }) to resize header`);
   var rawContent2 = (node) => {
     async function* contentGenerator(options = {}) {
       const { start, end } = validate_offset_and_length_default(node.length, options.offset, options.length);
-      const buf2 = extract_data_from_block_default(node, 0n, start, end);
+      const buf3 = extract_data_from_block_default(node, 0n, start, end);
       options.onProgress?.(new CustomProgressEvent("unixfs:exporter:progress:raw", {
-        bytesRead: BigInt(buf2.byteLength),
+        bytesRead: BigInt(buf3.byteLength),
         totalBytes: end - start,
         fileSize: BigInt(node.byteLength)
       }));
-      yield buf2;
+      yield buf3;
     }
     return contentGenerator;
   };
@@ -16674,42 +18129,42 @@ You can use close({ resize: true }) to resize header`);
   // ../../node_modules/.pnpm/protons-runtime@5.2.2/node_modules/protons-runtime/dist/src/utils/float.js
   var f32 = new Float32Array([-0]);
   var f8b = new Uint8Array(f32.buffer);
-  function writeFloatLE(val, buf2, pos) {
+  function writeFloatLE(val, buf3, pos) {
     f32[0] = val;
-    buf2[pos] = f8b[0];
-    buf2[pos + 1] = f8b[1];
-    buf2[pos + 2] = f8b[2];
-    buf2[pos + 3] = f8b[3];
-  }
-  function readFloatLE(buf2, pos) {
-    f8b[0] = buf2[pos];
-    f8b[1] = buf2[pos + 1];
-    f8b[2] = buf2[pos + 2];
-    f8b[3] = buf2[pos + 3];
+    buf3[pos] = f8b[0];
+    buf3[pos + 1] = f8b[1];
+    buf3[pos + 2] = f8b[2];
+    buf3[pos + 3] = f8b[3];
+  }
+  function readFloatLE(buf3, pos) {
+    f8b[0] = buf3[pos];
+    f8b[1] = buf3[pos + 1];
+    f8b[2] = buf3[pos + 2];
+    f8b[3] = buf3[pos + 3];
     return f32[0];
   }
   var f64 = new Float64Array([-0]);
   var d8b = new Uint8Array(f64.buffer);
-  function writeDoubleLE(val, buf2, pos) {
+  function writeDoubleLE(val, buf3, pos) {
     f64[0] = val;
-    buf2[pos] = d8b[0];
-    buf2[pos + 1] = d8b[1];
-    buf2[pos + 2] = d8b[2];
-    buf2[pos + 3] = d8b[3];
-    buf2[pos + 4] = d8b[4];
-    buf2[pos + 5] = d8b[5];
-    buf2[pos + 6] = d8b[6];
-    buf2[pos + 7] = d8b[7];
-  }
-  function readDoubleLE(buf2, pos) {
-    d8b[0] = buf2[pos];
-    d8b[1] = buf2[pos + 1];
-    d8b[2] = buf2[pos + 2];
-    d8b[3] = buf2[pos + 3];
-    d8b[4] = buf2[pos + 4];
-    d8b[5] = buf2[pos + 5];
-    d8b[6] = buf2[pos + 6];
-    d8b[7] = buf2[pos + 7];
+    buf3[pos] = d8b[0];
+    buf3[pos + 1] = d8b[1];
+    buf3[pos + 2] = d8b[2];
+    buf3[pos + 3] = d8b[3];
+    buf3[pos + 4] = d8b[4];
+    buf3[pos + 5] = d8b[5];
+    buf3[pos + 6] = d8b[6];
+    buf3[pos + 7] = d8b[7];
+  }
+  function readDoubleLE(buf3, pos) {
+    d8b[0] = buf3[pos];
+    d8b[1] = buf3[pos + 1];
+    d8b[2] = buf3[pos + 2];
+    d8b[3] = buf3[pos + 3];
+    d8b[4] = buf3[pos + 4];
+    d8b[5] = buf3[pos + 5];
+    d8b[6] = buf3[pos + 6];
+    d8b[7] = buf3[pos + 7];
     return f64[0];
   }
 
@@ -16887,7 +18342,7 @@ You can use close({ resize: true }) to resize header`);
     }
     return len;
   }
-  function read5(buffer2, start, end) {
+  function read5(buffer3, start, end) {
     const len = end - start;
     if (len < 1) {
       return "";
@@ -16897,17 +18352,17 @@ You can use close({ resize: true }) to resize header`);
     let i = 0;
     let t;
     while (start < end) {
-      t = buffer2[start++];
+      t = buffer3[start++];
       if (t < 128) {
         chunk[i++] = t;
       } else if (t > 191 && t < 224) {
-        chunk[i++] = (t & 31) << 6 | buffer2[start++] & 63;
+        chunk[i++] = (t & 31) << 6 | buffer3[start++] & 63;
       } else if (t > 239 && t < 365) {
-        t = ((t & 7) << 18 | (buffer2[start++] & 63) << 12 | (buffer2[start++] & 63) << 6 | buffer2[start++] & 63) - 65536;
+        t = ((t & 7) << 18 | (buffer3[start++] & 63) << 12 | (buffer3[start++] & 63) << 6 | buffer3[start++] & 63) - 65536;
         chunk[i++] = 55296 + (t >> 10);
         chunk[i++] = 56320 + (t & 1023);
       } else {
-        chunk[i++] = (t & 15) << 12 | (buffer2[start++] & 63) << 6 | buffer2[start++] & 63;
+        chunk[i++] = (t & 15) << 12 | (buffer3[start++] & 63) << 6 | buffer3[start++] & 63;
       }
       if (i > 8191) {
         (parts ?? (parts = [])).push(String.fromCharCode.apply(String, chunk));
@@ -16922,28 +18377,28 @@ You can use close({ resize: true }) to resize header`);
     }
     return String.fromCharCode.apply(String, chunk.slice(0, i));
   }
-  function write5(string3, buffer2, offset) {
+  function write5(string3, buffer3, offset) {
     const start = offset;
     let c1;
     let c2;
     for (let i = 0; i < string3.length; ++i) {
       c1 = string3.charCodeAt(i);
       if (c1 < 128) {
-        buffer2[offset++] = c1;
+        buffer3[offset++] = c1;
       } else if (c1 < 2048) {
-        buffer2[offset++] = c1 >> 6 | 192;
-        buffer2[offset++] = c1 & 63 | 128;
+        buffer3[offset++] = c1 >> 6 | 192;
+        buffer3[offset++] = c1 & 63 | 128;
       } else if ((c1 & 64512) === 55296 && ((c2 = string3.charCodeAt(i + 1)) & 64512) === 56320) {
         c1 = 65536 + ((c1 & 1023) << 10) + (c2 & 1023);
         ++i;
-        buffer2[offset++] = c1 >> 18 | 240;
-        buffer2[offset++] = c1 >> 12 & 63 | 128;
-        buffer2[offset++] = c1 >> 6 & 63 | 128;
-        buffer2[offset++] = c1 & 63 | 128;
+        buffer3[offset++] = c1 >> 18 | 240;
+        buffer3[offset++] = c1 >> 12 & 63 | 128;
+        buffer3[offset++] = c1 >> 6 & 63 | 128;
+        buffer3[offset++] = c1 & 63 | 128;
       } else {
-        buffer2[offset++] = c1 >> 12 | 224;
-        buffer2[offset++] = c1 >> 6 & 63 | 128;
-        buffer2[offset++] = c1 & 63 | 128;
+        buffer3[offset++] = c1 >> 12 | 224;
+        buffer3[offset++] = c1 >> 6 & 63 | 128;
+        buffer3[offset++] = c1 & 63 | 128;
       }
     }
     return offset - start;
@@ -16953,18 +18408,18 @@ You can use close({ resize: true }) to resize header`);
   function indexOutOfRange(reader, writeLength) {
     return RangeError(`index out of range: ${reader.pos} + ${writeLength ?? 1} > ${reader.len}`);
   }
-  function readFixed32End(buf2, end) {
-    return (buf2[end - 4] | buf2[end - 3] << 8 | buf2[end - 2] << 16 | buf2[end - 1] << 24) >>> 0;
+  function readFixed32End(buf3, end) {
+    return (buf3[end - 4] | buf3[end - 3] << 8 | buf3[end - 2] << 16 | buf3[end - 1] << 24) >>> 0;
   }
   var Uint8ArrayReader = class {
     buf;
     pos;
     len;
     _slice = Uint8Array.prototype.subarray;
-    constructor(buffer2) {
-      this.buf = buffer2;
+    constructor(buffer3) {
+      this.buf = buffer3;
       this.pos = 0;
-      this.len = buffer2.length;
+      this.len = buffer3.length;
     }
     /**
      * Reads a varint as an unsigned 32 bit value
@@ -17271,22 +18726,22 @@ You can use close({ resize: true }) to resize header`);
       return this.readFixed64().toString();
     }
   };
-  function createReader(buf2) {
-    return new Uint8ArrayReader(buf2 instanceof Uint8Array ? buf2 : buf2.subarray());
+  function createReader(buf3) {
+    return new Uint8ArrayReader(buf3 instanceof Uint8Array ? buf3 : buf3.subarray());
   }
 
   // ../../node_modules/.pnpm/protons-runtime@5.2.2/node_modules/protons-runtime/dist/src/decode.js
-  function decodeMessage(buf2, codec) {
-    const reader = createReader(buf2);
+  function decodeMessage(buf3, codec) {
+    const reader = createReader(buf3);
     return codec.decode(reader);
   }
 
   // ../../node_modules/.pnpm/uint8arrays@5.0.1/node_modules/uint8arrays/dist/src/util/as-uint8array.js
-  function asUint8Array2(buf2) {
+  function asUint8Array2(buf3) {
     if (globalThis.Buffer != null) {
-      return new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength);
+      return new Uint8Array(buf3.buffer, buf3.byteOffset, buf3.byteLength);
     }
-    return buf2;
+    return buf3;
   }
 
   // ../../node_modules/.pnpm/uint8arrays@5.0.1/node_modules/uint8arrays/dist/src/alloc.js
@@ -17353,13 +18808,13 @@ You can use close({ resize: true }) to resize header`);
     p[c.codePointAt(0)] = i;
     return p;
   }, []);
-  function encode16(data) {
+  function encode17(data) {
     return data.reduce((p, c) => {
       p += alphabetBytesToChars[c];
       return p;
     }, "");
   }
-  function decode21(str) {
+  function decode22(str) {
     const byts = [];
     for (const char of str) {
       const byt = alphabetCharsToBytes[char.codePointAt(0)];
@@ -17373,8 +18828,8 @@ You can use close({ resize: true }) to resize header`);
   var base256emoji = from2({
     prefix: "\u{1F680}",
     name: "base256emoji",
-    encode: encode16,
-    decode: decode21
+    encode: encode17,
+    decode: decode22
   });
 
   // ../../node_modules/.pnpm/multiformats@13.0.1/node_modules/multiformats/dist/src/bases/base36.js
@@ -17414,13 +18869,13 @@ You can use close({ resize: true }) to resize header`);
   var identity2 = from2({
     prefix: "\0",
     name: "identity",
-    encode: (buf2) => toString3(buf2),
+    encode: (buf3) => toString3(buf3),
     decode: (str) => fromString3(str)
   });
 
   // ../../node_modules/.pnpm/multiformats@13.0.1/node_modules/multiformats/dist/src/codecs/json.js
-  var textEncoder4 = new TextEncoder();
-  var textDecoder3 = new TextDecoder();
+  var textEncoder5 = new TextEncoder();
+  var textDecoder4 = new TextDecoder();
 
   // ../../node_modules/.pnpm/multiformats@13.0.1/node_modules/multiformats/dist/src/hashes/sha2-browser.js
   var sha2_browser_exports2 = {};
@@ -17447,40 +18902,40 @@ You can use close({ resize: true }) to resize header`);
   var hashes = { ...sha2_browser_exports2, ...identity_exports };
 
   // ../../node_modules/.pnpm/uint8arrays@5.0.1/node_modules/uint8arrays/dist/src/util/bases.js
-  function createCodec(name7, prefix, encode19, decode23) {
+  function createCodec(name7, prefix, encode20, decode24) {
     return {
       name: name7,
       prefix,
       encoder: {
         name: name7,
         prefix,
-        encode: encode19
+        encode: encode20
       },
       decoder: {
-        decode: decode23
+        decode: decode24
       }
     };
   }
-  var string = createCodec("utf8", "u", (buf2) => {
+  var string = createCodec("utf8", "u", (buf3) => {
     const decoder = new TextDecoder("utf8");
-    return "u" + decoder.decode(buf2);
+    return "u" + decoder.decode(buf3);
   }, (str) => {
     const encoder = new TextEncoder();
     return encoder.encode(str.substring(1));
   });
-  var ascii = createCodec("ascii", "a", (buf2) => {
+  var ascii = createCodec("ascii", "a", (buf3) => {
     let string3 = "a";
-    for (let i = 0; i < buf2.length; i++) {
-      string3 += String.fromCharCode(buf2[i]);
+    for (let i = 0; i < buf3.length; i++) {
+      string3 += String.fromCharCode(buf3[i]);
     }
     return string3;
   }, (str) => {
     str = str.substring(1);
-    const buf2 = allocUnsafe(str.length);
+    const buf3 = allocUnsafe(str.length);
     for (let i = 0; i < str.length; i++) {
-      buf2[i] = str.charCodeAt(i);
+      buf3[i] = str.charCodeAt(i);
     }
-    return buf2;
+    return buf3;
   });
   var BASES = {
     utf8: string,
@@ -17494,7 +18949,7 @@ You can use close({ resize: true }) to resize header`);
   var bases_default = BASES;
 
   // ../../node_modules/.pnpm/uint8arrays@5.0.1/node_modules/uint8arrays/dist/src/from-string.js
-  function fromString4(string3, encoding = "utf8") {
+  function fromString5(string3, encoding = "utf8") {
     const base4 = bases_default[encoding];
     if (base4 == null) {
       throw new Error(`Unsupported encoding "${encoding}"`);
@@ -17519,11 +18974,11 @@ You can use close({ resize: true }) to resize header`);
         slab = allocUnsafe(SIZE);
         offset = 0;
       }
-      const buf2 = slab.subarray(offset, offset += size2);
+      const buf3 = slab.subarray(offset, offset += size2);
       if ((offset & 7) !== 0) {
         offset = (offset | 7) + 1;
       }
-      return buf2;
+      return buf3;
     };
   }
 
@@ -17579,7 +19034,7 @@ You can use close({ resize: true }) to resize header`);
     }
   };
   var bufferPool = pool();
-  function alloc2(size) {
+  function alloc3(size) {
     if (globalThis.Buffer != null) {
       return allocUnsafe(size);
     }
@@ -17827,25 +19282,25 @@ You can use close({ resize: true }) to resize header`);
      */
     finish() {
       let head = this.head.next;
-      const buf2 = alloc2(this.len);
+      const buf3 = alloc3(this.len);
       let pos = 0;
       while (head != null) {
-        head.fn(head.val, buf2, pos);
+        head.fn(head.val, buf3, pos);
         pos += head.len;
         head = head.next;
       }
-      return buf2;
+      return buf3;
     }
   };
-  function writeByte(val, buf2, pos) {
-    buf2[pos] = val & 255;
+  function writeByte(val, buf3, pos) {
+    buf3[pos] = val & 255;
   }
-  function writeVarint32(val, buf2, pos) {
+  function writeVarint32(val, buf3, pos) {
     while (val > 127) {
-      buf2[pos++] = val & 127 | 128;
+      buf3[pos++] = val & 127 | 128;
       val >>>= 7;
     }
-    buf2[pos] = val;
+    buf3[pos] = val;
   }
   var VarintOp = class extends Op {
     next;
@@ -17854,26 +19309,26 @@ You can use close({ resize: true }) to resize header`);
       this.next = void 0;
     }
   };
-  function writeVarint64(val, buf2, pos) {
+  function writeVarint64(val, buf3, pos) {
     while (val.hi !== 0) {
-      buf2[pos++] = val.lo & 127 | 128;
+      buf3[pos++] = val.lo & 127 | 128;
       val.lo = (val.lo >>> 7 | val.hi << 25) >>> 0;
       val.hi >>>= 7;
     }
     while (val.lo > 127) {
-      buf2[pos++] = val.lo & 127 | 128;
+      buf3[pos++] = val.lo & 127 | 128;
       val.lo = val.lo >>> 7;
     }
-    buf2[pos++] = val.lo;
+    buf3[pos++] = val.lo;
   }
-  function writeFixed32(val, buf2, pos) {
-    buf2[pos] = val & 255;
-    buf2[pos + 1] = val >>> 8 & 255;
-    buf2[pos + 2] = val >>> 16 & 255;
-    buf2[pos + 3] = val >>> 24;
+  function writeFixed32(val, buf3, pos) {
+    buf3[pos] = val & 255;
+    buf3[pos + 1] = val >>> 8 & 255;
+    buf3[pos + 2] = val >>> 16 & 255;
+    buf3[pos + 3] = val >>> 24;
   }
-  function writeBytes2(val, buf2, pos) {
-    buf2.set(val, pos);
+  function writeBytes2(val, buf3, pos) {
+    buf3.set(val, pos);
   }
   if (globalThis.Buffer != null) {
     Uint8ArrayWriter.prototype.bytes = function(value) {
@@ -17893,16 +19348,16 @@ You can use close({ resize: true }) to resize header`);
       return this;
     };
   }
-  function writeBytesBuffer(val, buf2, pos) {
-    buf2.set(val, pos);
+  function writeBytesBuffer(val, buf3, pos) {
+    buf3.set(val, pos);
   }
-  function writeStringBuffer(val, buf2, pos) {
+  function writeStringBuffer(val, buf3, pos) {
     if (val.length < 40) {
-      write5(val, buf2, pos);
-    } else if (buf2.utf8Write != null) {
-      buf2.utf8Write(val, pos);
+      write5(val, buf3, pos);
+    } else if (buf3.utf8Write != null) {
+      buf3.utf8Write(val, pos);
     } else {
-      buf2.set(fromString4(val), pos);
+      buf3.set(fromString5(val), pos);
     }
   }
   function createWriter3() {
@@ -17928,12 +19383,12 @@ You can use close({ resize: true }) to resize header`);
     CODEC_TYPES2[CODEC_TYPES2["END_GROUP"] = 4] = "END_GROUP";
     CODEC_TYPES2[CODEC_TYPES2["BIT32"] = 5] = "BIT32";
   })(CODEC_TYPES || (CODEC_TYPES = {}));
-  function createCodec2(name7, type2, encode19, decode23) {
+  function createCodec2(name7, type2, encode20, decode24) {
     return {
       name: name7,
       type: type2,
-      encode: encode19,
-      decode: decode23
+      encode: encode20,
+      decode: decode24
     };
   }
 
@@ -17945,20 +19400,20 @@ You can use close({ resize: true }) to resize header`);
       }
       return v[val];
     }
-    const encode19 = function enumEncode(val, writer) {
+    const encode20 = function enumEncode(val, writer) {
       const enumValue = findValue(val);
       writer.int32(enumValue);
     };
-    const decode23 = function enumDecode(reader) {
+    const decode24 = function enumDecode(reader) {
       const val = reader.int32();
       return findValue(val);
     };
-    return createCodec2("enum", CODEC_TYPES.VARINT, encode19, decode23);
+    return createCodec2("enum", CODEC_TYPES.VARINT, encode20, decode24);
   }
 
   // ../../node_modules/.pnpm/protons-runtime@5.2.2/node_modules/protons-runtime/dist/src/codecs/message.js
-  function message(encode19, decode23) {
-    return createCodec2("message", CODEC_TYPES.LENGTH_DELIMITED, encode19, decode23);
+  function message(encode20, decode24) {
+    return createCodec2("message", CODEC_TYPES.LENGTH_DELIMITED, encode20, decode24);
   }
 
   // ../../node_modules/.pnpm/ipfs-unixfs@11.1.2/node_modules/ipfs-unixfs/dist/src/unixfs.js
@@ -18076,8 +19531,8 @@ You can use close({ resize: true }) to resize header`);
     Data3.encode = (obj) => {
       return encodeMessage(obj, Data3.codec());
     };
-    Data3.decode = (buf2) => {
-      return decodeMessage(buf2, Data3.codec());
+    Data3.decode = (buf3) => {
+      return decodeMessage(buf3, Data3.codec());
     };
   })(Data2 || (Data2 = {}));
   var UnixTime2;
@@ -18125,8 +19580,8 @@ You can use close({ resize: true }) to resize header`);
     UnixTime3.encode = (obj) => {
       return encodeMessage(obj, UnixTime3.codec());
     };
-    UnixTime3.decode = (buf2) => {
-      return decodeMessage(buf2, UnixTime3.codec());
+    UnixTime3.decode = (buf3) => {
+      return decodeMessage(buf3, UnixTime3.codec());
     };
   })(UnixTime2 || (UnixTime2 = {}));
   var Metadata2;
@@ -18167,8 +19622,8 @@ You can use close({ resize: true }) to resize header`);
     Metadata3.encode = (obj) => {
       return encodeMessage(obj, Metadata3.codec());
     };
-    Metadata3.decode = (buf2) => {
-      return decodeMessage(buf2, Metadata3.codec());
+    Metadata3.decode = (buf3) => {
+      return decodeMessage(buf3, Metadata3.codec());
     };
   })(Metadata2 || (Metadata2 = {}));
 
@@ -18334,11 +19789,11 @@ You can use close({ resize: true }) to resize header`);
   var import_sparse_array = __toESM(require_sparse_array(), 1);
 
   // ../../node_modules/.pnpm/uint8arrays@4.0.10/node_modules/uint8arrays/dist/src/util/as-uint8array.js
-  function asUint8Array3(buf2) {
+  function asUint8Array3(buf3) {
     if (globalThis.Buffer != null) {
-      return new Uint8Array(buf2.buffer, buf2.byteOffset, buf2.byteLength);
+      return new Uint8Array(buf3.buffer, buf3.byteOffset, buf3.byteLength);
     }
-    return buf2;
+    return buf3;
   }
 
   // ../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base10.js
@@ -18414,13 +19869,13 @@ You can use close({ resize: true }) to resize header`);
       []
     )
   );
-  function encode17(data) {
+  function encode18(data) {
     return data.reduce((p, c) => {
       p += alphabetBytesToChars2[c];
       return p;
     }, "");
   }
-  function decode22(str) {
+  function decode23(str) {
     const byts = [];
     for (const char of str) {
       const byt = alphabetCharsToBytes2[
@@ -18437,8 +19892,8 @@ You can use close({ resize: true }) to resize header`);
   var base256emoji2 = from({
     prefix: "\u{1F680}",
     name: "base256emoji",
-    encode: encode17,
-    decode: decode22
+    encode: encode18,
+    decode: decode23
   });
 
   // ../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/bases/base36.js
@@ -18511,13 +19966,13 @@ You can use close({ resize: true }) to resize header`);
   var identity3 = from({
     prefix: "\0",
     name: "identity",
-    encode: (buf2) => toString(buf2),
+    encode: (buf3) => toString(buf3),
     decode: (str) => fromString(str)
   });
 
   // ../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/codecs/json.js
-  var textEncoder5 = new TextEncoder();
-  var textDecoder4 = new TextDecoder();
+  var textEncoder6 = new TextEncoder();
+  var textDecoder5 = new TextDecoder();
 
   // ../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/hashes/identity.js
   var identity_exports4 = {};
@@ -18526,9 +19981,9 @@ You can use close({ resize: true }) to resize header`);
   });
   var code7 = 0;
   var name6 = "identity";
-  var encode18 = coerce;
-  var digest2 = (input) => create(code7, encode18(input));
-  var identity4 = { code: code7, name: name6, encode: encode18, digest: digest2 };
+  var encode19 = coerce;
+  var digest2 = (input) => create(code7, encode19(input));
+  var identity4 = { code: code7, name: name6, encode: encode19, digest: digest2 };
 
   // ../../node_modules/.pnpm/multiformats@12.1.3/node_modules/multiformats/src/basics.js
   var bases2 = { ...identity_exports3, ...base2_exports2, ...base8_exports2, ...base10_exports2, ...base16_exports2, ...base32_exports, ...base36_exports2, ...base58_exports, ...base64_exports2, ...base256emoji_exports2 };
@@ -18543,40 +19998,40 @@ You can use close({ resize: true }) to resize header`);
   }
 
   // ../../node_modules/.pnpm/uint8arrays@4.0.10/node_modules/uint8arrays/dist/src/util/bases.js
-  function createCodec3(name7, prefix, encode19, decode23) {
+  function createCodec3(name7, prefix, encode20, decode24) {
     return {
       name: name7,
       prefix,
       encoder: {
         name: name7,
         prefix,
-        encode: encode19
+        encode: encode20
       },
       decoder: {
-        decode: decode23
+        decode: decode24
       }
     };
   }
-  var string2 = createCodec3("utf8", "u", (buf2) => {
+  var string2 = createCodec3("utf8", "u", (buf3) => {
     const decoder = new TextDecoder("utf8");
-    return "u" + decoder.decode(buf2);
+    return "u" + decoder.decode(buf3);
   }, (str) => {
     const encoder = new TextEncoder();
     return encoder.encode(str.substring(1));
   });
-  var ascii2 = createCodec3("ascii", "a", (buf2) => {
+  var ascii2 = createCodec3("ascii", "a", (buf3) => {
     let string3 = "a";
-    for (let i = 0; i < buf2.length; i++) {
-      string3 += String.fromCharCode(buf2[i]);
+    for (let i = 0; i < buf3.length; i++) {
+      string3 += String.fromCharCode(buf3[i]);
     }
     return string3;
   }, (str) => {
     str = str.substring(1);
-    const buf2 = allocUnsafe2(str.length);
+    const buf3 = allocUnsafe2(str.length);
     for (let i = 0; i < str.length; i++) {
-      buf2[i] = str.charCodeAt(i);
+      buf3[i] = str.charCodeAt(i);
     }
-    return buf2;
+    return buf3;
   });
   var BASES2 = {
     utf8: string2,
@@ -18590,7 +20045,7 @@ You can use close({ resize: true }) to resize header`);
   var bases_default2 = BASES2;
 
   // ../../node_modules/.pnpm/uint8arrays@4.0.10/node_modules/uint8arrays/dist/src/from-string.js
-  function fromString5(string3, encoding = "utf8") {
+  function fromString6(string3, encoding = "utf8") {
     const base4 = bases_default2[encoding];
     if (base4 == null) {
       throw new Error(`Unsupported encoding "${encoding}"`);
@@ -18689,7 +20144,7 @@ You can use close({ resize: true }) to resize header`);
       }
     }
     async _findPlace(key) {
-      const hashValue = this._options.hash(typeof key === "string" ? fromString5(key) : key);
+      const hashValue = this._options.hash(typeof key === "string" ? fromString6(key) : key);
       const index2 = await hashValue.take(this._options.bits);
       const child = this._children.get(index2);
       if (child instanceof _Bucket) {
@@ -18855,7 +20310,7 @@ You can use close({ resize: true }) to resize header`);
   }
 
   // ../../node_modules/.pnpm/uint8arrays@4.0.10/node_modules/uint8arrays/dist/src/concat.js
-  function concat2(arrays, length5) {
+  function concat3(arrays, length5) {
     if (length5 == null) {
       length5 = arrays.reduce((acc, curr) => acc + curr.length, 0);
     }
@@ -18926,11 +20381,11 @@ You can use close({ resize: true }) to resize header`);
     }
     async _produceMoreBits() {
       this._depth++;
-      const value = this._depth > 0 ? concat2([this._value, Uint8Array.from([this._depth])]) : this._value;
+      const value = this._depth > 0 ? concat3([this._value, Uint8Array.from([this._depth])]) : this._value;
       const hashValue = await this._hashFn(value);
-      const buffer2 = new ConsumableBuffer(hashValue);
-      this._buffers.push(buffer2);
-      this._availableBits += buffer2.availableBits();
+      const buffer3 = new ConsumableBuffer(hashValue);
+      this._buffers.push(buffer3);
+      this._availableBits += buffer3.availableBits();
     }
   };
 
@@ -18947,8 +20402,8 @@ You can use close({ resize: true }) to resize header`);
   }
 
   // ../../node_modules/.pnpm/ipfs-unixfs-exporter@13.2.5/node_modules/ipfs-unixfs-exporter/dist/src/utils/find-cid-in-shard.js
-  var hashFn = async function(buf2) {
-    return (await murmur3128.encode(buf2)).slice(0, 8).reverse();
+  var hashFn = async function(buf3) {
+    return (await murmur3128.encode(buf3)).slice(0, 8).reverse();
   };
   var addLinksToHamtBucket = async (links3, bucket, rootBucket) => {
     const padLength = (bucket.tableSize() - 1).toString(16).length;
@@ -19038,7 +20493,7 @@ You can use close({ resize: true }) to resize header`);
     }
     context2.hamtDepth++;
     const block = await blockstore.get(link2.Hash, options);
-    node = decode15(block);
+    node = decode16(block);
     return findShardCid(node, name7, blockstore, context2, options);
   };
   var find_cid_in_shard_default = findShardCid;
@@ -19366,8 +20821,8 @@ You can use close({ resize: true }) to resize header`);
     }
   };
   function pushable(options = {}) {
-    const getNext = (buffer2) => {
-      const next = buffer2.shift();
+    const getNext = (buffer3) => {
+      const next = buffer3.shift();
       if (next == null) {
         return { done: true };
       }
@@ -19385,15 +20840,15 @@ You can use close({ resize: true }) to resize header`);
   function _pushable(getNext, options) {
     options = options ?? {};
     let onEnd = options.onEnd;
-    let buffer2 = new FIFO();
+    let buffer3 = new FIFO();
     let pushable2;
     let onNext;
     let ended;
     let drain = pDefer();
     const waitNext = async () => {
       try {
-        if (!buffer2.isEmpty()) {
-          return getNext(buffer2);
+        if (!buffer3.isEmpty()) {
+          return getNext(buffer3);
         }
         if (ended) {
           return { done: true };
@@ -19401,9 +20856,9 @@ You can use close({ resize: true }) to resize header`);
         return await new Promise((resolve5, reject) => {
           onNext = (next) => {
             onNext = null;
-            buffer2.push(next);
+            buffer3.push(next);
             try {
-              resolve5(getNext(buffer2));
+              resolve5(getNext(buffer3));
             } catch (err) {
               reject(err);
             }
@@ -19411,7 +20866,7 @@ You can use close({ resize: true }) to resize header`);
           };
         });
       } finally {
-        if (buffer2.isEmpty()) {
+        if (buffer3.isEmpty()) {
           queueMicrotask(() => {
             drain.resolve();
             drain = pDefer();
@@ -19423,15 +20878,15 @@ You can use close({ resize: true }) to resize header`);
       if (onNext != null) {
         return onNext(next);
       }
-      buffer2.push(next);
+      buffer3.push(next);
       return pushable2;
     };
     const bufferError = (err) => {
-      buffer2 = new FIFO();
+      buffer3 = new FIFO();
       if (onNext != null) {
         return onNext({ error: err });
       }
-      buffer2.push({ error: err });
+      buffer3.push({ error: err });
       return pushable2;
     };
     const push2 = (value) => {
@@ -19450,7 +20905,7 @@ You can use close({ resize: true }) to resize header`);
       return err != null ? bufferError(err) : bufferNext({ done: true });
     };
     const _return = () => {
-      buffer2 = new FIFO();
+      buffer3 = new FIFO();
       end();
       return { done: true };
     };
@@ -19468,12 +20923,12 @@ You can use close({ resize: true }) to resize header`);
       push: push2,
       end,
       get readableLength() {
-        return buffer2.size;
+        return buffer3.size;
       },
       onEmpty: async (options2) => {
         const signal = options2?.signal;
         signal?.throwIfAborted();
-        if (buffer2.isEmpty()) {
+        if (buffer3.isEmpty()) {
           return;
         }
         let cancel;
@@ -20118,8 +21573,8 @@ You can use close({ resize: true }) to resize header`);
   // ../../node_modules/.pnpm/ipfs-unixfs-exporter@13.2.5/node_modules/ipfs-unixfs-exporter/dist/src/resolvers/unixfs-v1/content/file.js
   async function walkDAG(blockstore, node, queue, streamPosition, start, end, options) {
     if (node instanceof Uint8Array) {
-      const buf2 = extract_data_from_block_default(node, streamPosition, start, end);
-      queue.push(buf2);
+      const buf3 = extract_data_from_block_default(node, streamPosition, start, end);
+      queue.push(buf3);
       return;
     }
     if (node.Data == null) {
@@ -20133,9 +21588,9 @@ You can use close({ resize: true }) to resize header`);
     }
     if (file.data != null) {
       const data = file.data;
-      const buf2 = extract_data_from_block_default(data, streamPosition, start, end);
-      queue.push(buf2);
-      streamPosition += BigInt(buf2.byteLength);
+      const buf3 = extract_data_from_block_default(data, streamPosition, start, end);
+      queue.push(buf3);
+      streamPosition += BigInt(buf3.byteLength);
     }
     const childOps = [];
     if (node.Links.length !== file.blockSizes.length) {
@@ -20173,7 +21628,7 @@ You can use close({ resize: true }) to resize header`);
         let child;
         switch (link2.Hash.code) {
           case code3:
-            child = decode15(block);
+            child = decode16(block);
             break;
           case code5:
             child = block;
@@ -20220,11 +21675,11 @@ You can use close({ resize: true }) to resize header`);
       void walkDAG(blockstore, node, queue, 0n, start, end, options).catch((err) => {
         queue.end(err);
       });
-      for await (const buf2 of queue) {
-        if (buf2 == null) {
+      for await (const buf3 of queue) {
+        if (buf3 == null) {
           continue;
         }
-        read6 += BigInt(buf2.byteLength);
+        read6 += BigInt(buf3.byteLength);
         if (read6 > wanted) {
           queue.end();
           throw (0, import_err_code7.default)(new Error("Read too many bytes - the file size reported by the UnixFS data in the root node may be incorrect"), "ERR_OVER_READ");
@@ -20237,7 +21692,7 @@ You can use close({ resize: true }) to resize header`);
           totalBytes: wanted,
           fileSize
         }));
-        yield buf2;
+        yield buf3;
       }
       if (read6 < wanted) {
         throw (0, import_err_code7.default)(new Error("Traversed entire DAG but did not read enough bytes"), "ERR_UNDER_READ");
@@ -20281,7 +21736,7 @@ You can use close({ resize: true }) to resize header`);
           return { entries: result.entry == null ? [] : [result.entry] };
         } else {
           const block = await blockstore.get(link2.Hash, options);
-          node = decode15(block);
+          node = decode16(block);
           options.onProgress?.(new CustomProgressEvent("unixfs:exporter:walk:hamt-sharded-directory", {
             cid: link2.Hash
           }));
@@ -20314,7 +21769,7 @@ You can use close({ resize: true }) to resize header`);
   };
   var unixFsResolver = async (cid, name7, path, toResolve, resolve5, depth, blockstore, options) => {
     const block = await blockstore.get(cid, options);
-    const node = decode15(block);
+    const node = decode16(block);
     let unixfs;
     let next;
     if (name7 == null) {
@@ -20598,6 +22053,11 @@ You can use close({ resize: true }) to resize header`);
           t.putSync(block.cid, block.bytes);
         }
         files[filename] = { cid, type: file.type, size: file.size };
+      } else {
+        const { cid, type: type2, size, car } = files[filename];
+        if (cid && type2 && size && car) {
+          files[filename] = { cid, type: type2, size, car };
+        }
       }
     }
     if (didPut.length) {
@@ -20876,7 +22336,7 @@ You can use close({ resize: true }) to resize header`);
     BranchClass: MapBranch,
     BranchEntryClass: MapBranchEntry
   };
-  var createGetNode2 = (get7, cache4, chunker3, codec, hasher, compare5, opts) => {
+  var createGetNode2 = (get7, cache4, chunker3, codec, hasher, compare6, opts) => {
     const LeafClass2 = opts.LeafClass || MapLeaf;
     const LeafEntryClass = opts.LeafEntryClass || MapLeafEntry;
     const BranchClass2 = opts.BranchClass || MapBranch;
@@ -20892,7 +22352,7 @@ You can use close({ resize: true }) to resize header`);
       getNode,
       codec,
       hasher,
-      compare: compare5,
+      compare: compare6,
       LeafEntryClass,
       LeafClass: LeafClass2,
       BranchEntryClass,
@@ -20900,10 +22360,10 @@ You can use close({ resize: true }) to resize header`);
     });
     return getNode;
   };
-  var create16 = ({ get: get7, cache: cache4, chunker: chunker3, list, codec, hasher, sorted, compare: compare5, ...opts }) => {
+  var create16 = ({ get: get7, cache: cache4, chunker: chunker3, list, codec, hasher, sorted, compare: compare6, ...opts }) => {
     if (!sorted)
-      list = list.sort(({ key: a }, { key: b }) => compare5(a, b));
-    const getNode = createGetNode2(get7, cache4, chunker3, codec, hasher, compare5, opts);
+      list = list.sort(({ key: a }, { key: b }) => compare6(a, b));
+    const getNode = createGetNode2(get7, cache4, chunker3, codec, hasher, compare6, opts);
     const _opts = {
       list,
       codec,
@@ -20911,7 +22371,7 @@ You can use close({ resize: true }) to resize header`);
       chunker: chunker3,
       getNode,
       sorted,
-      compare: compare5,
+      compare: compare6,
       cache: cache4,
       LeafClass: opts.LeafClass || MapLeaf,
       LeafEntryClass: opts.LeafEntryClass || MapLeafEntry,
@@ -20920,11 +22380,11 @@ You can use close({ resize: true }) to resize header`);
     };
     return create5(_opts);
   };
-  var load2 = ({ cid, get: get7, cache: cache4, chunker: chunker3, codec, hasher, compare: compare5, ...opts }) => {
-    const getNode = createGetNode2(get7, cache4, chunker3, codec, hasher, compare5, opts);
+  var load2 = ({ cid, get: get7, cache: cache4, chunker: chunker3, codec, hasher, compare: compare6, ...opts }) => {
+    const getNode = createGetNode2(get7, cache4, chunker3, codec, hasher, compare6, opts);
     return getNode(cid);
   };
-  function makeDecoder({ chunker: chunker3, cache: cache4, getNode, codec, hasher, compare: compare5, LeafEntryClass, LeafClass: LeafClass2, BranchEntryClass, BranchClass: BranchClass2 }) {
+  function makeDecoder({ chunker: chunker3, cache: cache4, getNode, codec, hasher, compare: compare6, LeafEntryClass, LeafClass: LeafClass2, BranchEntryClass, BranchClass: BranchClass2 }) {
     const entryOpts = {
       codec,
       hasher
@@ -20938,7 +22398,7 @@ You can use close({ resize: true }) to resize header`);
         getNode,
         codec,
         hasher,
-        compare: compare5
+        compare: compare6
       };
       let entries3;
       let CLS;
@@ -20973,7 +22433,7 @@ You can use close({ resize: true }) to resize header`);
   }
 
   // ../../node_modules/.pnpm/prolly-trees@1.0.4/node_modules/prolly-trees/esm/src/db-index.js
-  var compare3 = (a, b) => {
+  var compare4 = (a, b) => {
     const [aKey, aRef] = a;
     const [bKey, bRef] = b;
     const comp = simpleCompare(aKey, bKey);
@@ -21079,7 +22539,7 @@ You can use close({ resize: true }) to resize header`);
   };
   var defaults4 = {
     ...classes2,
-    compare: compare3
+    compare: compare4
   };
   var create17 = (opts) => {
     opts = {
@@ -21110,7 +22570,7 @@ You can use close({ resize: true }) to resize header`);
       return 1;
     return simpleCompare(aRef, bRef);
   };
-  var compare4 = (a, b) => {
+  var compare5 = (a, b) => {
     const [aKey, aRef] = a;
     const [bKey, bRef] = b;
     const comp = simpleCompare(aKey, bKey);
@@ -21118,7 +22578,7 @@ You can use close({ resize: true }) to resize header`);
       return comp;
     return refCompare2(aRef, bRef);
   };
-  var byKeyOpts = { cache: nocache, chunker: bf(30), codec: src_exports, hasher: sha256, compare: compare4 };
+  var byKeyOpts = { cache: nocache, chunker: bf(30), codec: src_exports, hasher: sha256, compare: compare5 };
   var byIdOpts = { cache: nocache, chunker: bf(30), codec: src_exports, hasher: sha256, compare: simpleCompare };
   function indexEntriesForChanges(changes, mapFn) {
     const indexEntries = [];