nitro-patcher 0.2.0 → 0.2.1

package/dist/browser.js

@@ -4,11 +4,20 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+var __esm = (fn, res, err2) => function __init() {
+  if (err2) throw err2[0];
+  try {
+    return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+  } catch (e) {
+    throw err2 = [e], e;
+  }
 };
 var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
 };
 var __copyProps = (to, from, except, desc) => {
   if (from && typeof from === "object" || typeof from === "function") {
@@ -39,11 +48,11 @@ var require_base64_js = __commonJS({
     var revLookup = [];
     var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
     var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-    for (i = 0, len = code.length; i < len; ++i) {
-      lookup[i] = code[i];
-      revLookup[code.charCodeAt(i)] = i;
+    for (i2 = 0, len = code.length; i2 < len; ++i2) {
+      lookup[i2] = code[i2];
+      revLookup[code.charCodeAt(i2)] = i2;
     }
-    var i;
+    var i2;
     var len;
     revLookup["-".charCodeAt(0)] = 62;
     revLookup["_".charCodeAt(0)] = 63;
@@ -74,19 +83,19 @@ var require_base64_js = __commonJS({
       var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen));
       var curByte = 0;
       var len2 = placeHoldersLen > 0 ? validLen - 4 : validLen;
-      var i2;
-      for (i2 = 0; i2 < len2; i2 += 4) {
-        tmp = revLookup[b64.charCodeAt(i2)] << 18 | revLookup[b64.charCodeAt(i2 + 1)] << 12 | revLookup[b64.charCodeAt(i2 + 2)] << 6 | revLookup[b64.charCodeAt(i2 + 3)];
+      var i3;
+      for (i3 = 0; i3 < len2; i3 += 4) {
+        tmp = revLookup[b64.charCodeAt(i3)] << 18 | revLookup[b64.charCodeAt(i3 + 1)] << 12 | revLookup[b64.charCodeAt(i3 + 2)] << 6 | revLookup[b64.charCodeAt(i3 + 3)];
         arr[curByte++] = tmp >> 16 & 255;
         arr[curByte++] = tmp >> 8 & 255;
         arr[curByte++] = tmp & 255;
       }
       if (placeHoldersLen === 2) {
-        tmp = revLookup[b64.charCodeAt(i2)] << 2 | revLookup[b64.charCodeAt(i2 + 1)] >> 4;
+        tmp = revLookup[b64.charCodeAt(i3)] << 2 | revLookup[b64.charCodeAt(i3 + 1)] >> 4;
         arr[curByte++] = tmp & 255;
       }
       if (placeHoldersLen === 1) {
-        tmp = revLookup[b64.charCodeAt(i2)] << 10 | revLookup[b64.charCodeAt(i2 + 1)] << 4 | revLookup[b64.charCodeAt(i2 + 2)] >> 2;
+        tmp = revLookup[b64.charCodeAt(i3)] << 10 | revLookup[b64.charCodeAt(i3 + 1)] << 4 | revLookup[b64.charCodeAt(i3 + 2)] >> 2;
         arr[curByte++] = tmp >> 8 & 255;
         arr[curByte++] = tmp & 255;
       }
@@ -98,8 +107,8 @@ var require_base64_js = __commonJS({
     function encodeChunk(uint8, start, end) {
       var tmp;
       var output = [];
-      for (var i2 = start; i2 < end; i2 += 3) {
-        tmp = (uint8[i2] << 16 & 16711680) + (uint8[i2 + 1] << 8 & 65280) + (uint8[i2 + 2] & 255);
+      for (var i3 = start; i3 < end; i3 += 3) {
+        tmp = (uint8[i3] << 16 & 16711680) + (uint8[i3 + 1] << 8 & 65280) + (uint8[i3 + 2] & 255);
         output.push(tripletToBase64(tmp));
       }
       return output.join("");
@@ -110,8 +119,8 @@ var require_base64_js = __commonJS({
       var extraBytes = len2 % 3;
       var parts = [];
       var maxChunkLength = 16383;
-      for (var i2 = 0, len22 = len2 - extraBytes; i2 < len22; i2 += maxChunkLength) {
-        parts.push(encodeChunk(uint8, i2, i2 + maxChunkLength > len22 ? len22 : i2 + maxChunkLength));
+      for (var i3 = 0, len22 = len2 - extraBytes; i3 < len22; i3 += maxChunkLength) {
+        parts.push(encodeChunk(uint8, i3, i3 + maxChunkLength > len22 ? len22 : i3 + maxChunkLength));
       }
       if (extraBytes === 1) {
         tmp = uint8[len2 - 1];
@@ -139,19 +148,19 @@ var require_ieee754 = __commonJS({
       var eMax = (1 << eLen) - 1;
       var eBias = eMax >> 1;
       var nBits = -7;
-      var i = isLE2 ? nBytes - 1 : 0;
+      var i2 = isLE2 ? nBytes - 1 : 0;
       var d = isLE2 ? -1 : 1;
-      var s = buffer[offset + i];
-      i += d;
+      var s = buffer[offset + i2];
+      i2 += d;
       e = s & (1 << -nBits) - 1;
       s >>= -nBits;
       nBits += eLen;
-      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      for (; nBits > 0; e = e * 256 + buffer[offset + i2], i2 += d, nBits -= 8) {
       }
       m = e & (1 << -nBits) - 1;
       e >>= -nBits;
       nBits += mLen;
-      for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8) {
+      for (; nBits > 0; m = m * 256 + buffer[offset + i2], i2 += d, nBits -= 8) {
       }
       if (e === 0) {
         e = 1 - eBias;
@@ -169,7 +178,7 @@ var require_ieee754 = __commonJS({
       var eMax = (1 << eLen) - 1;
       var eBias = eMax >> 1;
       var rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0;
-      var i = isLE2 ? 0 : nBytes - 1;
+      var i2 = isLE2 ? 0 : nBytes - 1;
       var d = isLE2 ? 1 : -1;
       var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
       value = Math.abs(value);
@@ -202,13 +211,13 @@ var require_ieee754 = __commonJS({
           e = 0;
         }
       }
-      for (; mLen >= 8; buffer[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
+      for (; mLen >= 8; buffer[offset + i2] = m & 255, i2 += d, m /= 256, mLen -= 8) {
       }
       e = e << mLen | m;
       eLen += mLen;
-      for (; eLen > 0; buffer[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
+      for (; eLen > 0; buffer[offset + i2] = e & 255, i2 += d, e /= 256, eLen -= 8) {
       }
-      buffer[offset + i - d] |= s * 128;
+      buffer[offset + i2 - d] |= s * 128;
     };
   }
 });
@@ -368,8 +377,8 @@ var require_buffer = __commonJS({
     function fromArrayLike(array) {
       const length = array.length < 0 ? 0 : checked(array.length) | 0;
       const buf = createBuffer(length);
-      for (let i = 0; i < length; i += 1) {
-        buf[i] = array[i] & 255;
+      for (let i2 = 0; i2 < length; i2 += 1) {
+        buf[i2] = array[i2] & 255;
       }
       return buf;
     }
@@ -442,17 +451,17 @@ var require_buffer = __commonJS({
         );
       }
       if (a === b) return 0;
-      let x = a.length;
+      let x2 = a.length;
       let y = b.length;
-      for (let i = 0, len = Math.min(x, y); i < len; ++i) {
-        if (a[i] !== b[i]) {
-          x = a[i];
-          y = b[i];
+      for (let i2 = 0, len = Math.min(x2, y); i2 < len; ++i2) {
+        if (a[i2] !== b[i2]) {
+          x2 = a[i2];
+          y = b[i2];
           break;
         }
       }
-      if (x < y) return -1;
-      if (y < x) return 1;
+      if (x2 < y) return -1;
+      if (y < x2) return 1;
       return 0;
     };
     Buffer3.isEncoding = function isEncoding(encoding) {
@@ -480,17 +489,17 @@ var require_buffer = __commonJS({
       if (list.length === 0) {
         return Buffer3.alloc(0);
       }
-      let i;
+      let i2;
       if (length === void 0) {
         length = 0;
-        for (i = 0; i < list.length; ++i) {
-          length += list[i].length;
+        for (i2 = 0; i2 < list.length; ++i2) {
+          length += list[i2].length;
         }
       }
       const buffer = Buffer3.allocUnsafe(length);
       let pos = 0;
-      for (i = 0; i < list.length; ++i) {
-        let buf = list[i];
+      for (i2 = 0; i2 < list.length; ++i2) {
+        let buf = list[i2];
         if (isInstance(buf, Uint8Array)) {
           if (pos + buf.length > buffer.length) {
             if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf);
@@ -603,17 +612,17 @@ var require_buffer = __commonJS({
     }
     Buffer3.prototype._isBuffer = true;
     function swap(b, n, m) {
-      const i = b[n];
+      const i2 = b[n];
       b[n] = b[m];
-      b[m] = i;
+      b[m] = i2;
     }
     Buffer3.prototype.swap16 = function swap16() {
       const len = this.length;
       if (len % 2 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 16-bits");
       }
-      for (let i = 0; i < len; i += 2) {
-        swap(this, i, i + 1);
+      for (let i2 = 0; i2 < len; i2 += 2) {
+        swap(this, i2, i2 + 1);
       }
       return this;
     };
@@ -622,9 +631,9 @@ var require_buffer = __commonJS({
       if (len % 4 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 32-bits");
       }
-      for (let i = 0; i < len; i += 4) {
-        swap(this, i, i + 3);
-        swap(this, i + 1, i + 2);
+      for (let i2 = 0; i2 < len; i2 += 4) {
+        swap(this, i2, i2 + 3);
+        swap(this, i2 + 1, i2 + 2);
       }
       return this;
     };
@@ -633,11 +642,11 @@ var require_buffer = __commonJS({
       if (len % 8 !== 0) {
         throw new RangeError("Buffer size must be a multiple of 64-bits");
       }
-      for (let i = 0; i < len; i += 8) {
-        swap(this, i, i + 7);
-        swap(this, i + 1, i + 6);
-        swap(this, i + 2, i + 5);
-        swap(this, i + 3, i + 4);
+      for (let i2 = 0; i2 < len; i2 += 8) {
+        swap(this, i2, i2 + 7);
+        swap(this, i2 + 1, i2 + 6);
+        swap(this, i2 + 2, i2 + 5);
+        swap(this, i2 + 3, i2 + 4);
       }
       return this;
     };
@@ -701,20 +710,20 @@ var require_buffer = __commonJS({
       thisStart >>>= 0;
       thisEnd >>>= 0;
       if (this === target) return 0;
-      let x = thisEnd - thisStart;
+      let x2 = thisEnd - thisStart;
       let y = end - start;
-      const len = Math.min(x, y);
+      const len = Math.min(x2, y);
       const thisCopy = this.slice(thisStart, thisEnd);
       const targetCopy = target.slice(start, end);
-      for (let i = 0; i < len; ++i) {
-        if (thisCopy[i] !== targetCopy[i]) {
-          x = thisCopy[i];
-          y = targetCopy[i];
+      for (let i2 = 0; i2 < len; ++i2) {
+        if (thisCopy[i2] !== targetCopy[i2]) {
+          x2 = thisCopy[i2];
+          y = targetCopy[i2];
           break;
         }
       }
-      if (x < y) return -1;
-      if (y < x) return 1;
+      if (x2 < y) return -1;
+      if (y < x2) return 1;
       return 0;
     };
     function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
@@ -776,36 +785,36 @@ var require_buffer = __commonJS({
           byteOffset /= 2;
         }
       }
-      function read(buf, i2) {
+      function read(buf, i3) {
         if (indexSize === 1) {
-          return buf[i2];
+          return buf[i3];
         } else {
-          return buf.readUInt16BE(i2 * indexSize);
+          return buf.readUInt16BE(i3 * indexSize);
         }
       }
-      let i;
+      let i2;
       if (dir) {
         let foundIndex = -1;
-        for (i = byteOffset; i < arrLength; i++) {
-          if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
-            if (foundIndex === -1) foundIndex = i;
-            if (i - foundIndex + 1 === valLength) return foundIndex * indexSize;
+        for (i2 = byteOffset; i2 < arrLength; i2++) {
+          if (read(arr, i2) === read(val, foundIndex === -1 ? 0 : i2 - foundIndex)) {
+            if (foundIndex === -1) foundIndex = i2;
+            if (i2 - foundIndex + 1 === valLength) return foundIndex * indexSize;
           } else {
-            if (foundIndex !== -1) i -= i - foundIndex;
+            if (foundIndex !== -1) i2 -= i2 - foundIndex;
             foundIndex = -1;
           }
         }
       } else {
         if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
-        for (i = byteOffset; i >= 0; i--) {
+        for (i2 = byteOffset; i2 >= 0; i2--) {
           let found = true;
           for (let j = 0; j < valLength; j++) {
-            if (read(arr, i + j) !== read(val, j)) {
+            if (read(arr, i2 + j) !== read(val, j)) {
               found = false;
               break;
             }
           }
-          if (found) return i;
+          if (found) return i2;
         }
       }
       return -1;
@@ -834,13 +843,13 @@ var require_buffer = __commonJS({
       if (length > strLen / 2) {
         length = strLen / 2;
       }
-      let i;
-      for (i = 0; i < length; ++i) {
-        const parsed = parseInt(string.substr(i * 2, 2), 16);
-        if (numberIsNaN(parsed)) return i;
-        buf[offset + i] = parsed;
+      let i2;
+      for (i2 = 0; i2 < length; ++i2) {
+        const parsed = parseInt(string.substr(i2 * 2, 2), 16);
+        if (numberIsNaN(parsed)) return i2;
+        buf[offset + i2] = parsed;
       }
-      return i;
+      return i2;
     }
     function utf8Write(buf, string, offset, length) {
       return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
@@ -925,12 +934,12 @@ var require_buffer = __commonJS({
     function utf8Slice(buf, start, end) {
       end = Math.min(buf.length, end);
       const res = [];
-      let i = start;
-      while (i < end) {
-        const firstByte = buf[i];
+      let i2 = start;
+      while (i2 < end) {
+        const firstByte = buf[i2];
         let codePoint = null;
         let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
-        if (i + bytesPerSequence <= end) {
+        if (i2 + bytesPerSequence <= end) {
           let secondByte, thirdByte, fourthByte, tempCodePoint;
           switch (bytesPerSequence) {
             case 1:
@@ -939,7 +948,7 @@ var require_buffer = __commonJS({
               }
               break;
             case 2:
-              secondByte = buf[i + 1];
+              secondByte = buf[i2 + 1];
               if ((secondByte & 192) === 128) {
                 tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
                 if (tempCodePoint > 127) {
@@ -948,8 +957,8 @@ var require_buffer = __commonJS({
               }
               break;
             case 3:
-              secondByte = buf[i + 1];
-              thirdByte = buf[i + 2];
+              secondByte = buf[i2 + 1];
+              thirdByte = buf[i2 + 2];
               if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
                 tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
                 if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
@@ -958,9 +967,9 @@ var require_buffer = __commonJS({
               }
               break;
             case 4:
-              secondByte = buf[i + 1];
-              thirdByte = buf[i + 2];
-              fourthByte = buf[i + 3];
+              secondByte = buf[i2 + 1];
+              thirdByte = buf[i2 + 2];
+              fourthByte = buf[i2 + 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) {
@@ -978,7 +987,7 @@ var require_buffer = __commonJS({
           codePoint = 56320 | codePoint & 1023;
         }
         res.push(codePoint);
-        i += bytesPerSequence;
+        i2 += bytesPerSequence;
       }
       return decodeCodePointsArray(res);
     }
@@ -989,11 +998,11 @@ var require_buffer = __commonJS({
         return String.fromCharCode.apply(String, codePoints);
       }
       let res = "";
-      let i = 0;
-      while (i < len) {
+      let i2 = 0;
+      while (i2 < len) {
         res += String.fromCharCode.apply(
           String,
-          codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+          codePoints.slice(i2, i2 += MAX_ARGUMENTS_LENGTH)
         );
       }
       return res;
@@ -1001,16 +1010,16 @@ var require_buffer = __commonJS({
     function asciiSlice(buf, start, end) {
       let ret = "";
       end = Math.min(buf.length, end);
-      for (let i = start; i < end; ++i) {
-        ret += String.fromCharCode(buf[i] & 127);
+      for (let i2 = start; i2 < end; ++i2) {
+        ret += String.fromCharCode(buf[i2] & 127);
       }
       return ret;
     }
     function latin1Slice(buf, start, end) {
       let ret = "";
       end = Math.min(buf.length, end);
-      for (let i = start; i < end; ++i) {
-        ret += String.fromCharCode(buf[i]);
+      for (let i2 = start; i2 < end; ++i2) {
+        ret += String.fromCharCode(buf[i2]);
       }
       return ret;
     }
@@ -1019,16 +1028,16 @@ var require_buffer = __commonJS({
       if (!start || start < 0) start = 0;
       if (!end || end < 0 || end > len) end = len;
       let out = "";
-      for (let i = start; i < end; ++i) {
-        out += hexSliceLookupTable[buf[i]];
+      for (let i2 = start; i2 < end; ++i2) {
+        out += hexSliceLookupTable[buf[i2]];
       }
       return out;
     }
     function utf16leSlice(buf, start, end) {
       const bytes2 = buf.slice(start, end);
       let res = "";
-      for (let i = 0; i < bytes2.length - 1; i += 2) {
-        res += String.fromCharCode(bytes2[i] + bytes2[i + 1] * 256);
+      for (let i2 = 0; i2 < bytes2.length - 1; i2 += 2) {
+        res += String.fromCharCode(bytes2[i2] + bytes2[i2 + 1] * 256);
       }
       return res;
     }
@@ -1063,9 +1072,9 @@ var require_buffer = __commonJS({
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
       let val = this[offset];
       let mul3 = 1;
-      let i = 0;
-      while (++i < byteLength2 && (mul3 *= 256)) {
-        val += this[offset + i] * mul3;
+      let i2 = 0;
+      while (++i2 < byteLength2 && (mul3 *= 256)) {
+        val += this[offset + i2] * mul3;
       }
       return val;
     };
@@ -1137,9 +1146,9 @@ var require_buffer = __commonJS({
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
       let val = this[offset];
       let mul3 = 1;
-      let i = 0;
-      while (++i < byteLength2 && (mul3 *= 256)) {
-        val += this[offset + i] * mul3;
+      let i2 = 0;
+      while (++i2 < byteLength2 && (mul3 *= 256)) {
+        val += this[offset + i2] * mul3;
       }
       mul3 *= 128;
       if (val >= mul3) val -= Math.pow(2, 8 * byteLength2);
@@ -1149,11 +1158,11 @@ var require_buffer = __commonJS({
       offset = offset >>> 0;
       byteLength2 = byteLength2 >>> 0;
       if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      let i = byteLength2;
+      let i2 = byteLength2;
       let mul3 = 1;
-      let val = this[offset + --i];
-      while (i > 0 && (mul3 *= 256)) {
-        val += this[offset + --i] * mul3;
+      let val = this[offset + --i2];
+      while (i2 > 0 && (mul3 *= 256)) {
+        val += this[offset + --i2] * mul3;
       }
       mul3 *= 128;
       if (val >= mul3) val -= Math.pow(2, 8 * byteLength2);
@@ -1244,10 +1253,10 @@ var require_buffer = __commonJS({
         checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
       let mul3 = 1;
-      let i = 0;
+      let i2 = 0;
       this[offset] = value & 255;
-      while (++i < byteLength2 && (mul3 *= 256)) {
-        this[offset + i] = value / mul3 & 255;
+      while (++i2 < byteLength2 && (mul3 *= 256)) {
+        this[offset + i2] = value / mul3 & 255;
       }
       return offset + byteLength2;
     };
@@ -1259,11 +1268,11 @@ var require_buffer = __commonJS({
         const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
         checkInt(this, value, offset, byteLength2, maxBytes, 0);
       }
-      let i = byteLength2 - 1;
+      let i2 = byteLength2 - 1;
       let mul3 = 1;
-      this[offset + i] = value & 255;
-      while (--i >= 0 && (mul3 *= 256)) {
-        this[offset + i] = value / mul3 & 255;
+      this[offset + i2] = value & 255;
+      while (--i2 >= 0 && (mul3 *= 256)) {
+        this[offset + i2] = value / mul3 & 255;
       }
       return offset + byteLength2;
     };
@@ -1363,15 +1372,15 @@ var require_buffer = __commonJS({
         const limit2 = Math.pow(2, 8 * byteLength2 - 1);
         checkInt(this, value, offset, byteLength2, limit2 - 1, -limit2);
       }
-      let i = 0;
+      let i2 = 0;
       let mul3 = 1;
       let sub = 0;
       this[offset] = value & 255;
-      while (++i < byteLength2 && (mul3 *= 256)) {
-        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
+      while (++i2 < byteLength2 && (mul3 *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i2 - 1] !== 0) {
           sub = 1;
         }
-        this[offset + i] = (value / mul3 >> 0) - sub & 255;
+        this[offset + i2] = (value / mul3 >> 0) - sub & 255;
       }
       return offset + byteLength2;
     };
@@ -1382,15 +1391,15 @@ var require_buffer = __commonJS({
         const limit2 = Math.pow(2, 8 * byteLength2 - 1);
         checkInt(this, value, offset, byteLength2, limit2 - 1, -limit2);
       }
-      let i = byteLength2 - 1;
+      let i2 = byteLength2 - 1;
       let mul3 = 1;
       let sub = 0;
-      this[offset + i] = value & 255;
-      while (--i >= 0 && (mul3 *= 256)) {
-        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
+      this[offset + i2] = value & 255;
+      while (--i2 >= 0 && (mul3 *= 256)) {
+        if (value < 0 && sub === 0 && this[offset + i2 + 1] !== 0) {
           sub = 1;
         }
-        this[offset + i] = (value / mul3 >> 0) - sub & 255;
+        this[offset + i2] = (value / mul3 >> 0) - sub & 255;
       }
       return offset + byteLength2;
     };
@@ -1545,10 +1554,10 @@ var require_buffer = __commonJS({
       start = start >>> 0;
       end = end === void 0 ? this.length : end >>> 0;
       if (!val) val = 0;
-      let i;
+      let i2;
       if (typeof val === "number") {
-        for (i = start; i < end; ++i) {
-          this[i] = val;
+        for (i2 = start; i2 < end; ++i2) {
+          this[i2] = val;
         }
       } else {
         const bytes2 = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
@@ -1556,8 +1565,8 @@ var require_buffer = __commonJS({
         if (len === 0) {
           throw new TypeError('The value "' + val + '" is invalid for argument "value"');
         }
-        for (i = 0; i < end - start; ++i) {
-          this[i + start] = bytes2[i % len];
+        for (i2 = 0; i2 < end - start; ++i2) {
+          this[i2 + start] = bytes2[i2 % len];
         }
       }
       return this;
@@ -1630,12 +1639,12 @@ var require_buffer = __commonJS({
     );
     function addNumericalSeparator(val) {
       let res = "";
-      let i = val.length;
+      let i2 = val.length;
       const start = val[0] === "-" ? 1 : 0;
-      for (; i >= start + 4; i -= 3) {
-        res = `_${val.slice(i - 3, i)}${res}`;
+      for (; i2 >= start + 4; i2 -= 3) {
+        res = `_${val.slice(i2 - 3, i2)}${res}`;
       }
-      return `${val.slice(0, i)}${res}`;
+      return `${val.slice(0, i2)}${res}`;
     }
     function checkBounds(buf, offset, byteLength2) {
       validateNumber(offset, "offset");
@@ -1695,14 +1704,14 @@ var require_buffer = __commonJS({
       const length = string.length;
       let leadSurrogate = null;
       const bytes2 = [];
-      for (let i = 0; i < length; ++i) {
-        codePoint = string.charCodeAt(i);
+      for (let i2 = 0; i2 < length; ++i2) {
+        codePoint = string.charCodeAt(i2);
         if (codePoint > 55295 && codePoint < 57344) {
           if (!leadSurrogate) {
             if (codePoint > 56319) {
               if ((units -= 3) > -1) bytes2.push(239, 191, 189);
               continue;
-            } else if (i + 1 === length) {
+            } else if (i2 + 1 === length) {
               if ((units -= 3) > -1) bytes2.push(239, 191, 189);
               continue;
             }
@@ -1751,17 +1760,17 @@ var require_buffer = __commonJS({
     }
     function asciiToBytes(str) {
       const byteArray = [];
-      for (let i = 0; i < str.length; ++i) {
-        byteArray.push(str.charCodeAt(i) & 255);
+      for (let i2 = 0; i2 < str.length; ++i2) {
+        byteArray.push(str.charCodeAt(i2) & 255);
       }
       return byteArray;
     }
     function utf16leToBytes(str, units) {
       let c, hi, lo;
       const byteArray = [];
-      for (let i = 0; i < str.length; ++i) {
+      for (let i2 = 0; i2 < str.length; ++i2) {
         if ((units -= 2) < 0) break;
-        c = str.charCodeAt(i);
+        c = str.charCodeAt(i2);
         hi = c >> 8;
         lo = c % 256;
         byteArray.push(lo);
@@ -1773,12 +1782,12 @@ var require_buffer = __commonJS({
       return base64.toByteArray(base64clean(str));
     }
     function blitBuffer(src, dst, offset, length) {
-      let i;
-      for (i = 0; i < length; ++i) {
-        if (i + offset >= dst.length || i >= src.length) break;
-        dst[i + offset] = src[i];
+      let i2;
+      for (i2 = 0; i2 < length; ++i2) {
+        if (i2 + offset >= dst.length || i2 >= src.length) break;
+        dst[i2 + offset] = src[i2];
       }
-      return i;
+      return i2;
     }
     function isInstance(obj, type) {
       return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
@@ -1789,10 +1798,10 @@ var require_buffer = __commonJS({
     var hexSliceLookupTable = (function() {
       const alphabet = "0123456789abcdef";
       const table2 = new Array(256);
-      for (let i = 0; i < 16; ++i) {
-        const i16 = i * 16;
+      for (let i2 = 0; i2 < 16; ++i2) {
+        const i16 = i2 * 16;
         for (let j = 0; j < 16; ++j) {
-          table2[i16 + j] = alphabet[i] + alphabet[j];
+          table2[i16 + j] = alphabet[i2] + alphabet[j];
         }
       }
       return table2;
@@ -1824,24 +1833,10 @@ init_buffer();
 // src/runtime/browser.ts
 init_buffer();
 
-// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/legacy.js
-init_buffer();
-
-// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/_md.js
-init_buffer();
-
-// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/_u64.js
+// node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/aes.js
 init_buffer();
-var fromNumH = (n) => n / 2 ** 32 | 0;
-var fromNumL = (n) => n >>> 0;
-function setU64FromNum(view, byteOffset, n, isLE2) {
-  const h = fromNumH(n);
-  const l = fromNumL(n);
-  view.setUint32(byteOffset, isLE2 ? l : h, isLE2);
-  view.setUint32(byteOffset + 4, isLE2 ? h : l, isLE2);
-}
 
-// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/utils.js
+// node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/utils.js
 init_buffer();
 function isBytes(a) {
   return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
@@ -1867,167 +1862,562 @@ function abytes(value, length, title = "") {
     throw new TypeError(message);
   throw new RangeError(message);
 }
-function ahash(h) {
-  if (typeof h !== "function" || typeof h.create !== "function")
-    throw new TypeError("expected hash wrapped by utils.createHasher");
-  anumber(h.outputLen);
-  anumber(h.blockLen);
-  if (h.outputLen < 1 || h.blockLen < 1)
-    throw new Error("hash blockLen / outputLen must be >= 1");
-}
-var aobject = (value, label) => {
-  if (value === null || typeof value !== "object" || Array.isArray(value))
-    throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
-};
-var aopts = (value, label) => {
-  aobject(value, label);
-  const proto = Object.getPrototypeOf(value);
-  if (proto !== Object.prototype && proto !== null)
-    throw new TypeError(`"${label}" expected plain object`);
-  if (Object.hasOwn(value, "__proto__"))
-    throw new TypeError(`"${label}.__proto__" is not allowed`);
-};
-function aexists(instance, checkFinished = true) {
-  if (instance.destroyed)
-    throw new Error("hash was destroyed");
-  if (checkFinished && instance.finished)
-    throw new Error("digest() was already called");
+function u32(arr) {
+  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
 }
-function aoutput(out, instance) {
-  abytes(out, void 0, "output");
-  const min = instance.outputLen;
-  if (!(out.length >= min)) {
-    throw new RangeError('"output" expected length >= ' + min);
+function clean(...arrays) {
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    arrays[i2].fill(0);
   }
 }
-function clean(...arrays) {
-  for (let i = 0; i < arrays.length; i++) {
-    arrays[i].fill(0);
+var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
+function byteSwap(word) {
+  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
+}
+function byteSwap32(arr) {
+  for (let i2 = 0; i2 < arr.length; i2++) {
+    arr[i2] = byteSwap(arr[i2]);
   }
+  return arr;
 }
-function createView(arr) {
-  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+var swap32IfBE = isLE ? (u) => u : byteSwap32;
+function overlapBytes(a, b) {
+  if (!a.byteLength || !b.byteLength)
+    return false;
+  return a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy
+  a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end
+  b.byteOffset < a.byteOffset + a.byteLength;
 }
-function rotl(word, shift) {
-  return word << shift | word >>> 32 - shift >>> 0;
+function complexOverlapBytes(input, output) {
+  if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)
+    throw new Error("complex overlap of input and output is not supported");
 }
-function checkOpts(defaults, opts, title = "opts") {
-  aopts(defaults, "defaults");
-  if (opts !== void 0)
-    aopts(opts, title);
-  const merged = Object.assign(/* @__PURE__ */ Object.create(null), defaults, opts);
-  return merged;
+var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
+  function wrappedCipher(key2, ...args) {
+    abytes(key2, void 0, "key");
+    if (params.nonceLength !== void 0) {
+      const nonce = args[0];
+      abytes(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
+    }
+    const tagl = params.tagLength;
+    const aadStart = params.nonceLength !== void 0 ? 1 : 0;
+    if (!params.withAAD) {
+      for (let i2 = aadStart; i2 < args.length; i2++)
+        if (isBytes(args[i2]))
+          throw new Error("AAD not supported");
+    }
+    if (params.withAAD && args[aadStart] !== void 0)
+      abytes(args[aadStart], void 0, "AAD");
+    const cipher = constructor(key2, ...args);
+    const checkOutput = (fnLength, output) => {
+      if (output !== void 0) {
+        if (fnLength !== 2)
+          throw new Error("cipher output not supported");
+        abytes(output, void 0, "output");
+      }
+    };
+    let called = false;
+    const wrCipher = {
+      encrypt(data, output) {
+        if (called)
+          throw new Error("cannot encrypt() twice with same key + nonce");
+        called = true;
+        abytes(data, void 0, "data");
+        checkOutput(cipher.encrypt.length, output);
+        return cipher.encrypt(data, output);
+      },
+      decrypt(data, output) {
+        abytes(data, void 0, "data");
+        if (tagl && data.length < tagl)
+          throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
+        checkOutput(cipher.decrypt.length, output);
+        return cipher.decrypt(data, output);
+      }
+    };
+    return wrCipher;
+  }
+  Object.assign(wrappedCipher, params);
+  return wrappedCipher;
+};
+function getOutput(expectedLength, out, onlyAligned = true) {
+  if (out === void 0)
+    return new Uint8Array(expectedLength);
+  abytes(out, expectedLength, "output");
+  if (onlyAligned && !isAligned32(out))
+    throw new Error("invalid output, must be aligned");
+  return out;
 }
-function createHasher(hashCons, info = {}) {
-  if (typeof hashCons !== "function")
-    throw new TypeError('"hashCons" expected function, got type=' + typeof hashCons);
-  info = checkOpts({}, info, "info");
-  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
-  const tmp = hashCons(void 0);
-  hashC.outputLen = tmp.outputLen;
-  hashC.blockLen = tmp.blockLen;
-  hashC.canXOF = tmp.canXOF;
-  hashC.create = (opts) => hashCons(opts);
-  Object.assign(hashC, info);
-  return Object.freeze(hashC);
+function isAligned32(bytes2) {
+  return bytes2.byteOffset % 4 === 0;
+}
+function copyBytes(bytes2) {
+  return Uint8Array.from(abytes(bytes2));
 }
 
-// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/_md.js
-function Chi(a, b, c) {
-  return a & b ^ ~a & c;
+// node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/aes.js
+var BLOCK_SIZE = 16;
+var POLY = 283;
+function validateKeyLength(key2) {
+  if (![16, 24, 32].includes(key2.length))
+    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key2.length);
 }
-function Maj(a, b, c) {
-  return a & b ^ a & c ^ b & c;
+function mul2(n) {
+  return n << 1 ^ POLY & -(n >> 7);
 }
-var HashMD = class {
-  blockLen;
-  outputLen;
-  canXOF = false;
-  padOffset;
-  isLE;
-  // For partial updates less than block size
-  buffer;
-  view;
-  finished = false;
-  length = 0;
-  pos = 0;
-  destroyed = false;
-  constructor(blockLen, outputLen, padOffset, isLE2) {
-    this.blockLen = blockLen;
-    this.outputLen = outputLen;
-    this.padOffset = padOffset;
-    this.isLE = isLE2;
-    this.buffer = new Uint8Array(blockLen);
-    this.view = createView(this.buffer);
+function mul(a, b) {
+  let res = 0;
+  for (; b > 0; b >>= 1) {
+    res ^= a & -(b & 1);
+    a = mul2(a);
   }
-  update(data) {
-    aexists(this);
-    abytes(data);
-    const { view, buffer, blockLen } = this;
-    const len = data.length;
-    let processed = false;
-    for (let pos = 0; pos < len; ) {
-      const take = Math.min(blockLen - this.pos, len - pos);
-      if (take === blockLen) {
-        const dataView = createView(data);
-        for (; blockLen <= len - pos; pos += blockLen)
-          this.process(dataView, pos);
-        processed = true;
-        continue;
-      }
-      buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
-      this.pos += take;
-      pos += take;
-      if (this.pos === blockLen) {
-        this.process(view, 0);
-        this.pos = 0;
-        processed = true;
-      }
-    }
-    this.length += data.length;
-    if (processed)
-      this.roundClean();
-    return this;
+  return res;
+}
+var sbox = /* @__PURE__ */ (() => {
+  const t = new Uint8Array(256);
+  for (let i2 = 0, x2 = 1; i2 < 256; i2++, x2 ^= mul2(x2))
+    t[i2] = x2;
+  const box = new Uint8Array(256);
+  box[0] = 99;
+  for (let i2 = 0; i2 < 255; i2++) {
+    let x2 = t[255 - i2];
+    x2 |= x2 << 8;
+    box[t[i2]] = (x2 ^ x2 >> 4 ^ x2 >> 5 ^ x2 >> 6 ^ x2 >> 7 ^ 99) & 255;
   }
-  digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
-    this.finished = true;
-    const { buffer, view, blockLen, isLE: isLE2 } = this;
-    let { pos } = this;
-    buffer[pos++] = 128;
-    buffer.fill(0, pos);
-    if (this.padOffset > blockLen - pos) {
-      this.process(view, 0);
-      buffer.fill(0);
+  clean(t);
+  return box;
+})();
+var invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
+var rotr32_8 = (n) => n << 24 | n >>> 8;
+var rotl32_8 = (n) => n << 8 | n >>> 24;
+function genTtable(sbox2, fn) {
+  if (sbox2.length !== 256)
+    throw new Error("wrong sbox length");
+  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
+  const T1 = T0.map(rotl32_8);
+  const T2 = T1.map(rotl32_8);
+  const T3 = T2.map(rotl32_8);
+  const T01 = new Uint32Array(256 * 256);
+  const T23 = new Uint32Array(256 * 256);
+  const sbox22 = new Uint16Array(256 * 256);
+  for (let i2 = 0; i2 < 256; i2++) {
+    for (let j = 0; j < 256; j++) {
+      const idx = i2 * 256 + j;
+      T01[idx] = T0[i2] ^ T1[j];
+      T23[idx] = T2[i2] ^ T3[j];
+      sbox22[idx] = sbox2[i2] << 8 | sbox2[j];
     }
-    setU64FromNum(view, blockLen - 8, this.length * 8, isLE2);
-    this.process(view, 0);
-    this.roundClean();
-    const oview = out === buffer ? view : createView(out);
-    const len = this.outputLen;
-    const outLen = len / 4;
-    const state = this.get();
-    if (len % 4 || outLen > state.length)
-      throw new Error("invalid outputLen");
-    for (let i = 0; i < outLen; i++)
-      oview.setUint32(4 * i, state[i], isLE2);
-  }
-  digest() {
-    const { buffer, outputLen } = this;
-    this.digestInto(buffer);
-    const res = buffer.slice(0, outputLen);
-    this.destroy();
-    return res;
   }
-  _cloneIntoMeta(to) {
-    const { buffer, length, finished, destroyed, pos } = this;
-    to.destroyed = destroyed;
-    to.finished = finished;
-    to.length = length;
-    to.pos = pos;
-    if (pos)
-      to.buffer.set(buffer);
+  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
+}
+var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
+var tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => mul(s, 11) << 24 | mul(s, 13) << 16 | mul(s, 9) << 8 | mul(s, 14));
+var xPowers = /* @__PURE__ */ (() => {
+  const p = new Uint8Array(16);
+  for (let i2 = 0, x2 = 1; i2 < 16; i2++, x2 = mul2(x2))
+    p[i2] = x2;
+  return p;
+})();
+function expandKeyLE(key2) {
+  abytes(key2);
+  const len = key2.length;
+  validateKeyLength(key2);
+  const { sbox2 } = tableEncoding;
+  const toClean = [];
+  if (!isLE || !isAligned32(key2))
+    toClean.push(key2 = copyBytes(key2));
+  const k32 = swap32IfBE(u32(key2));
+  const Nk = k32.length;
+  const subByte = (n) => applySbox(sbox2, n, n, n, n);
+  const xk = new Uint32Array(len + 28);
+  xk.set(k32);
+  for (let i2 = Nk; i2 < xk.length; i2++) {
+    let t = xk[i2 - 1];
+    if (i2 % Nk === 0)
+      t = subByte(rotr32_8(t)) ^ xPowers[i2 / Nk - 1];
+    else if (Nk > 6 && i2 % Nk === 4)
+      t = subByte(t);
+    xk[i2] = xk[i2 - Nk] ^ t;
+  }
+  clean(...toClean);
+  return xk;
+}
+function expandKeyDecLE(key2) {
+  const encKey = expandKeyLE(key2);
+  const xk = encKey.slice();
+  const Nk = encKey.length;
+  const { sbox2 } = tableEncoding;
+  const { T0, T1, T2, T3 } = tableDecoding;
+  for (let i2 = 0; i2 < Nk; i2 += 4) {
+    for (let j = 0; j < 4; j++)
+      xk[i2 + j] = encKey[Nk - i2 - 4 + j];
+  }
+  clean(encKey);
+  for (let i2 = 4; i2 < Nk - 4; i2++) {
+    const x2 = xk[i2];
+    const w = applySbox(sbox2, x2, x2, x2, x2);
+    xk[i2] = T0[w & 255] ^ T1[w >>> 8 & 255] ^ T2[w >>> 16 & 255] ^ T3[w >>> 24];
+  }
+  return xk;
+}
+function apply0123(T01, T23, s0, s1, s2, s3) {
+  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
+}
+function applySbox(sbox2, s0, s1, s2, s3) {
+  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
+}
+function encrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableEncoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i2 = 0; i2 < rounds; i2++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function decrypt(xk, s0, s1, s2, s3) {
+  const { sbox2, T01, T23 } = tableDecoding;
+  let k = 0;
+  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
+  const rounds = xk.length / 4 - 2;
+  for (let i2 = 0; i2 < rounds; i2++) {
+    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);
+    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);
+    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);
+    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);
+    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  }
+  const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);
+  const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);
+  const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);
+  const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);
+  return { s0: t0, s1: t1, s2: t2, s3: t3 };
+}
+function validateBlockDecrypt(data, dst) {
+  abytes(data);
+  if (data.length % BLOCK_SIZE !== 0) {
+    throw new Error("ciphertext must be multiple of " + BLOCK_SIZE);
+  }
+  if (dst !== void 0) {
+    getOutput(data.length, dst);
+    complexOverlapBytes(data, dst);
+  }
+}
+function validateBlockEncrypt(plaintext, pkcs5, dst) {
+  abytes(plaintext);
+  let outLen = plaintext.length;
+  const remaining = outLen % BLOCK_SIZE;
+  if (!pkcs5 && remaining !== 0)
+    throw new Error("plaintext must be multiple of " + BLOCK_SIZE);
+  if (pkcs5) {
+    let left = BLOCK_SIZE - remaining;
+    if (!left)
+      left = BLOCK_SIZE;
+    outLen = outLen + left;
+  }
+  if (dst !== void 0) {
+    getOutput(outLen, dst);
+    complexOverlapBytes(plaintext, dst);
+  }
+  return outLen;
+}
+function prepareBlockEncrypt(plaintext, outLen, dst) {
+  if (dst === void 0)
+    dst = new Uint8Array(outLen);
+  if (!isLE || !isAligned32(plaintext))
+    plaintext = copyBytes(plaintext);
+  const o = u32(dst);
+  return { b: plaintext, o, out: dst };
+}
+function validatePKCS(data, pkcs5) {
+  if (!pkcs5)
+    return data;
+  const len = data.length;
+  if (len === 0)
+    throw new Error("pkcs7: empty ciphertext not allowed");
+  const lastByte = data[len - 1];
+  let valid = 1;
+  valid &= lastByte - 1 >>> 31 ^ 1;
+  valid &= 16 - lastByte >>> 31 ^ 1;
+  for (let i2 = 0; i2 < 16; i2++) {
+    const shouldCheck = i2 - lastByte >>> 31;
+    const eq = (data[len - 1 - i2] ^ lastByte) === 0 ? 1 : 0;
+    valid &= eq | shouldCheck ^ 1;
+  }
+  if (!valid)
+    throw new Error("aes: bad decrypt");
+  return data.subarray(0, len - lastByte);
+}
+function padPCKS(left) {
+  const tmp = new Uint8Array(16);
+  const tmp32 = u32(tmp);
+  tmp.set(left);
+  const paddingByte = BLOCK_SIZE - left.length;
+  for (let i2 = BLOCK_SIZE - paddingByte; i2 < BLOCK_SIZE; i2++)
+    tmp[i2] = paddingByte;
+  return tmp32;
+}
+var ecb = /* @__PURE__ */ wrapCipher({ blockSize: 16 }, function aesecb(key2, opts = {}) {
+  const pkcs5 = !opts.disablePadding;
+  return {
+    encrypt(plaintext, dst) {
+      const outLen = validateBlockEncrypt(plaintext, pkcs5, dst);
+      const xk = expandKeyLE(key2);
+      const { b: input, o, out: _out } = prepareBlockEncrypt(plaintext, outLen, dst);
+      const b = u32(input);
+      swap32IfBE(b);
+      let i2 = 0;
+      for (; i2 + 4 <= b.length; ) {
+        const { s0, s1, s2, s3 } = encrypt(xk, b[i2 + 0], b[i2 + 1], b[i2 + 2], b[i2 + 3]);
+        o[i2++] = s0, o[i2++] = s1, o[i2++] = s2, o[i2++] = s3;
+      }
+      if (pkcs5) {
+        const tmp32 = padPCKS(plaintext.subarray(i2 * 4));
+        swap32IfBE(tmp32);
+        const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);
+        o[i2++] = s0, o[i2++] = s1, o[i2++] = s2, o[i2++] = s3;
+        clean(tmp32);
+      }
+      swap32IfBE(o);
+      clean(xk);
+      if (input !== plaintext)
+        clean(input);
+      return _out;
+    },
+    decrypt(ciphertext, dst) {
+      validateBlockDecrypt(ciphertext, dst);
+      const xk = expandKeyDecLE(key2);
+      if (dst === void 0)
+        dst = new Uint8Array(ciphertext.length);
+      const toClean = [xk];
+      if (!isLE || !isAligned32(ciphertext))
+        toClean.push(ciphertext = copyBytes(ciphertext));
+      const b = u32(ciphertext);
+      const o = u32(dst);
+      swap32IfBE(b);
+      for (let i2 = 0; i2 + 4 <= b.length; ) {
+        const { s0, s1, s2, s3 } = decrypt(xk, b[i2 + 0], b[i2 + 1], b[i2 + 2], b[i2 + 3]);
+        o[i2++] = s0, o[i2++] = s1, o[i2++] = s2, o[i2++] = s3;
+      }
+      swap32IfBE(o);
+      clean(...toClean);
+      return validatePKCS(dst, pkcs5);
+    }
+  };
+});
+
+// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/legacy.js
+init_buffer();
+
+// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/_md.js
+init_buffer();
+
+// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/_u64.js
+init_buffer();
+var fromNumH = (n) => n / 2 ** 32 | 0;
+var fromNumL = (n) => n >>> 0;
+function setU64FromNum(view, byteOffset, n, isLE2) {
+  const h = fromNumH(n);
+  const l = fromNumL(n);
+  view.setUint32(byteOffset, isLE2 ? l : h, isLE2);
+  view.setUint32(byteOffset + 4, isLE2 ? h : l, isLE2);
+}
+
+// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/utils.js
+init_buffer();
+function isBytes2(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+var atitle2 = (title) => title ? `"${title}" ` : "";
+function anumber2(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle2(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle2(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+function abytes2(value, length, title = "") {
+  if (isBytes2(value) && (length === void 0 || value.length === length))
+    return value;
+  if (length !== void 0)
+    anumber2(length, "length");
+  const bytes2 = isBytes2(value);
+  const ofLen = length !== void 0 ? ` of length ${length}` : "";
+  const got = bytes2 ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle2(title) + "expected Uint8Array" + ofLen + ", got " + got;
+  if (!bytes2)
+    throw new TypeError(message);
+  throw new RangeError(message);
+}
+function ahash(h) {
+  if (typeof h !== "function" || typeof h.create !== "function")
+    throw new TypeError("expected hash wrapped by utils.createHasher");
+  anumber2(h.outputLen);
+  anumber2(h.blockLen);
+  if (h.outputLen < 1 || h.blockLen < 1)
+    throw new Error("hash blockLen / outputLen must be >= 1");
+}
+var aobject = (value, label) => {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new TypeError((label === "object" ? "" : `"${label}" `) + "expected object, got type=" + typeof value);
+};
+var aopts = (value, label) => {
+  aobject(value, label);
+  const proto = Object.getPrototypeOf(value);
+  if (proto !== Object.prototype && proto !== null)
+    throw new TypeError(`"${label}" expected plain object`);
+  if (Object.hasOwn(value, "__proto__"))
+    throw new TypeError(`"${label}.__proto__" is not allowed`);
+};
+function aexists2(instance, checkFinished = true) {
+  if (instance.destroyed)
+    throw new Error("hash was destroyed");
+  if (checkFinished && instance.finished)
+    throw new Error("digest() was already called");
+}
+function aoutput(out, instance) {
+  abytes2(out, void 0, "output");
+  const min = instance.outputLen;
+  if (!(out.length >= min)) {
+    throw new RangeError('"output" expected length >= ' + min);
+  }
+}
+function clean2(...arrays) {
+  for (let i2 = 0; i2 < arrays.length; i2++) {
+    arrays[i2].fill(0);
+  }
+}
+function createView2(arr) {
+  return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+function rotl(word, shift) {
+  return word << shift | word >>> 32 - shift >>> 0;
+}
+function checkOpts(defaults, opts, title = "opts") {
+  aopts(defaults, "defaults");
+  if (opts !== void 0)
+    aopts(opts, title);
+  const merged = Object.assign(/* @__PURE__ */ Object.create(null), defaults, opts);
+  return merged;
+}
+function createHasher(hashCons, info = {}) {
+  if (typeof hashCons !== "function")
+    throw new TypeError('"hashCons" expected function, got type=' + typeof hashCons);
+  info = checkOpts({}, info, "info");
+  const hashC = (msg, opts) => hashCons(opts).update(msg).digest();
+  const tmp = hashCons(void 0);
+  hashC.outputLen = tmp.outputLen;
+  hashC.blockLen = tmp.blockLen;
+  hashC.canXOF = tmp.canXOF;
+  hashC.create = (opts) => hashCons(opts);
+  Object.assign(hashC, info);
+  return Object.freeze(hashC);
+}
+
+// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/_md.js
+function Chi(a, b, c) {
+  return a & b ^ ~a & c;
+}
+function Maj(a, b, c) {
+  return a & b ^ a & c ^ b & c;
+}
+var HashMD = class {
+  blockLen;
+  outputLen;
+  canXOF = false;
+  padOffset;
+  isLE;
+  // For partial updates less than block size
+  buffer;
+  view;
+  finished = false;
+  length = 0;
+  pos = 0;
+  destroyed = false;
+  constructor(blockLen, outputLen, padOffset, isLE2) {
+    this.blockLen = blockLen;
+    this.outputLen = outputLen;
+    this.padOffset = padOffset;
+    this.isLE = isLE2;
+    this.buffer = new Uint8Array(blockLen);
+    this.view = createView2(this.buffer);
+  }
+  update(data) {
+    aexists2(this);
+    abytes2(data);
+    const { view, buffer, blockLen } = this;
+    const len = data.length;
+    let processed = false;
+    for (let pos = 0; pos < len; ) {
+      const take = Math.min(blockLen - this.pos, len - pos);
+      if (take === blockLen) {
+        const dataView = createView2(data);
+        for (; blockLen <= len - pos; pos += blockLen)
+          this.process(dataView, pos);
+        processed = true;
+        continue;
+      }
+      buffer.set(pos === 0 && take === len ? data : data.subarray(pos, pos + take), this.pos);
+      this.pos += take;
+      pos += take;
+      if (this.pos === blockLen) {
+        this.process(view, 0);
+        this.pos = 0;
+        processed = true;
+      }
+    }
+    this.length += data.length;
+    if (processed)
+      this.roundClean();
+    return this;
+  }
+  digestInto(out) {
+    aexists2(this);
+    aoutput(out, this);
+    this.finished = true;
+    const { buffer, view, blockLen, isLE: isLE2 } = this;
+    let { pos } = this;
+    buffer[pos++] = 128;
+    buffer.fill(0, pos);
+    if (this.padOffset > blockLen - pos) {
+      this.process(view, 0);
+      buffer.fill(0);
+    }
+    setU64FromNum(view, blockLen - 8, this.length * 8, isLE2);
+    this.process(view, 0);
+    this.roundClean();
+    const oview = out === buffer ? view : createView2(out);
+    const len = this.outputLen;
+    const outLen = len / 4;
+    const state = this.get();
+    if (len % 4 || outLen > state.length)
+      throw new Error("invalid outputLen");
+    for (let i2 = 0; i2 < outLen; i2++)
+      oview.setUint32(4 * i2, state[i2], isLE2);
+  }
+  digest() {
+    const { buffer, outputLen } = this;
+    this.digestInto(buffer);
+    const res = buffer.slice(0, outputLen);
+    this.destroy();
+    return res;
+  }
+  _cloneIntoMeta(to) {
+    const { buffer, length, finished, destroyed, pos } = this;
+    to.destroyed = destroyed;
+    to.finished = finished;
+    to.length = length;
+    to.pos = pos;
+    if (pos)
+      to.buffer.set(buffer);
     return to;
   }
   clone() {
@@ -2069,585 +2459,204 @@ var _SHA1 = class extends HashMD {
     return this._cloneIntoMeta(to);
   }
   process(view, offset) {
-    for (let i = 0; i < 16; i++, offset += 4)
-      SHA1_W[i] = view.getUint32(offset, false);
-    for (let i = 16; i < 80; i++)
-      SHA1_W[i] = rotl(SHA1_W[i - 3] ^ SHA1_W[i - 8] ^ SHA1_W[i - 14] ^ SHA1_W[i - 16], 1);
+    for (let i2 = 0; i2 < 16; i2++, offset += 4)
+      SHA1_W[i2] = view.getUint32(offset, false);
+    for (let i2 = 16; i2 < 80; i2++)
+      SHA1_W[i2] = rotl(SHA1_W[i2 - 3] ^ SHA1_W[i2 - 8] ^ SHA1_W[i2 - 14] ^ SHA1_W[i2 - 16], 1);
     let { A, B, C, D, E } = this;
-    for (let i = 0; i < 80; i++) {
+    for (let i2 = 0; i2 < 80; i2++) {
       let F, K2;
-      if (i < 20) {
+      if (i2 < 20) {
         F = Chi(B, C, D);
         K2 = 1518500249;
-      } else if (i < 40) {
+      } else if (i2 < 40) {
         F = B ^ C ^ D;
         K2 = 1859775393;
-      } else if (i < 60) {
+      } else if (i2 < 60) {
         F = Maj(B, C, D);
         K2 = 2400959708;
       } else {
-        F = B ^ C ^ D;
-        K2 = 3395469782;
-      }
-      const T = rotl(A, 5) + F + E + K2 + SHA1_W[i] | 0;
-      E = D;
-      D = C;
-      C = rotl(B, 30);
-      B = A;
-      A = T;
-    }
-    A = A + this.A | 0;
-    B = B + this.B | 0;
-    C = C + this.C | 0;
-    D = D + this.D | 0;
-    E = E + this.E | 0;
-    this.set(A, B, C, D, E);
-  }
-  roundClean() {
-    clean(SHA1_W);
-  }
-  destroy() {
-    this.destroyed = true;
-    this.set(0, 0, 0, 0, 0);
-    clean(this.buffer);
-  }
-};
-var sha1 = /* @__PURE__ */ createHasher(() => new _SHA1());
-var p32 = /* @__PURE__ */ Math.pow(2, 32);
-var K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i) => Math.floor(p32 * Math.abs(Math.sin(i + 1))));
-var MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);
-var MD5_W = /* @__PURE__ */ new Uint32Array(16);
-var MD5_SHIFTS = /* @__PURE__ */ (() => {
-  const S = [
-    [7, 12, 17, 22],
-    [5, 9, 14, 20],
-    [4, 11, 16, 23],
-    [6, 10, 15, 21]
-  ];
-  return Uint8Array.from({ length: 64 }, (_, i) => S[Math.floor(i / 16)][i % 4]);
-})();
-var _MD5 = class extends HashMD {
-  A = MD5_IV[0] | 0;
-  B = MD5_IV[1] | 0;
-  C = MD5_IV[2] | 0;
-  D = MD5_IV[3] | 0;
-  constructor() {
-    super(64, 16, 8, true);
-  }
-  get() {
-    const { A, B, C, D } = this;
-    return [A, B, C, D];
-  }
-  set(A, B, C, D) {
-    this.A = A | 0;
-    this.B = B | 0;
-    this.C = C | 0;
-    this.D = D | 0;
-  }
-  _cloneInto(to) {
-    (to ||= new this.constructor()).set(...this.get());
-    return this._cloneIntoMeta(to);
-  }
-  process(view, offset) {
-    for (let i = 0; i < 16; i++, offset += 4)
-      MD5_W[i] = view.getUint32(offset, true);
-    let { A, B, C, D } = this;
-    for (let i = 0; i < 64; i++) {
-      let F, g;
-      if (i < 16) {
-        F = Chi(B, C, D);
-        g = i;
-      } else if (i < 32) {
-        F = Chi(D, B, C);
-        g = (5 * i + 1) % 16;
-      } else if (i < 48) {
-        F = B ^ C ^ D;
-        g = (3 * i + 5) % 16;
-      } else {
-        F = C ^ (B | ~D);
-        g = 7 * i % 16;
-      }
-      F = F + A + K[i] + MD5_W[g];
-      A = D;
-      D = C;
-      C = B;
-      B = B + rotl(F, MD5_SHIFTS[i]);
-    }
-    A = A + this.A | 0;
-    B = B + this.B | 0;
-    C = C + this.C | 0;
-    D = D + this.D | 0;
-    this.set(A, B, C, D);
-  }
-  roundClean() {
-    clean(MD5_W);
-  }
-  destroy() {
-    this.destroyed = true;
-    this.set(0, 0, 0, 0);
-    clean(this.buffer);
-  }
-};
-var md5 = /* @__PURE__ */ createHasher(() => new _MD5());
-
-// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/hmac.js
-init_buffer();
-var _HMAC = class {
-  oHash;
-  iHash;
-  blockLen;
-  outputLen;
-  canXOF = false;
-  finished = false;
-  destroyed = false;
-  constructor(hash2, key2) {
-    ahash(hash2);
-    abytes(key2, void 0, "key");
-    this.iHash = hash2.create();
-    if (typeof this.iHash.update !== "function")
-      throw new Error("expected Hash instance");
-    this.blockLen = this.iHash.blockLen;
-    this.outputLen = this.iHash.outputLen;
-    const blockLen = this.blockLen;
-    const pad = new Uint8Array(blockLen);
-    pad.set(key2.length > blockLen ? hash2.create().update(key2).digest() : key2);
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54;
-    this.iHash.update(pad);
-    this.oHash = hash2.create();
-    for (let i = 0; i < pad.length; i++)
-      pad[i] ^= 54 ^ 92;
-    this.oHash.update(pad);
-    clean(pad);
-  }
-  update(buf) {
-    aexists(this);
-    this.iHash.update(buf);
-    return this;
-  }
-  digestInto(out) {
-    aexists(this);
-    aoutput(out, this);
-    this.finished = true;
-    const buf = out.subarray(0, this.outputLen);
-    this.iHash.digestInto(buf);
-    this.oHash.update(buf);
-    this.oHash.digestInto(buf);
-    this.destroy();
-  }
-  digest() {
-    const out = new Uint8Array(this.oHash.outputLen);
-    this.digestInto(out);
-    return out;
-  }
-  _cloneInto(to) {
-    to ||= Object.create(Object.getPrototypeOf(this), {});
-    const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
-    to = to;
-    to.finished = finished;
-    to.destroyed = destroyed;
-    to.blockLen = blockLen;
-    to.outputLen = outputLen;
-    to.canXOF = canXOF;
-    to.oHash = oHash._cloneInto(to.oHash);
-    to.iHash = iHash._cloneInto(to.iHash);
-    return to;
-  }
-  clone() {
-    return this._cloneInto();
-  }
-  destroy() {
-    this.destroyed = true;
-    this.oHash.destroy();
-    this.iHash.destroy();
-  }
-};
-var hmac = /* @__PURE__ */ (() => {
-  const hmac_ = ((hash2, key2, message) => new _HMAC(hash2, key2).update(message).digest());
-  hmac_.create = (hash2, key2) => new _HMAC(hash2, key2);
-  return hmac_;
-})();
-
-// node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/aes.js
-init_buffer();
-
-// node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/utils.js
-init_buffer();
-function isBytes2(a) {
-  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
-}
-var atitle2 = (title) => title ? `"${title}" ` : "";
-function anumber2(n, title = "") {
-  if (typeof n !== "number")
-    throw new TypeError(atitle2(title) + "expected number, got " + typeof n);
-  if (!Number.isSafeInteger(n) || n < 0)
-    throw new RangeError(atitle2(title) + "expected integer >= 0, got " + n);
-  return n;
-}
-function abytes2(value, length, title = "") {
-  if (isBytes2(value) && (length === void 0 || value.length === length))
-    return value;
-  if (length !== void 0)
-    anumber2(length, "length");
-  const bytes2 = isBytes2(value);
-  const ofLen = length !== void 0 ? ` of length ${length}` : "";
-  const got = bytes2 ? `length=${value.length}` : `type=${typeof value}`;
-  const message = atitle2(title) + "expected Uint8Array" + ofLen + ", got " + got;
-  if (!bytes2)
-    throw new TypeError(message);
-  throw new RangeError(message);
-}
-function u32(arr) {
-  return new Uint32Array(arr.buffer, arr.byteOffset, Math.floor(arr.byteLength / 4));
-}
-function clean2(...arrays) {
-  for (let i = 0; i < arrays.length; i++) {
-    arrays[i].fill(0);
-  }
-}
-var isLE = /* @__PURE__ */ (() => new Uint8Array(new Uint32Array([287454020]).buffer)[0] === 68)();
-function byteSwap(word) {
-  return word << 24 & 4278190080 | word << 8 & 16711680 | word >>> 8 & 65280 | word >>> 24 & 255;
-}
-function byteSwap32(arr) {
-  for (let i = 0; i < arr.length; i++) {
-    arr[i] = byteSwap(arr[i]);
-  }
-  return arr;
-}
-var swap32IfBE = isLE ? (u) => u : byteSwap32;
-function overlapBytes(a, b) {
-  if (!a.byteLength || !b.byteLength)
-    return false;
-  return a.buffer === b.buffer && // best we can do, may fail with an obscure Proxy
-  a.byteOffset < b.byteOffset + b.byteLength && // a starts before b end
-  b.byteOffset < a.byteOffset + a.byteLength;
-}
-function complexOverlapBytes(input, output) {
-  if (overlapBytes(input, output) && input.byteOffset < output.byteOffset)
-    throw new Error("complex overlap of input and output is not supported");
-}
-var wrapCipher = /* @__NO_SIDE_EFFECTS__ */ (params, constructor) => {
-  function wrappedCipher(key2, ...args) {
-    abytes2(key2, void 0, "key");
-    if (params.nonceLength !== void 0) {
-      const nonce = args[0];
-      abytes2(nonce, params.varSizeNonce ? void 0 : params.nonceLength, "nonce");
-    }
-    const tagl = params.tagLength;
-    const aadStart = params.nonceLength !== void 0 ? 1 : 0;
-    if (!params.withAAD) {
-      for (let i = aadStart; i < args.length; i++)
-        if (isBytes2(args[i]))
-          throw new Error("AAD not supported");
-    }
-    if (params.withAAD && args[aadStart] !== void 0)
-      abytes2(args[aadStart], void 0, "AAD");
-    const cipher = constructor(key2, ...args);
-    const checkOutput = (fnLength, output) => {
-      if (output !== void 0) {
-        if (fnLength !== 2)
-          throw new Error("cipher output not supported");
-        abytes2(output, void 0, "output");
-      }
-    };
-    let called = false;
-    const wrCipher = {
-      encrypt(data, output) {
-        if (called)
-          throw new Error("cannot encrypt() twice with same key + nonce");
-        called = true;
-        abytes2(data, void 0, "data");
-        checkOutput(cipher.encrypt.length, output);
-        return cipher.encrypt(data, output);
-      },
-      decrypt(data, output) {
-        abytes2(data, void 0, "data");
-        if (tagl && data.length < tagl)
-          throw new Error('"ciphertext" expected length >= tagLength=' + tagl);
-        checkOutput(cipher.decrypt.length, output);
-        return cipher.decrypt(data, output);
+        F = B ^ C ^ D;
+        K2 = 3395469782;
       }
-    };
-    return wrCipher;
+      const T = rotl(A, 5) + F + E + K2 + SHA1_W[i2] | 0;
+      E = D;
+      D = C;
+      C = rotl(B, 30);
+      B = A;
+      A = T;
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    E = E + this.E | 0;
+    this.set(A, B, C, D, E);
   }
-  Object.assign(wrappedCipher, params);
-  return wrappedCipher;
-};
-function getOutput(expectedLength, out, onlyAligned = true) {
-  if (out === void 0)
-    return new Uint8Array(expectedLength);
-  abytes2(out, expectedLength, "output");
-  if (onlyAligned && !isAligned32(out))
-    throw new Error("invalid output, must be aligned");
-  return out;
-}
-function isAligned32(bytes2) {
-  return bytes2.byteOffset % 4 === 0;
-}
-function copyBytes(bytes2) {
-  return Uint8Array.from(abytes2(bytes2));
-}
-
-// node_modules/.pnpm/@noble+ciphers@2.4.0/node_modules/@noble/ciphers/aes.js
-var BLOCK_SIZE = 16;
-var POLY = 283;
-function validateKeyLength(key2) {
-  if (![16, 24, 32].includes(key2.length))
-    throw new Error('"aes key" expected Uint8Array of length 16/24/32, got length=' + key2.length);
-}
-function mul2(n) {
-  return n << 1 ^ POLY & -(n >> 7);
-}
-function mul(a, b) {
-  let res = 0;
-  for (; b > 0; b >>= 1) {
-    res ^= a & -(b & 1);
-    a = mul2(a);
+  roundClean() {
+    clean2(SHA1_W);
   }
-  return res;
-}
-var sbox = /* @__PURE__ */ (() => {
-  const t = new Uint8Array(256);
-  for (let i = 0, x = 1; i < 256; i++, x ^= mul2(x))
-    t[i] = x;
-  const box = new Uint8Array(256);
-  box[0] = 99;
-  for (let i = 0; i < 255; i++) {
-    let x = t[255 - i];
-    x |= x << 8;
-    box[t[i]] = (x ^ x >> 4 ^ x >> 5 ^ x >> 6 ^ x >> 7 ^ 99) & 255;
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0, 0);
+    clean2(this.buffer);
   }
-  clean2(t);
-  return box;
+};
+var sha1 = /* @__PURE__ */ createHasher(() => new _SHA1());
+var p32 = /* @__PURE__ */ Math.pow(2, 32);
+var K = /* @__PURE__ */ Array.from({ length: 64 }, (_, i2) => Math.floor(p32 * Math.abs(Math.sin(i2 + 1))));
+var MD5_IV = /* @__PURE__ */ SHA1_IV.slice(0, 4);
+var MD5_W = /* @__PURE__ */ new Uint32Array(16);
+var MD5_SHIFTS = /* @__PURE__ */ (() => {
+  const S = [
+    [7, 12, 17, 22],
+    [5, 9, 14, 20],
+    [4, 11, 16, 23],
+    [6, 10, 15, 21]
+  ];
+  return Uint8Array.from({ length: 64 }, (_, i2) => S[Math.floor(i2 / 16)][i2 % 4]);
 })();
-var invSbox = /* @__PURE__ */ sbox.map((_, j) => sbox.indexOf(j));
-var rotr32_8 = (n) => n << 24 | n >>> 8;
-var rotl32_8 = (n) => n << 8 | n >>> 24;
-function genTtable(sbox2, fn) {
-  if (sbox2.length !== 256)
-    throw new Error("wrong sbox length");
-  const T0 = new Uint32Array(256).map((_, j) => fn(sbox2[j]));
-  const T1 = T0.map(rotl32_8);
-  const T2 = T1.map(rotl32_8);
-  const T3 = T2.map(rotl32_8);
-  const T01 = new Uint32Array(256 * 256);
-  const T23 = new Uint32Array(256 * 256);
-  const sbox22 = new Uint16Array(256 * 256);
-  for (let i = 0; i < 256; i++) {
-    for (let j = 0; j < 256; j++) {
-      const idx = i * 256 + j;
-      T01[idx] = T0[i] ^ T1[j];
-      T23[idx] = T2[i] ^ T3[j];
-      sbox22[idx] = sbox2[i] << 8 | sbox2[j];
-    }
+var _MD5 = class extends HashMD {
+  A = MD5_IV[0] | 0;
+  B = MD5_IV[1] | 0;
+  C = MD5_IV[2] | 0;
+  D = MD5_IV[3] | 0;
+  constructor() {
+    super(64, 16, 8, true);
   }
-  return { sbox: sbox2, sbox2: sbox22, T0, T1, T2, T3, T01, T23 };
-}
-var tableEncoding = /* @__PURE__ */ genTtable(sbox, (s) => mul(s, 3) << 24 | s << 16 | s << 8 | mul(s, 2));
-var tableDecoding = /* @__PURE__ */ genTtable(invSbox, (s) => mul(s, 11) << 24 | mul(s, 13) << 16 | mul(s, 9) << 8 | mul(s, 14));
-var xPowers = /* @__PURE__ */ (() => {
-  const p = new Uint8Array(16);
-  for (let i = 0, x = 1; i < 16; i++, x = mul2(x))
-    p[i] = x;
-  return p;
-})();
-function expandKeyLE(key2) {
-  abytes2(key2);
-  const len = key2.length;
-  validateKeyLength(key2);
-  const { sbox2 } = tableEncoding;
-  const toClean = [];
-  if (!isLE || !isAligned32(key2))
-    toClean.push(key2 = copyBytes(key2));
-  const k32 = swap32IfBE(u32(key2));
-  const Nk = k32.length;
-  const subByte = (n) => applySbox(sbox2, n, n, n, n);
-  const xk = new Uint32Array(len + 28);
-  xk.set(k32);
-  for (let i = Nk; i < xk.length; i++) {
-    let t = xk[i - 1];
-    if (i % Nk === 0)
-      t = subByte(rotr32_8(t)) ^ xPowers[i / Nk - 1];
-    else if (Nk > 6 && i % Nk === 4)
-      t = subByte(t);
-    xk[i] = xk[i - Nk] ^ t;
+  get() {
+    const { A, B, C, D } = this;
+    return [A, B, C, D];
   }
-  clean2(...toClean);
-  return xk;
-}
-function expandKeyDecLE(key2) {
-  const encKey = expandKeyLE(key2);
-  const xk = encKey.slice();
-  const Nk = encKey.length;
-  const { sbox2 } = tableEncoding;
-  const { T0, T1, T2, T3 } = tableDecoding;
-  for (let i = 0; i < Nk; i += 4) {
-    for (let j = 0; j < 4; j++)
-      xk[i + j] = encKey[Nk - i - 4 + j];
+  set(A, B, C, D) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
   }
-  clean2(encKey);
-  for (let i = 4; i < Nk - 4; i++) {
-    const x = xk[i];
-    const w = applySbox(sbox2, x, x, x, x);
-    xk[i] = T0[w & 255] ^ T1[w >>> 8 & 255] ^ T2[w >>> 16 & 255] ^ T3[w >>> 24];
+  _cloneInto(to) {
+    (to ||= new this.constructor()).set(...this.get());
+    return this._cloneIntoMeta(to);
   }
-  return xk;
-}
-function apply0123(T01, T23, s0, s1, s2, s3) {
-  return T01[s0 << 8 & 65280 | s1 >>> 8 & 255] ^ T23[s2 >>> 8 & 65280 | s3 >>> 24 & 255];
-}
-function applySbox(sbox2, s0, s1, s2, s3) {
-  return sbox2[s0 & 255 | s1 & 65280] | sbox2[s2 >>> 16 & 255 | s3 >>> 16 & 65280] << 16;
-}
-function encrypt(xk, s0, s1, s2, s3) {
-  const { sbox2, T01, T23 } = tableEncoding;
-  let k = 0;
-  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
-  const rounds = xk.length / 4 - 2;
-  for (let i = 0; i < rounds; i++) {
-    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s1, s2, s3);
-    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s2, s3, s0);
-    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s3, s0, s1);
-    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s0, s1, s2);
-    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  process(view, offset) {
+    for (let i2 = 0; i2 < 16; i2++, offset += 4)
+      MD5_W[i2] = view.getUint32(offset, true);
+    let { A, B, C, D } = this;
+    for (let i2 = 0; i2 < 64; i2++) {
+      let F, g;
+      if (i2 < 16) {
+        F = Chi(B, C, D);
+        g = i2;
+      } else if (i2 < 32) {
+        F = Chi(D, B, C);
+        g = (5 * i2 + 1) % 16;
+      } else if (i2 < 48) {
+        F = B ^ C ^ D;
+        g = (3 * i2 + 5) % 16;
+      } else {
+        F = C ^ (B | ~D);
+        g = 7 * i2 % 16;
+      }
+      F = F + A + K[i2] + MD5_W[g];
+      A = D;
+      D = C;
+      C = B;
+      B = B + rotl(F, MD5_SHIFTS[i2]);
+    }
+    A = A + this.A | 0;
+    B = B + this.B | 0;
+    C = C + this.C | 0;
+    D = D + this.D | 0;
+    this.set(A, B, C, D);
   }
-  const t0 = xk[k++] ^ applySbox(sbox2, s0, s1, s2, s3);
-  const t1 = xk[k++] ^ applySbox(sbox2, s1, s2, s3, s0);
-  const t2 = xk[k++] ^ applySbox(sbox2, s2, s3, s0, s1);
-  const t3 = xk[k++] ^ applySbox(sbox2, s3, s0, s1, s2);
-  return { s0: t0, s1: t1, s2: t2, s3: t3 };
-}
-function decrypt(xk, s0, s1, s2, s3) {
-  const { sbox2, T01, T23 } = tableDecoding;
-  let k = 0;
-  s0 ^= xk[k++], s1 ^= xk[k++], s2 ^= xk[k++], s3 ^= xk[k++];
-  const rounds = xk.length / 4 - 2;
-  for (let i = 0; i < rounds; i++) {
-    const t02 = xk[k++] ^ apply0123(T01, T23, s0, s3, s2, s1);
-    const t12 = xk[k++] ^ apply0123(T01, T23, s1, s0, s3, s2);
-    const t22 = xk[k++] ^ apply0123(T01, T23, s2, s1, s0, s3);
-    const t32 = xk[k++] ^ apply0123(T01, T23, s3, s2, s1, s0);
-    s0 = t02, s1 = t12, s2 = t22, s3 = t32;
+  roundClean() {
+    clean2(MD5_W);
   }
-  const t0 = xk[k++] ^ applySbox(sbox2, s0, s3, s2, s1);
-  const t1 = xk[k++] ^ applySbox(sbox2, s1, s0, s3, s2);
-  const t2 = xk[k++] ^ applySbox(sbox2, s2, s1, s0, s3);
-  const t3 = xk[k++] ^ applySbox(sbox2, s3, s2, s1, s0);
-  return { s0: t0, s1: t1, s2: t2, s3: t3 };
-}
-function validateBlockDecrypt(data, dst) {
-  abytes2(data);
-  if (data.length % BLOCK_SIZE !== 0) {
-    throw new Error("ciphertext must be multiple of " + BLOCK_SIZE);
+  destroy() {
+    this.destroyed = true;
+    this.set(0, 0, 0, 0);
+    clean2(this.buffer);
   }
-  if (dst !== void 0) {
-    getOutput(data.length, dst);
-    complexOverlapBytes(data, dst);
+};
+var md5 = /* @__PURE__ */ createHasher(() => new _MD5());
+
+// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/hmac.js
+init_buffer();
+var _HMAC = class {
+  oHash;
+  iHash;
+  blockLen;
+  outputLen;
+  canXOF = false;
+  finished = false;
+  destroyed = false;
+  constructor(hash2, key2) {
+    ahash(hash2);
+    abytes2(key2, void 0, "key");
+    this.iHash = hash2.create();
+    if (typeof this.iHash.update !== "function")
+      throw new Error("expected Hash instance");
+    this.blockLen = this.iHash.blockLen;
+    this.outputLen = this.iHash.outputLen;
+    const blockLen = this.blockLen;
+    const pad = new Uint8Array(blockLen);
+    pad.set(key2.length > blockLen ? hash2.create().update(key2).digest() : key2);
+    for (let i2 = 0; i2 < pad.length; i2++)
+      pad[i2] ^= 54;
+    this.iHash.update(pad);
+    this.oHash = hash2.create();
+    for (let i2 = 0; i2 < pad.length; i2++)
+      pad[i2] ^= 54 ^ 92;
+    this.oHash.update(pad);
+    clean2(pad);
   }
-}
-function validateBlockEncrypt(plaintext, pkcs5, dst) {
-  abytes2(plaintext);
-  let outLen = plaintext.length;
-  const remaining = outLen % BLOCK_SIZE;
-  if (!pkcs5 && remaining !== 0)
-    throw new Error("plaintext must be multiple of " + BLOCK_SIZE);
-  if (pkcs5) {
-    let left = BLOCK_SIZE - remaining;
-    if (!left)
-      left = BLOCK_SIZE;
-    outLen = outLen + left;
+  update(buf) {
+    aexists2(this);
+    this.iHash.update(buf);
+    return this;
+  }
+  digestInto(out) {
+    aexists2(this);
+    aoutput(out, this);
+    this.finished = true;
+    const buf = out.subarray(0, this.outputLen);
+    this.iHash.digestInto(buf);
+    this.oHash.update(buf);
+    this.oHash.digestInto(buf);
+    this.destroy();
+  }
+  digest() {
+    const out = new Uint8Array(this.oHash.outputLen);
+    this.digestInto(out);
+    return out;
   }
-  if (dst !== void 0) {
-    getOutput(outLen, dst);
-    complexOverlapBytes(plaintext, dst);
+  _cloneInto(to) {
+    to ||= Object.create(Object.getPrototypeOf(this), {});
+    const { oHash, iHash, finished, destroyed, blockLen, outputLen, canXOF } = this;
+    to = to;
+    to.finished = finished;
+    to.destroyed = destroyed;
+    to.blockLen = blockLen;
+    to.outputLen = outputLen;
+    to.canXOF = canXOF;
+    to.oHash = oHash._cloneInto(to.oHash);
+    to.iHash = iHash._cloneInto(to.iHash);
+    return to;
   }
-  return outLen;
-}
-function prepareBlockEncrypt(plaintext, outLen, dst) {
-  if (dst === void 0)
-    dst = new Uint8Array(outLen);
-  if (!isLE || !isAligned32(plaintext))
-    plaintext = copyBytes(plaintext);
-  const o = u32(dst);
-  return { b: plaintext, o, out: dst };
-}
-function validatePKCS(data, pkcs5) {
-  if (!pkcs5)
-    return data;
-  const len = data.length;
-  if (len === 0)
-    throw new Error("pkcs7: empty ciphertext not allowed");
-  const lastByte = data[len - 1];
-  let valid = 1;
-  valid &= lastByte - 1 >>> 31 ^ 1;
-  valid &= 16 - lastByte >>> 31 ^ 1;
-  for (let i = 0; i < 16; i++) {
-    const shouldCheck = i - lastByte >>> 31;
-    const eq = (data[len - 1 - i] ^ lastByte) === 0 ? 1 : 0;
-    valid &= eq | shouldCheck ^ 1;
+  clone() {
+    return this._cloneInto();
   }
-  if (!valid)
-    throw new Error("aes: bad decrypt");
-  return data.subarray(0, len - lastByte);
-}
-function padPCKS(left) {
-  const tmp = new Uint8Array(16);
-  const tmp32 = u32(tmp);
-  tmp.set(left);
-  const paddingByte = BLOCK_SIZE - left.length;
-  for (let i = BLOCK_SIZE - paddingByte; i < BLOCK_SIZE; i++)
-    tmp[i] = paddingByte;
-  return tmp32;
-}
-var ecb = /* @__PURE__ */ wrapCipher({ blockSize: 16 }, function aesecb(key2, opts = {}) {
-  const pkcs5 = !opts.disablePadding;
-  return {
-    encrypt(plaintext, dst) {
-      const outLen = validateBlockEncrypt(plaintext, pkcs5, dst);
-      const xk = expandKeyLE(key2);
-      const { b: input, o, out: _out } = prepareBlockEncrypt(plaintext, outLen, dst);
-      const b = u32(input);
-      swap32IfBE(b);
-      let i = 0;
-      for (; i + 4 <= b.length; ) {
-        const { s0, s1, s2, s3 } = encrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);
-        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
-      }
-      if (pkcs5) {
-        const tmp32 = padPCKS(plaintext.subarray(i * 4));
-        swap32IfBE(tmp32);
-        const { s0, s1, s2, s3 } = encrypt(xk, tmp32[0], tmp32[1], tmp32[2], tmp32[3]);
-        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
-        clean2(tmp32);
-      }
-      swap32IfBE(o);
-      clean2(xk);
-      if (input !== plaintext)
-        clean2(input);
-      return _out;
-    },
-    decrypt(ciphertext, dst) {
-      validateBlockDecrypt(ciphertext, dst);
-      const xk = expandKeyDecLE(key2);
-      if (dst === void 0)
-        dst = new Uint8Array(ciphertext.length);
-      const toClean = [xk];
-      if (!isLE || !isAligned32(ciphertext))
-        toClean.push(ciphertext = copyBytes(ciphertext));
-      const b = u32(ciphertext);
-      const o = u32(dst);
-      swap32IfBE(b);
-      for (let i = 0; i + 4 <= b.length; ) {
-        const { s0, s1, s2, s3 } = decrypt(xk, b[i + 0], b[i + 1], b[i + 2], b[i + 3]);
-        o[i++] = s0, o[i++] = s1, o[i++] = s2, o[i++] = s3;
-      }
-      swap32IfBE(o);
-      clean2(...toClean);
-      return validatePKCS(dst, pkcs5);
-    }
-  };
-});
+  destroy() {
+    this.destroyed = true;
+    this.oHash.destroy();
+    this.iHash.destroy();
+  }
+};
+var hmac = /* @__PURE__ */ (() => {
+  const hmac_ = ((hash2, key2, message) => new _HMAC(hash2, key2).update(message).digest());
+  hmac_.create = (hash2, key2) => new _HMAC(hash2, key2);
+  return hmac_;
+})();
 
 // node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/browser.js
 init_buffer();
@@ -2728,13 +2737,13 @@ var fdeb = new u82([
 var clim = new u82([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]);
 var freb = function(eb, start) {
   var b = new u16(31);
-  for (var i = 0; i < 31; ++i) {
-    b[i] = start += 1 << eb[i - 1];
+  for (var i2 = 0; i2 < 31; ++i2) {
+    b[i2] = start += 1 << eb[i2 - 1];
   }
   var r = new i32(b[30]);
-  for (var i = 1; i < 30; ++i) {
-    for (var j = b[i]; j < b[i + 1]; ++j) {
-      r[j] = j - b[i] << 5 | i;
+  for (var i2 = 1; i2 < 30; ++i2) {
+    for (var j = b[i2]; j < b[i2 + 1]; ++j) {
+      r[j] = j - b[i2] << 5 | i2;
     }
   }
   return { b, r };
@@ -2757,25 +2766,25 @@ var x;
 var i;
 var hMap = (function(cd, mb, r) {
   var s = cd.length;
-  var i = 0;
+  var i2 = 0;
   var l = new u16(mb);
-  for (; i < s; ++i) {
-    if (cd[i])
-      ++l[cd[i] - 1];
+  for (; i2 < s; ++i2) {
+    if (cd[i2])
+      ++l[cd[i2] - 1];
   }
   var le = new u16(mb);
-  for (i = 1; i < mb; ++i) {
-    le[i] = le[i - 1] + l[i - 1] << 1;
+  for (i2 = 1; i2 < mb; ++i2) {
+    le[i2] = le[i2 - 1] + l[i2 - 1] << 1;
   }
   var co;
   if (r) {
     co = new u16(1 << mb);
     var rvb = 15 - mb;
-    for (i = 0; i < s; ++i) {
-      if (cd[i]) {
-        var sv = i << 4 | cd[i];
-        var r_1 = mb - cd[i];
-        var v = le[cd[i] - 1]++ << r_1;
+    for (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        var sv = i2 << 4 | cd[i2];
+        var r_1 = mb - cd[i2];
+        var v = le[cd[i2] - 1]++ << r_1;
         for (var m = v | (1 << r_1) - 1; v <= m; ++v) {
           co[rev[v] >> rvb] = sv;
         }
@@ -2783,9 +2792,9 @@ var hMap = (function(cd, mb, r) {
     }
   } else {
     co = new u16(s);
-    for (i = 0; i < s; ++i) {
-      if (cd[i]) {
-        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+    for (i2 = 0; i2 < s; ++i2) {
+      if (cd[i2]) {
+        co[i2] = rev[le[cd[i2] - 1]++] >> 15 - cd[i2];
       }
     }
   }
@@ -2812,9 +2821,9 @@ var flrm = /* @__PURE__ */ hMap(flt, 9, 1);
 var fdrm = /* @__PURE__ */ hMap(fdt, 5, 1);
 var max = function(a) {
   var m = a[0];
-  for (var i = 1; i < a.length; ++i) {
-    if (a[i] > m)
-      m = a[i];
+  for (var i2 = 1; i2 < a.length; ++i2) {
+    if (a[i2] > m)
+      m = a[i2];
   }
   return m;
 };
@@ -2907,28 +2916,28 @@ var inflt = function(dat, st, buf, dict) {
         pos += 14;
         var ldt = new u82(tl);
         var clt = new u82(19);
-        for (var i = 0; i < hcLen; ++i) {
-          clt[clim[i]] = bits(dat, pos + i * 3, 7);
+        for (var i2 = 0; i2 < hcLen; ++i2) {
+          clt[clim[i2]] = bits(dat, pos + i2 * 3, 7);
         }
         pos += hcLen * 3;
         var clb = max(clt), clbmsk = (1 << clb) - 1;
         var clm = hMap(clt, clb, 1);
-        for (var i = 0; i < tl; ) {
+        for (var i2 = 0; i2 < tl; ) {
           var r = clm[bits(dat, pos, clbmsk)];
           pos += r & 15;
           var s = r >> 4;
           if (s < 16) {
-            ldt[i++] = s;
+            ldt[i2++] = s;
           } else {
             var c = 0, n = 0;
             if (s == 16)
-              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 1];
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i2 - 1];
             else if (s == 17)
               n = 3 + bits(dat, pos, 7), pos += 3;
             else if (s == 18)
               n = 11 + bits(dat, pos, 127), pos += 7;
             while (n--)
-              ldt[i++] = c;
+              ldt[i2++] = c;
           }
         }
         var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
@@ -2966,8 +2975,8 @@ var inflt = function(dat, st, buf, dict) {
       } else {
         var add = sym - 254;
         if (sym > 264) {
-          var i = sym - 257, b = fleb[i];
-          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          var i2 = sym - 257, b = fleb[i2];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i2];
           pos += b;
         }
         var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
@@ -3058,8 +3067,7 @@ var inflateRawSync = (data, options) => {
   const output = import_buffer.Buffer.alloc(options.maxOutputLength);
   let length = 0;
   const stream = new Inflate((chunk) => {
-    if (chunk.length > output.length - length)
-      throw new RangeError("Inflated data exceeds declared size");
+    if (chunk.length > output.length - length) throw new RangeError("Inflated data exceeds declared size");
     output.set(chunk, length);
     length += chunk.length;
   });
@@ -3076,6 +3084,9 @@ var readFile = nodeOnly;
 var writeFile = nodeOnly;
 var readFileSync = nodeOnly;
 
+// src/nitro/banner.ts
+init_buffer();
+
 // src/nitro/binary.ts
 init_buffer();
 var DEFAULT_MAX_SIZE = 1073741824;
@@ -3085,15 +3096,11 @@ var bytes = (value, name = "input") => {
 };
 var range = (buffer, offset, size, name = "binary data") => {
   if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(size) || offset < 0 || size < 0 || offset + size > buffer.length) {
-    throw new RangeError(
-      `Invalid ${name} range: offset=${offset}, size=${size}, available=${buffer.length}`
-    );
+    throw new RangeError(`Invalid ${name} range: offset=${offset}, size=${size}, available=${buffer.length}`);
   }
   return buffer.subarray(offset, offset + size);
 };
-var align = (value, alignment = 512) => {
-  return Math.ceil(value / alignment) * alignment;
-};
+var align = (value, alignment = 512) => Math.ceil(value / alignment) * alignment;
 var BinaryWriter = class {
   maxSize;
   buffer;
@@ -3117,8 +3124,7 @@ var BinaryWriter = class {
   }
   write(data) {
     data = bytes(data);
-    if (!Number.isSafeInteger(this.position) || this.position < 0)
-      throw new RangeError("Invalid writer position");
+    if (!Number.isSafeInteger(this.position) || this.position < 0) throw new RangeError("Invalid writer position");
     this.ensure(this.position + data.length);
     bytes(data).copy(this.buffer, this.position);
     this.position += data.length;
@@ -3139,260 +3145,31 @@ var BinaryWriter = class {
   }
 };
 
-// src/nitro/header.ts
-init_buffer();
-
 // src/nitro/crc.ts
-init_buffer();
-var table16 = new Uint16Array(256);
-var table32 = new Uint32Array(256);
-for (let i = 0; i < 256; i++) {
-  let a = i, b = i;
-  for (let bit = 0; bit < 8; bit++) {
-    a = a >>> 1 ^ (a & 1 ? 40961 : 0);
-    b = b >>> 1 ^ (b & 1 ? 3988292384 : 0);
-  }
-  table16[i] = a;
-  table32[i] = b;
-}
-var crc16 = (data, initial = 65535) => {
-  let crc = initial;
-  for (const byte of data) crc = crc >>> 8 ^ table16[(crc ^ byte) & 255];
-  return crc;
-};
-var crc32 = (data) => {
-  let crc = 4294967295;
-  for (const byte of data) crc = crc >>> 8 ^ table32[(crc ^ byte) & 255];
-  return (crc ^ 4294967295) >>> 0;
-};
-
-// src/nitro/crypto.ts
-init_buffer();
-var KEY1 = import_buffer.Buffer.from(
-  "99D5205F5744F5B96E19A4D99E6A5A94D8AEF1EB4175E23A9382D03233EE31D5CC57619A3706A21B793972F555AEF6BE5F1B69FBE59DF1E9CE2CD9A15E3205E6FED3FECFD462040D8BF5ECB72B6079BB1295310D6E3FDA2B8884F0F13D127E254522F1BB24061A0611ADDF288B6481342BEB332999AAF2BD9C14959D9FF7F58C7297A1299DD15FCF664D071ADED34A4B85C9A7A31795053A3D490ABF0A898BA24A8249DD2790F10BE9EB1C6A83764505BA817061173F4BDEAECFAB3957F23A564811AD8A40E1453FFA9B0254CAA693FBEF4DFE6FA3D8879C08BAD5486A8D2DFD6E15F874BDBE528B18228A9EFB7437071B366C4A19BA4262B97991107B676596FE0223E8EE998C773E5C86644D6D7886A54F65E21EB2DF5A0AD07E0814B071ACBDDB831CB9D7A162CDC6637C5269C3E6BF75CE12445D2104FAFBD33C381163D4958541494609F2084311DC1F76C0156D1F3C6370EA87806CC3BD638BC2372137DCEE09232E376A4D7390F75030AC1C92041023914FD207AA683E4F9AC964606AC81421F3D62241124424CFE68A56DD0D534DE1851E8C525A9C1984C20357F16FE300BE58F64CEDD521649C1FBE55033C4ADCFFAAC9DAE05D5EBFE6DEF5D8B1F8FF36B3B9626795DB315F37ED4C70679990B518316C3D9999E442DAD3254213A0AED7706CB155CFC7D746D54361173D4428E93385D5D0A293AA25121FFBC50B46F597765645A6BE87B1946BE8B1FE3399AE1F3E6C39711D09009037E4103E7574FF8C833BB0F1B0F90105474295F1D6AC7E38E69E9574263FB4685018D04330B44C4BE368BFE54DB6958B0AA074253277CFA1F72CD871135AABEAC951E80DEEEFE9937E19A71E433881162CA148E373CC29216CD35DCEA0D9617143A01513B56492CF2A19DCADB7A59F8665F81A9FE7FBF7FDB8136C27DB6FDF351CF78D2C5B9B12AB386406CCDE31E84E751164E3FAEAEB3454C2AD3F34EB932C7D26369D56F35AE1F6B398634A9E3283E49A84607D902E130EEE934B36A285EC1638E8880602BFF0A03AEDD76A9A73E157CFF844B8DC2E2359D1DF9552719961A04BD57F6E78BAA9C530D34086329D320C9C37B7022FBA5498A9C41304C98DBEC8E75D97502E93D622590C27BC2292E0A7200F936F7F4C9FD3B5A62A0B7467497D1026CBD1C58671E78CA09CE95BB21AF601EE8C9E5E83F21ADBE6E5EA845976D27CF68DA5493648C21652BB83A374B9070C3BFF6128E161E9E4EF6E15AA4EBAE85D0596BB3256B0FB72520F0EC84225657689AFF2DE1027F0014B74A79707D5265454091F820A867D30390EB3269B0B57BB360631AFFD79FCD930102B0CB3E19BD77BDC5FEFD2F813454D4775BD46963C7E75F33EB567C59A3BB05B296BDE805BC81505B131B6CE49DDAD84B5AE60DC67313430FE4EBD802FA6BF63392186D9357F1668220554E990268C076C51A43155D70907A83E2E5366C1F8F27BC4F258CFF187C5A2E7278F308758A064622318B9887CFACEC498AEAD17CC4A5BF3E948D556D30DF2C892738CDBD72F56AC81F992694DC632F6E6C08D21E276806111BCDC6C93AF19699BD0BFB9319F0267A351EE8306227B0CAB494240B8D5017DCE5EF7555339C59946D8879FBAF764B4E39AFAA16D90681030CA8A54A79F60C319F56B0D7A5198E6984351B4D635E94FC3DF0F7BD62F5CBD3A156119F14BCBAADC6D64C9D3C61E56EF384C50718675CC0D0D4EE928F6065D701BAAD345CFA839AC95A62EB4E422D474A8375F487A04CCA54C40D828B428080D1C725241F07D47193A534E5884626B93B58A81214E0DDCB43FA2C6FCC92B40DA3804E95E5A866B0C22258568118D7C921D95554DAB8EBBDAA6E6B751B6325A0541DD052A0A5650911747CCC9E67EB5614ADB736751C833F5DA6E742E54C3370D6DAF08E8158A5FE25921CDA8DE0C065A776B5FDB18653EC850DE78E0B882B35D4E7232074FC13423BA96B7674EA4281E3462EB2D6A70E92F42C4704E5A319CF95B4728AADA716F381FB378C4926B1C9EF6359AB74D0EBFCC1829410348355D55D02BC629AF5C6074698E5E9B7CD4BD7B44647D3F925D69B61F004BD48335CF7E644E17AE8DD52E9A28124E2E2B49085CAEC64685AE41611E6F82D25137161F0BF659A49ACA5AAF0DD4338B2063F184805CCBCF08B4B9D31605BD6283319B5651989FBAB25BAAB2226B2CB5D448FA632B5F58FA61FA6409BB38E0B89D9260A80D676F0E37F50D019FC277D4FEECF1733039E07DF56198E42C2855045655DB2F6BECE55806B664806A2A1A4E5B0FD8C40A2E5219D962F53048BE8C7B4F389BA2C3AFC9D3C7C1624186B96121576F994FC1BACE7BB53B4D5E8A8B44575F135F706D5B2947DC38E2EC045565122AE81743E18EDD2AB3E294F7096E5CE6EB8AF86D89495448F52FADBFEA944BCAFC3987825F8A01F275F2E671D6D842DEF12D1D28A6887EA3A0471D30D9A371DF491CCB01F836B1F2F022585D456BBDA0BBB28842C78C28CE93E8906308907C893CF57DB7042D4F555116FD7E79E8BEC1F212D4F8B4840523A0CCD22BFDE1ABAD0DD1556C2341944D77374F05280CBF17B312676C8CC35AF741842A6DD09412272CB4ED9C4DEC478297D567B91B9DC055077EE58EE2A8E73E12E40E3A2A455534A2F92D5A1BAB527C83105F55D2F15A432BC6A7A4891595E8B44B9DF875E39F60785BD6E60D44E62106BD472253A400AD8D43138539F7AAFC38AF7BEDFCE42B5450984CFC8580F7DF3C8022E194DADE24C6B07A3938DC0FA1A7F4F96F6318578B84412A2ED453F2D9000FD0DD996E19A60AD0EC5B5824ABC0CB0665EC1A1338940A67032F3FF7E377447733C61439D0E3C0A20879BB409957410B0190CDE1CC4867DBB3AF8874F34C828F72B1B52329C4126C19FC8E46A49CC4256587D36DBE8A93110338ED832BF346A493EA3B53851DCED4F1088327EDFC9B1A18BCF98BAEDC24AB5038E9724B1022177B465DAB5964F340AEF8BBE5C8F926034E557DEBEBFEF739E6E00A11BE2E28FF98EDC0C9425642C3FD00F6AF87A25B013F329247959A72A5323DAE6BD09B07D24992E3784AFAA1067DF241CF77740414B20C86846416D5BB51A1E56FF1D1F2E2F75F58204DB857C7CFDDC5D8BE763DF65F7EE72A8B88241B383F0E412377F5F04BD40C1FFAA40B805FCF45F6E0DA2F345953FB203C52625E35B562FE8B6063E3865A151A6ED14745BC32B4EB6738ABE46E333AB5EDA3AD67E04E4195EE626271261D31EF6230AFD782ACC2DC0504F59707BF11592307C06402E897E53EAF18AC59A68B4A33901C6E7C9C207E4C3C3E6164BBC56B7C7E3E9FC54C9FEA73F5D789C04CF4FBF42DEC141B51D5C112C810DF0B4A8B9CBC93456A3E3E7DC1A9BACDC1B407E4E1688643B26D38F3FB0C5C663771DE56EF6EA0104065A798F7D0BE0EC83736EC10CA7C9CAB841E051776021C4F52AA5FC1C6A056B9D80484444DA759D8DE60E6380E058F03E13B6D8104336F300BCE69052133FB26BB897DB6AE877E5107E0ACF7960A6BF9C45C1DE44447B85EFAE3788455424B485EF77D4735861D2B430503EC8AB81E063C760C481A43A7B78AED1E13C643EE10EFDBECFB3C83B29544EFD854514E2D11441DFB36591E7A34C1C3CA570061EA67A5169B55D055E17FD936D24076AEDC01CEB07A83D5CB2098EC6BC1729234F3825737628A32360C9043AEAE5C9B788E136502FD6871C1FEB031A02482B0C3B17969A7F5D2EBD082C032DC9EC7263C6D8D98C1BB22D4D00F33EC3EB9CCE1DC6A4C7736141CF9BF819F285F71853229907548C4B34ACED8448F142FFD4057EFAA0875D946D1D66E32551FC318FE841FFC84D5FF715E1B48C386950E280827D33883717B4C8063549A56B0ACCF80CA3109EFFEF3BEAF247EA6FE533FC28D4A3368D122A666AD7BEADEB643B0A1259500A33F7546141144ECD795BC92F04FA916536297602A0F41F17124BEEE947F08CD6093B3855B07003FD80F28839AD1699FD1DA2EC39001A2B96B4E2A669DDAAEA6EA2AD3682F0C0C9CD28C4AEDE29E57659D0987A3B4C4325DC9D4322BB1E0711E644DE69071E31E40ED7DF3840EEDC87876AEC0712772BB05EA0264FBF3486BB542933FED9F1353D2F7FE2AEC1D4725DB3C9186C68EF011FD237436F7A4F59E7A7E535044D447CAD3EB386DE6D971947F4AC6694B11F452EA22FE8AB036678B59E8E6802AEB650413EEECDC9E5FB1EC056A59E69F5E596B89BFF71ACA44F95B6A718503E42962E0706F41C4CFB2B1CCE37EA607A887E77F8493DB524B6CEC7EDDD4244810699F046074E64818F3E42CB94F2E507ADFD454692B8BA7F3CEFF1FF33E26013917958489B0F04C4B82919FC44BAC9DA574AF1725C9CA32D3BC898A8489CC0DAE7CA2DB9C6A7891EEEA765D4E8760F5691567D402CFAF483607EABF6F662D068FC49AFEF9F6908775B8F7AD0F76105A3D59B02EB3C7352CCC70562BCBE33796C52F461B8A2246C788A726329861DF86228AF41C2F87A109AACCA9AED3BD00451C9A5487865287EFFF1E8FA18FC1895C351BDA2D3A2C16B2C2F156E278C16B6397C5568FC9327F2CAAAFA6A8AC20912288DEE4608BF94B42251AE37F9C2C19893A7E05D436CC6958C2C1328B2F9085EB7A3950A5A12792C566B0204F587E5583432B45E29CE4D812902C168356167903B3AD2D61181A131F37E2E19C737B80D5FD2D5187FC7BAAD71F2C7A8EAFF48DBBCD95117C720BEE6FE2B9AFDE3783DE8C8D620567B796C68D56B60DD762BAD64636BD8EC8E6EA2A6C1014FF6B5BFA823C46B1304346518A7D9B923E83795B555DB26C5ECE90628E5398C90D6DE52D57CDC58157BAE1E8B88F72E54F13DCEA9D711510B21188D509D47F5B657F2C3B384C1168508DFB9EB059BF9480894AC51A18128953D14A1029E88C1CECB6EA46C7178B251531A8A26B43B19DE2DB0B879BB011040E71D2297789820A66417F1D0B48FF72BB24FDC248A19BFE7B7FCE88DB86D9853B1CB0DCA83307BF512EE30E9A00971E06C097439DD8B645C486675F00F8889AA4529EC7AA8A8375ECC518AECEC32F1A2BF918FFAE1AF5530BB53351A7FDE8A8E1A264B622174380CC0AD8AE3BBA40D7D9924A89DF0410EE9B182B6A77698A68F4F9B9A221156EE61E3B0362309B60417E259B9E8FC5521008F8C269A1211188375E793566FF1042186EED97B66B1C4E36E56D7DB4E4BF20B9E0053A69D5B8E3D5DCE0B9AC533E07A457AD77FF4818762AAC492A8E47756D9F676330358C390539D56F643A5BADCA0BBB82529945B193363699AF13204436D8024409399285FF4A4A9787A663D7C7B5B524ED0FB46F0C585214D9A67BD379BC3858A1BD3B8406D81A06FD6BA8EA4B69280437AD8299FB0E1B85BDA85D73CDDC58750ABE636C48E74CE4302B0460B915D8DA8681758F96D48D1C5D70857C1C677BD50867A6CE4B0A6670B7E563D45B8A82EA1067CAE2F4EF17852F2A5F8A9782F86AD63410EAEBC95C3CE149F846EBDEBDF6A992F1AAA6A018B03AD30F1FF36FFF31454344D3509AF7880996C1CE76CCF22C2CBAAD82778F1884C0D2079C3690834E0BA54F433E04AB784FD6FB09012490DA6F3C3A610D7F694AEB2B3002B4DBE084A9ECD735BF377D8558CEA94EE480C7A8D3306748EB29AF2F746AB4A73F0F3F92AFF3CAACAF4BD994C043CA810D2F48A1B027D5D2EF4B0585A3DE4D93303CF0BB4A8F30274CEBE33E64ED9A2F3BF182F0BAF4CF7F40CBB0E17FBCAA57D3C974F2FA430D22D0F4774E93D785701F99BFB6DE35F130A75E71F06B012D7B64F033530A3988F36B3AA66B35D22F43CD02FDB5E9BC5BAAD8A4197E0E5D94819E6F77ADD60E749396E7C4185FADF519",
-  "hex"
-);
-var aes128CtrCrypt = (key2, counter, data) => {
-  if (key2.length !== 16 || counter.length !== 16)
-    throw new RangeError("AES key and counter must have 16 bytes");
-  const ctr = import_buffer.Buffer.from(counter).reverse();
-  const aes = createAesBlockCipher(import_buffer.Buffer.from(key2).reverse());
-  const output = import_buffer.Buffer.alloc(data.length);
-  for (let p = 0; p < data.length; p += 16) {
-    const mask = aes(ctr);
-    for (let j = 0; j < 16 && p + j < data.length; j++) output[p + j] = data[p + j] ^ mask[15 - j];
-    for (let j = 15; j >= 0; j--) {
-      ctr[j] = ctr[j] + 1 & 255;
-      if (ctr[j]) break;
-    }
-  }
-  return output;
-};
-var modcryptKey = (header) => {
-  if (typeof header.gameCode !== "string" || header.gameCode.length !== 4)
-    throw new Error("Expected four-character game code");
-  if (header.twlInternalFlags & 4 || (header.appflags?.[3] ?? 0) & 128) {
-    const key2 = import_buffer.Buffer.alloc(16);
-    key2.write(header.gameTitle, 0, 12, "ascii");
-    key2.write(header.gameCode, 12, 4, "ascii");
-    return key2;
-  }
-  if (!header.hmac_arm9i || header.hmac_arm9i.length < 16)
-    throw new Error("Missing ARM9i HMAC for modcrypt key");
-  const x = import_buffer.Buffer.from(
-    "Nintendo" + header.gameCode + [...header.gameCode].reverse().join(""),
-    "ascii"
-  );
-  for (let i = 0; i < 16; i++) x[i] ^= header.hmac_arm9i[i];
-  const mask = (1n << 128n) - 1n;
-  let v = x.readBigUInt64LE(0) | x.readBigUInt64LE(8) << 64n;
-  v = v + 0xfffefb4e295902582a680f5f1a4f3e79n & mask;
-  v = (v << 42n | v >> 86n) & mask;
-  const out = import_buffer.Buffer.alloc(16);
-  out.writeBigUInt64LE(v & (1n << 64n) - 1n);
-  out.writeBigUInt64LE(v >> 64n, 8);
-  return out;
-};
-var encryptSecureArea = (gameCode, input) => {
-  if (typeof gameCode !== "string" || gameCode.length !== 4)
-    throw new Error("Expected four-character game code");
-  if (input.length < 2048) throw new RangeError("Secure area must contain at least 0x800 bytes");
-  const output = import_buffer.Buffer.from(input);
-  let magic = new Uint32Array(1042);
-  let args = [0, 0, 0];
-  function encrypt2(a2, b2) {
-    for (let i = 0; i < 16; i++) {
-      const c = (magic[i] ^ a2) >>> 0;
-      const sum = magic[18 + (c >>> 24)] + magic[274 + (c >>> 16 & 255)] >>> 0;
-      const f = magic[786 + (c & 255)] + (magic[530 + (c >>> 8 & 255)] ^ sum) >>> 0;
-      a2 = (b2 ^ f) >>> 0;
-      b2 = c;
-    }
-    return [(b2 ^ magic[17]) >>> 0, (a2 ^ magic[16]) >>> 0];
-  }
-  function init2() {
-    [args[2], args[1]] = encrypt2(args[2], args[1]);
-    [args[1], args[0]] = encrypt2(args[1], args[0]);
-    const key2 = import_buffer.Buffer.alloc(12);
-    args.forEach((v, i) => key2.writeUInt32LE(v, i * 4));
-    for (let j = 0; j < 18; j++) magic[j] ^= key2.readUInt32BE(j * 4 & 7);
-    let a2 = 0, b2 = 0;
-    for (let i = 0; i < 1042; i += 2) {
-      [a2, b2] = encrypt2(a2, b2);
-      magic[i] = a2;
-      magic[i + 1] = b2;
-    }
-  }
-  function init1() {
-    magic = Uint32Array.from({ length: 1042 }, (_, i) => KEY1.readUInt32LE(i * 4));
-    const code = import_buffer.Buffer.from(gameCode, "ascii").readUInt32LE();
-    args = [code, code >>> 1, code << 1 >>> 0];
-    init2();
-    init2();
-  }
-  init1();
-  args[1] = args[1] << 1 >>> 0;
-  args[2] >>>= 1;
-  init2();
-  for (let p = 8; p < 2048; p += 8) {
-    const [b2, a2] = encrypt2(output.readUInt32LE(p + 4), output.readUInt32LE(p));
-    output.writeUInt32LE(a2, p);
-    output.writeUInt32LE(b2, p + 4);
-  }
-  let [b, a] = encrypt2(1784827769, 1919118949);
-  init1();
-  [b, a] = encrypt2(b, a);
-  output.writeUInt32LE(a, 0);
-  output.writeUInt32LE(b, 4);
-  return output;
-};
-
-// src/nitro/header.ts
-var UnitCode = Object.freeze({ NDS: 0, NDS_DSi: 2, DSi: 3 });
-var Header = class {
-  raw;
-  trimmedRom;
-  doublePadding;
-  nitrocode;
-  decrypted;
-  headerCRC;
-  logoCRC;
-  secureCRC;
-  dlp_signature;
-  constructor(input) {
-    const data = bytes(input, "header");
-    range(data, 0, 368, "header");
-    const size = data.readUInt32LE(132);
-    if (size < 368 || size > data.length) throw new RangeError(`Invalid header size: ${size}`);
-    this.raw = import_buffer.Buffer.from(data.subarray(0, size));
-    if (this.unitCode & 2 && size > 512) range(this.raw, 0, 4096, "DSi header");
-    this.trimmedRom = this.total_rom_size ? this.total_rom_size >= data.length : data.length !== this.size;
-    this.doublePadding = this.ARM9size % 1024 < 512 && this.ARM7romOffset % 1024 === 0 && this.ARM9overlayOffset % 1024 === 0 || this.ARM7size % 1024 < 512 && this.FNToffset % 1024 === 0 && this.ARM7overlayOffset % 1024 === 0 || this.FNTsize % 1024 < 512 && this.FAToffset % 1024 === 0 || this.FATsize % 1024 < 512 && this.bannerOffset % 1024 === 0;
-    const nitroOffset = this.ARM9romOffset + this.ARM9size;
-    this.nitrocode = nitroOffset >= size && nitroOffset + 4 <= data.length && data.readUInt32LE(nitroOffset) === 3737126433;
-    this.decrypted = data.length >= 16392 && data.readBigUInt64LE(16384) === 0xe7ffdeffe7ffdeffn;
-    this.headerCRC = crc16(this.raw.subarray(0, 350)) === this.headerCRC16;
-    this.logoCRC = crc16(this.logo) === this.logoCRC16;
-    const secure = data.subarray(16384, 32768);
-    this.secureCRC = secure.length > 0 && crc16(this.decrypted ? encryptSecureArea(this.gameCode, secure) : secure) === this.secureCRC16;
-    this.dlp_signature = import_buffer.Buffer.alloc(0);
-    if (this.ROMsize >= size && this.ROMsize + 136 <= data.length && data.readUInt32LE(this.ROMsize) === 90977) {
-      this.dlp_signature = import_buffer.Buffer.from(data.subarray(this.ROMsize, this.ROMsize + 136));
-    }
-  }
-  get size() {
-    return 2 ** (17 + this.raw[20]);
-  }
-  set size(value) {
-    const power = Math.log2(value);
-    if (!Number.isInteger(power) || power < 17 || power > 32)
-      throw new RangeError("ROM capacity must be a power of two from 128 KiB to 4 GiB");
-    this.raw[20] = power - 17;
-  }
-  toBuffer() {
-    const data = import_buffer.Buffer.from(this.raw);
-    data.writeUInt16LE(crc16(data.subarray(192, 348)), 348);
-    data.writeUInt16LE(crc16(data.subarray(0, 350)), 350);
-    return data;
-  }
-  toString() {
-    return `NDS header: ${this.gameTitle.replace(/\0+$/, "")} (${this.gameCode})`;
+init_buffer();
+var table16 = new Uint16Array(256);
+var table32 = new Uint32Array(256);
+for (let i2 = 0; i2 < 256; i2++) {
+  let a = i2, b = i2;
+  for (let bit = 0; bit < 8; bit++) {
+    a = a >>> 1 ^ (a & 1 ? 40961 : 0);
+    b = b >>> 1 ^ (b & 1 ? 3988292384 : 0);
   }
-};
-function field(name, offset, length, type = "buffer", dsi = false) {
-  Object.defineProperty(Header.prototype, name, {
-    enumerable: true,
-    get() {
-      if (dsi && (!(this.unitCode & 2) || this.raw.length <= 512))
-        return type === "buffer" ? import_buffer.Buffer.alloc(length) : 0;
-      const data = range(this.raw, offset, length, `header ${name}`);
-      if (type === "string") return data.toString("latin1");
-      if (type === "buffer") return data;
-      return length === 8 ? data.readBigUInt64LE() : data.readUIntLE(0, length);
-    },
-    set(value) {
-      const target = range(this.raw, offset, length, `header ${name}`);
-      if (type === "string") {
-        if (typeof value !== "string" || import_buffer.Buffer.byteLength(value, "latin1") > length)
-          throw new TypeError(`Invalid ${name}`);
-        target.fill(0);
-        target.write(value, "latin1");
-      } else if (type === "buffer") {
-        if (!(value instanceof Uint8Array)) throw new TypeError(`Invalid ${name}`);
-        const source = bytes(value, name);
-        if (source.length !== length) throw new RangeError(`${name} must contain ${length} bytes`);
-        source.copy(target);
-      } else if (length === 8) {
-        if (typeof value !== "bigint") throw new TypeError(`Invalid ${name}`);
-        target.writeBigUInt64LE(value);
-      } else {
-        if (typeof value !== "number") throw new TypeError(`Invalid ${name}`);
-        target.writeUIntLE(value, 0, length);
-      }
-    }
-  });
+  table16[i2] = a;
+  table32[i2] = b;
 }
-field("gameTitle", 0, 12, "string");
-field("gameCode", 12, 4, "string");
-field("makerCode", 16, 2, "string");
-for (const [name, offset] of Object.entries({
-  unitCode: 18,
-  encryptionSeed: 19,
-  twlInternalFlags: 28,
-  permitsFlags: 29,
-  ROMversion: 30,
-  internalFlags: 31
-}))
-  field(name, offset, 1, "number");
-field("reserved", 21, 7);
-var ntr32 = "ARM9romOffset ARM9entryAddress ARM9ramAddress ARM9size ARM7romOffset ARM7entryAddress ARM7ramAddress ARM7size FNToffset FNTsize FAToffset FATsize ARM9overlayOffset ARM9overlaySize ARM7overlayOffset ARM7overlaySize flagsRead flagsInit bannerOffset".split(
-  " "
-);
-ntr32.forEach((name, i) => field(name, 32 + i * 4, 4, "number"));
-field("secureCRC16", 108, 2, "number");
-field("ROMtimeout", 110, 2, "number");
-field("ARM9autoload", 112, 4, "number");
-field("ARM7autoload", 116, 4, "number");
-field("secureDisable", 120, 8, "number");
-field("ROMsize", 128, 4, "number");
-field("headerSize", 132, 4, "number");
-field("reserved2", 136, 56);
-field("logo", 192, 156);
-field("logoCRC16", 348, 2, "number");
-field("headerCRC16", 350, 2, "number");
-"debug_romOffset debug_size debug_ramAddress reserved3".split(" ").forEach((name, i) => field(name, 352 + i * 4, 4, "number"));
-field("appflags", 444, 4, "buffer", true);
-"mbk9_wramcnt_setting region_flags access_control scfg_ext_mask".split(" ").forEach((name, i) => field(name, 428 + i * 4, 4, "number", true));
-var twl32 = "dsi9_rom_offset offset_0x1C4 dsi9_ram_address dsi9_size dsi7_rom_offset offset_0x1D4 dsi7_ram_address dsi7_size digest_ntr_start digest_ntr_size digest_twl_start digest_twl_size sector_hashtable_start sector_hashtable_size block_hashtable_start block_hashtable_size digest_sector_size digest_block_sectorcount banner_size offset_0x20C total_rom_size offset_0x214 offset_0x218 offset_0x21C modcrypt1_start modcrypt1_size modcrypt2_start modcrypt2_size tid_low tid_high public_sav_size private_sav_size".split(
-  " "
-);
-twl32.forEach((name, i) => field(name, 448 + i * 4, 4, "number", true));
-"hmac_arm9 hmac_arm7 hmac_digest_master hmac_icon_title hmac_arm9i hmac_arm7i".split(" ").forEach((name, i) => field(name, 768 + i * 20, 20, "buffer", true));
-field("hmac_arm9_no_secure", 928, 20, "buffer", true);
-field("rsa_signature", 3968, 128, "buffer", true);
+var crc16 = (data, initial = 65535) => {
+  let crc = initial;
+  for (const byte of data) crc = crc >>> 8 ^ table16[(crc ^ byte) & 255];
+  return crc;
+};
+var crc32 = (data) => {
+  let crc = 4294967295;
+  for (const byte of data) crc = crc >>> 8 ^ table32[(crc ^ byte) & 255];
+  return (crc ^ 4294967295) >>> 0;
+};
 
 // src/nitro/banner.ts
-init_buffer();
 var titles = [
   "japaneseTitle",
   "englishTitle",
@@ -3421,14 +3198,13 @@ var Banner = class {
     const data = bytes(input, "banner");
     this.version = range(data, offset, 2, "banner").readUInt16LE();
     let size = this.getDefSize(hardSize);
-    if (this.version >>> 8 === 1)
-      size = hardSize > 0 && hardSize !== 4294967295 ? Math.min(hardSize, 9152) : 9152;
+    if (this.version >>> 8 === 1) size = hardSize > 0 && hardSize !== 4294967295 ? Math.min(hardSize, 9152) : 9152;
     this.raw = import_buffer.Buffer.from(range(data, offset, size, "banner"));
     this.bannerCRC = crc16(this.raw.subarray(32, 2112)) === this.raw.readUInt16LE(2);
     this.tileData = import_buffer.Buffer.from(this.raw.subarray(32, 544));
     this.palette = import_buffer.Buffer.from(this.raw.subarray(544, 576));
-    for (const [i, title] of titles.entries())
-      this[title] = i < this.titleCount ? this.raw.subarray(576 + i * 256, 832 + i * 256).toString("utf16le").split("\0")[0] : "";
+    for (const [i2, title] of titles.entries())
+      this[title] = i2 < this.titleCount ? this.raw.subarray(576 + i2 * 256, 832 + i2 * 256).toString("utf16le").split("\0")[0] : "";
   }
   get titleCount() {
     return this.version >= 3 ? 8 : this.version >= 2 ? 7 : 6;
@@ -3442,16 +3218,14 @@ var Banner = class {
   toBuffer() {
     const output = import_buffer.Buffer.from(this.raw);
     output.writeUInt16LE(this.version);
-    if (this.tileData.length !== 512 || this.palette.length !== 32)
-      throw new RangeError("Invalid banner icon size");
+    if (this.tileData.length !== 512 || this.palette.length !== 32) throw new RangeError("Invalid banner icon size");
     this.tileData.copy(output, 32);
     this.palette.copy(output, 544);
-    for (let i = 0; i < this.titleCount; i++) {
-      const text = import_buffer.Buffer.from(this[titles[i]], "utf16le");
-      if (text.length > 256)
-        throw new RangeError(`Banner ${titles[i]} exceeds 128 UTF-16 code units`);
-      output.fill(0, 576 + i * 256, 832 + i * 256);
-      text.copy(output, 576 + i * 256);
+    for (let i2 = 0; i2 < this.titleCount; i2++) {
+      const text = import_buffer.Buffer.from(this[titles[i2]], "utf16le");
+      if (text.length > 256) throw new RangeError(`Banner ${titles[i2]} exceeds 128 UTF-16 code units`);
+      output.fill(0, 576 + i2 * 256, 832 + i2 * 256);
+      text.copy(output, 576 + i2 * 256);
     }
     output.writeUInt16LE(crc16(output.subarray(32, 2112)), 2);
     if (this.version >= 2) output.writeUInt16LE(crc16(output.subarray(32, 2368)), 4);
@@ -3461,6 +3235,101 @@ var Banner = class {
   }
 };
 
+// src/nitro/crypto.ts
+init_buffer();
+var KEY1 = import_buffer.Buffer.from(
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
+  "hex"
+);
+var aes128CtrCrypt = (key2, counter, data) => {
+  if (key2.length !== 16 || counter.length !== 16) throw new RangeError("AES key and counter must have 16 bytes");
+  const ctr = import_buffer.Buffer.from(counter).reverse();
+  const aes = createAesBlockCipher(import_buffer.Buffer.from(key2).reverse());
+  const output = import_buffer.Buffer.alloc(data.length);
+  for (let p = 0; p < data.length; p += 16) {
+    const mask = aes(ctr);
+    for (let j = 0; j < 16 && p + j < data.length; j++) output[p + j] = data[p + j] ^ mask[15 - j];
+    for (let j = 15; j >= 0; j--) {
+      ctr[j] = ctr[j] + 1 & 255;
+      if (ctr[j]) break;
+    }
+  }
+  return output;
+};
+var modcryptKey = (header) => {
+  if (typeof header.gameCode !== "string" || header.gameCode.length !== 4)
+    throw new Error("Expected four-character game code");
+  if (header.twlInternalFlags & 4 || (header.appflags?.[3] ?? 0) & 128) {
+    const key2 = import_buffer.Buffer.alloc(16);
+    key2.write(header.gameTitle, 0, 12, "ascii");
+    key2.write(header.gameCode, 12, 4, "ascii");
+    return key2;
+  }
+  if (!header.hmac_arm9i || header.hmac_arm9i.length < 16) throw new Error("Missing ARM9i HMAC for modcrypt key");
+  const x2 = import_buffer.Buffer.from(`Nintendo${header.gameCode}${[...header.gameCode].reverse().join("")}`, "ascii");
+  for (let i2 = 0; i2 < 16; i2++) x2[i2] ^= header.hmac_arm9i[i2];
+  const mask = (1n << 128n) - 1n;
+  let v = x2.readBigUInt64LE(0) | x2.readBigUInt64LE(8) << 64n;
+  v = v + 0xfffefb4e295902582a680f5f1a4f3e79n & mask;
+  v = (v << 42n | v >> 86n) & mask;
+  const out = import_buffer.Buffer.alloc(16);
+  out.writeBigUInt64LE(v & (1n << 64n) - 1n);
+  out.writeBigUInt64LE(v >> 64n, 8);
+  return out;
+};
+var encryptSecureArea = (gameCode, input) => {
+  if (typeof gameCode !== "string" || gameCode.length !== 4) throw new Error("Expected four-character game code");
+  if (input.length < 2048) throw new RangeError("Secure area must contain at least 0x800 bytes");
+  const output = import_buffer.Buffer.from(input);
+  let magic = new Uint32Array(1042);
+  let args = [0, 0, 0];
+  function encrypt2(a2, b2) {
+    for (let i2 = 0; i2 < 16; i2++) {
+      const c = (magic[i2] ^ a2) >>> 0;
+      const sum = magic[18 + (c >>> 24)] + magic[274 + (c >>> 16 & 255)] >>> 0;
+      const f = magic[786 + (c & 255)] + (magic[530 + (c >>> 8 & 255)] ^ sum) >>> 0;
+      a2 = (b2 ^ f) >>> 0;
+      b2 = c;
+    }
+    return [(b2 ^ magic[17]) >>> 0, (a2 ^ magic[16]) >>> 0];
+  }
+  function init2() {
+    [args[2], args[1]] = encrypt2(args[2], args[1]);
+    [args[1], args[0]] = encrypt2(args[1], args[0]);
+    const key2 = import_buffer.Buffer.alloc(12);
+    args.forEach((v, i2) => key2.writeUInt32LE(v, i2 * 4));
+    for (let j = 0; j < 18; j++) magic[j] ^= key2.readUInt32BE(j * 4 & 7);
+    let a2 = 0, b2 = 0;
+    for (let i2 = 0; i2 < 1042; i2 += 2) {
+      [a2, b2] = encrypt2(a2, b2);
+      magic[i2] = a2;
+      magic[i2 + 1] = b2;
+    }
+  }
+  function init1() {
+    magic = Uint32Array.from({ length: 1042 }, (_, i2) => KEY1.readUInt32LE(i2 * 4));
+    const code = import_buffer.Buffer.from(gameCode, "ascii").readUInt32LE();
+    args = [code, code >>> 1, code << 1 >>> 0];
+    init2();
+    init2();
+  }
+  init1();
+  args[1] = args[1] << 1 >>> 0;
+  args[2] >>>= 1;
+  init2();
+  for (let p = 8; p < 2048; p += 8) {
+    const [b2, a2] = encrypt2(output.readUInt32LE(p + 4), output.readUInt32LE(p));
+    output.writeUInt32LE(a2, p);
+    output.writeUInt32LE(b2, p + 4);
+  }
+  let [b, a] = encrypt2(1784827769, 1919118949);
+  init1();
+  [b, a] = encrypt2(b, a);
+  output.writeUInt32LE(a, 0);
+  output.writeUInt32LE(b, 4);
+  return output;
+};
+
 // src/nitro/filesystem.ts
 init_buffer();
 var FileAllocationTable = class {
@@ -3491,8 +3360,7 @@ var FileNameTable = class _FileNameTable {
     const visited = /* @__PURE__ */ new Set();
     const fileIds = /* @__PURE__ */ new Set();
     const parse = (index, name, depth) => {
-      if (depth > 256 || index >= count || visited.has(index))
-        throw new Error("Invalid FNT directory tree or cycle");
+      if (depth > 256 || index >= count || visited.has(index)) throw new Error("Invalid FNT directory tree or cycle");
       visited.add(index);
       let cursor = table2.readUInt32LE(index * 8);
       let fileId = table2.readUInt16LE(index * 8 + 4);
@@ -3572,6 +3440,7 @@ var OverlayTable = class {
       });
     }
   }
+  isArm9;
   entries = [];
   readBasicOverlays(fat) {
     return this.entries.map((item) => {
@@ -3586,12 +3455,137 @@ var OverlayTable = class {
   toBuffer() {
     const data = import_buffer.Buffer.alloc(this.entries.length * 32);
     this.entries.forEach(
-      (entry, i) => overlayFields.forEach((field2, j) => data.writeUInt32LE(entry[field2], i * 32 + j * 4))
+      (entry, i2) => overlayFields.forEach((field2, j) => data.writeUInt32LE(entry[field2], i2 * 32 + j * 4))
     );
     return data;
   }
 };
 
+// src/nitro/header.ts
+init_buffer();
+var UnitCode = Object.freeze({ NDS: 0, NDS_DSi: 2, DSi: 3 });
+var Header = class {
+  raw;
+  trimmedRom;
+  doublePadding;
+  nitrocode;
+  decrypted;
+  headerCRC;
+  logoCRC;
+  secureCRC;
+  dlp_signature;
+  constructor(input) {
+    const data = bytes(input, "header");
+    range(data, 0, 368, "header");
+    const size = data.readUInt32LE(132);
+    if (size < 368 || size > data.length) throw new RangeError(`Invalid header size: ${size}`);
+    this.raw = import_buffer.Buffer.from(data.subarray(0, size));
+    if (this.unitCode & 2 && size > 512) range(this.raw, 0, 4096, "DSi header");
+    this.trimmedRom = this.total_rom_size ? this.total_rom_size >= data.length : data.length !== this.size;
+    this.doublePadding = this.ARM9size % 1024 < 512 && this.ARM7romOffset % 1024 === 0 && this.ARM9overlayOffset % 1024 === 0 || this.ARM7size % 1024 < 512 && this.FNToffset % 1024 === 0 && this.ARM7overlayOffset % 1024 === 0 || this.FNTsize % 1024 < 512 && this.FAToffset % 1024 === 0 || this.FATsize % 1024 < 512 && this.bannerOffset % 1024 === 0;
+    const nitroOffset = this.ARM9romOffset + this.ARM9size;
+    this.nitrocode = nitroOffset >= size && nitroOffset + 4 <= data.length && data.readUInt32LE(nitroOffset) === 3737126433;
+    this.decrypted = data.length >= 16392 && data.readBigUInt64LE(16384) === 0xe7ffdeffe7ffdeffn;
+    this.headerCRC = crc16(this.raw.subarray(0, 350)) === this.headerCRC16;
+    this.logoCRC = crc16(this.logo) === this.logoCRC16;
+    const secure = data.subarray(16384, 32768);
+    this.secureCRC = secure.length > 0 && crc16(this.decrypted ? encryptSecureArea(this.gameCode, secure) : secure) === this.secureCRC16;
+    this.dlp_signature = import_buffer.Buffer.alloc(0);
+    if (this.ROMsize >= size && this.ROMsize + 136 <= data.length && data.readUInt32LE(this.ROMsize) === 90977) {
+      this.dlp_signature = import_buffer.Buffer.from(data.subarray(this.ROMsize, this.ROMsize + 136));
+    }
+  }
+  get size() {
+    return 2 ** (17 + this.raw[20]);
+  }
+  set size(value) {
+    const power = Math.log2(value);
+    if (!Number.isInteger(power) || power < 17 || power > 32)
+      throw new RangeError("ROM capacity must be a power of two from 128 KiB to 4 GiB");
+    this.raw[20] = power - 17;
+  }
+  toBuffer() {
+    const data = import_buffer.Buffer.from(this.raw);
+    data.writeUInt16LE(crc16(data.subarray(192, 348)), 348);
+    data.writeUInt16LE(crc16(data.subarray(0, 350)), 350);
+    return data;
+  }
+  toString() {
+    return `NDS header: ${this.gameTitle.replace(/\0+$/, "")} (${this.gameCode})`;
+  }
+};
+function field(name, offset, length, type = "buffer", dsi = false) {
+  Object.defineProperty(Header.prototype, name, {
+    enumerable: true,
+    get() {
+      if (dsi && (!(this.unitCode & 2) || this.raw.length <= 512))
+        return type === "buffer" ? import_buffer.Buffer.alloc(length) : 0;
+      const data = range(this.raw, offset, length, `header ${name}`);
+      if (type === "string") return data.toString("latin1");
+      if (type === "buffer") return data;
+      return length === 8 ? data.readBigUInt64LE() : data.readUIntLE(0, length);
+    },
+    set(value) {
+      const target = range(this.raw, offset, length, `header ${name}`);
+      if (type === "string") {
+        if (typeof value !== "string" || import_buffer.Buffer.byteLength(value, "latin1") > length)
+          throw new TypeError(`Invalid ${name}`);
+        target.fill(0);
+        target.write(value, "latin1");
+      } else if (type === "buffer") {
+        if (!(value instanceof Uint8Array)) throw new TypeError(`Invalid ${name}`);
+        const source = bytes(value, name);
+        if (source.length !== length) throw new RangeError(`${name} must contain ${length} bytes`);
+        source.copy(target);
+      } else if (length === 8) {
+        if (typeof value !== "bigint") throw new TypeError(`Invalid ${name}`);
+        target.writeBigUInt64LE(value);
+      } else {
+        if (typeof value !== "number") throw new TypeError(`Invalid ${name}`);
+        target.writeUIntLE(value, 0, length);
+      }
+    }
+  });
+}
+field("gameTitle", 0, 12, "string");
+field("gameCode", 12, 4, "string");
+field("makerCode", 16, 2, "string");
+for (const [name, offset] of Object.entries({
+  unitCode: 18,
+  encryptionSeed: 19,
+  twlInternalFlags: 28,
+  permitsFlags: 29,
+  ROMversion: 30,
+  internalFlags: 31
+}))
+  field(name, offset, 1, "number");
+field("reserved", 21, 7);
+var ntr32 = "ARM9romOffset ARM9entryAddress ARM9ramAddress ARM9size ARM7romOffset ARM7entryAddress ARM7ramAddress ARM7size FNToffset FNTsize FAToffset FATsize ARM9overlayOffset ARM9overlaySize ARM7overlayOffset ARM7overlaySize flagsRead flagsInit bannerOffset".split(
+  " "
+);
+ntr32.forEach((name, i2) => field(name, 32 + i2 * 4, 4, "number"));
+field("secureCRC16", 108, 2, "number");
+field("ROMtimeout", 110, 2, "number");
+field("ARM9autoload", 112, 4, "number");
+field("ARM7autoload", 116, 4, "number");
+field("secureDisable", 120, 8, "number");
+field("ROMsize", 128, 4, "number");
+field("headerSize", 132, 4, "number");
+field("reserved2", 136, 56);
+field("logo", 192, 156);
+field("logoCRC16", 348, 2, "number");
+field("headerCRC16", 350, 2, "number");
+"debug_romOffset debug_size debug_ramAddress reserved3".split(" ").forEach((name, i2) => field(name, 352 + i2 * 4, 4, "number"));
+field("appflags", 444, 4, "buffer", true);
+"mbk9_wramcnt_setting region_flags access_control scfg_ext_mask".split(" ").forEach((name, i2) => field(name, 428 + i2 * 4, 4, "number", true));
+var twl32 = "dsi9_rom_offset offset_0x1C4 dsi9_ram_address dsi9_size dsi7_rom_offset offset_0x1D4 dsi7_ram_address dsi7_size digest_ntr_start digest_ntr_size digest_twl_start digest_twl_size sector_hashtable_start sector_hashtable_size block_hashtable_start block_hashtable_size digest_sector_size digest_block_sectorcount banner_size offset_0x20C total_rom_size offset_0x214 offset_0x218 offset_0x21C modcrypt1_start modcrypt1_size modcrypt2_start modcrypt2_size tid_low tid_high public_sav_size private_sav_size".split(
+  " "
+);
+twl32.forEach((name, i2) => field(name, 448 + i2 * 4, 4, "number", true));
+"hmac_arm9 hmac_arm7 hmac_digest_master hmac_icon_title hmac_arm9i hmac_arm7i".split(" ").forEach((name, i2) => field(name, 768 + i2 * 20, 20, "buffer", true));
+field("hmac_arm9_no_secure", 928, 20, "buffer", true);
+field("rsa_signature", 3968, 128, "buffer", true);
+
 // src/nitro/twl.ts
 init_buffer();
 
@@ -3617,8 +3611,7 @@ var decompressBLZ = (input, maxSize = 268435456) => {
         if (src - 2 < prefix) throw new Error("Truncated BLZ reference");
         const high = input[--src], low = input[--src];
         const count = (high >>> 4) + 3, offset = ((high & 15) << 8 | low) + 3;
-        if (dst - count < prefix || dst - 1 + offset >= size)
-          throw new Error("Invalid BLZ reference");
+        if (dst - count < prefix || dst - 1 + offset >= size) throw new Error("Invalid BLZ reference");
         for (let j = 0; j < count; j++) {
           --dst;
           out[dst] = out[dst + offset];
@@ -3712,10 +3705,7 @@ var decompressArm9 = (data, header) => {
   const compressed = ptr > header.ARM9ramAddress && ptr + nitro >= header.ARM9ramAddress + data.length;
   return {
     compressed,
-    data: compressed ? import_buffer.Buffer.concat([
-      decompressBLZ(data.subarray(0, data.length - nitro)),
-      data.subarray(data.length - nitro)
-    ]) : import_buffer.Buffer.from(data)
+    data: compressed ? import_buffer.Buffer.concat([decompressBLZ(data.subarray(0, data.length - nitro)), data.subarray(data.length - nitro)]) : import_buffer.Buffer.from(data)
   };
 };
 var compressArm9 = (data, header, postSize = 0) => {
@@ -3765,8 +3755,7 @@ function validate(h) {
     }
   }
   const s = h.digest_sector_size;
-  if (!Number.isSafeInteger(s) || s <= 0 || s > 16384 || 16384 % s)
-    throw new Error("Invalid TWL digest sector size");
+  if (!Number.isSafeInteger(s) || s <= 0 || s > 16384 || 16384 % s) throw new Error("Invalid TWL digest sector size");
   if (!Number.isSafeInteger(h.digest_block_sectorcount) || h.digest_block_sectorcount <= 0 || h.digest_block_sectorcount > 1048576)
     throw new Error("Invalid TWL digest block sector count");
   if (h.digest_ntr_size < 16384 || h.digest_ntr_size % s || h.digest_twl_size % s)
@@ -3796,45 +3785,25 @@ var TWL = class {
     this.Hashtable2Data = import_buffer.Buffer.from(
       slice(original, h.block_hashtable_start, h.block_hashtable_size, "Block hash table")
     );
-    this.DSi9Data = import_buffer.Buffer.from(
-      slice(original, h.dsi9_rom_offset, Math.max(h.modcrypt1_size, h.dsi9_size), "ARM9i")
-    );
-    this.DSi7Data = import_buffer.Buffer.from(
-      slice(original, h.dsi7_rom_offset, Math.max(h.modcrypt2_size, h.dsi7_size), "ARM7i")
-    );
+    this.DSi9Data = import_buffer.Buffer.from(slice(original, h.dsi9_rom_offset, Math.max(h.modcrypt1_size, h.dsi9_size), "ARM9i"));
+    this.DSi7Data = import_buffer.Buffer.from(slice(original, h.dsi7_rom_offset, Math.max(h.modcrypt2_size, h.dsi7_size), "ARM7i"));
     this.Header2Data = h.trimmedRom ? null : Array.from(
       { length: 3 },
-      (_, i) => import_buffer.Buffer.from(
-        slice(original, h.digest_twl_start - 12288 + 4096 * i, 4096, "Secondary header")
-      )
-    );
-    this.Overlays9Sha1Hmac = overlays.map(
-      (o) => hash(slice(original, o.offset, o.size, "ARM9 overlay"))
+      (_, i2) => import_buffer.Buffer.from(slice(original, h.digest_twl_start - 12288 + 4096 * i2, 4096, "Secondary header"))
     );
+    this.Overlays9Sha1Hmac = overlays.map((o) => hash(slice(original, o.offset, o.size, "ARM9 overlay")));
     let encrypted = false;
     const modcryptStart = [
       { start: h.modcrypt1_start, size: h.modcrypt1_size },
       { start: h.modcrypt2_start, size: h.modcrypt2_size }
-    ].find(
-      ({ start, size }) => size > 0 && start >= h.digest_twl_start && start < 4294967295
-    )?.start;
+    ].find(({ start, size }) => size > 0 && start >= h.digest_twl_start && start < 4294967295)?.start;
     if (modcryptStart !== void 0) {
       const index = Math.floor((modcryptStart - h.digest_twl_start) / h.digest_sector_size);
       const actual = hash(
-        slice(
-          original,
-          h.digest_twl_start + index * h.digest_sector_size,
-          h.digest_sector_size,
-          "Modcrypt sector"
-        )
+        slice(original, h.digest_twl_start + index * h.digest_sector_size, h.digest_sector_size, "Modcrypt sector")
       );
       encrypted = !actual.equals(
-        slice(
-          this.Hashtable1Data,
-          this.firstDSiHashOffset + index * 20,
-          20,
-          "Modcrypt sector hash"
-        )
+        slice(this.Hashtable1Data, this.firstDSiHashOffset + index * 20, 20, "Modcrypt sector hash")
       );
     }
     if (encrypted) this.cryptSections(h);
@@ -3878,7 +3847,7 @@ var TWL = class {
     if (overlays.length !== this.Overlays9Sha1Hmac.length)
       throw new Error("Changing ARM9 overlay count is unsupported");
     const hashes = overlays.map(hash);
-    if (hashes.every((h, i) => h.equals(this.Overlays9Sha1Hmac[i]))) return import_buffer.Buffer.from(arm9Data);
+    if (hashes.every((h, i2) => h.equals(this.Overlays9Sha1Hmac[i2]))) return import_buffer.Buffer.from(arm9Data);
     const init = header.reserved2.readUInt32LE(0) & 16383;
     const hdrptr = arm9Data.readUInt32LE(init + 20) - header.ARM9ramAddress;
     const unpacked = decompressArm9(arm9Data, header);
@@ -3890,9 +3859,8 @@ var TWL = class {
         break;
       }
     }
-    if (found < 0)
-      throw new Error("ARM9 overlay hashes changed but original hash table was not found");
-    hashes.forEach((h, i) => h.copy(unpacked.data, found + i * 20));
+    if (found < 0) throw new Error("ARM9 overlay hashes changed but original hash table was not found");
+    hashes.forEach((h, i2) => h.copy(unpacked.data, found + i2 * 20));
     return unpacked.compressed ? compressArm9(unpacked.data, header, arm9Data.length - hdrptr) : unpacked.data;
   }
   writeTo(writer, h) {
@@ -3930,8 +3898,7 @@ var TWL = class {
       writer.position = h.sector_hashtable_start + index++ * 20;
       writer.write(hash(b));
     };
-    for (let p = 0; p < 16384; p += h.digest_sector_size)
-      put(secure.subarray(p, p + h.digest_sector_size));
+    for (let p = 0; p < 16384; p += h.digest_sector_size) put(secure.subarray(p, p + h.digest_sector_size));
     for (let p = h.digest_ntr_start + 16384; p < h.digest_ntr_start + h.digest_ntr_size; p += h.digest_sector_size)
       put(read(p, h.digest_sector_size));
     for (let p = h.digest_twl_start; p < h.digest_twl_start + h.digest_twl_size; p += h.digest_sector_size)
@@ -3975,18 +3942,8 @@ var NDSFile = class _NDSFile {
     this.fatTable = new FileAllocationTable(this.original, h.FAToffset, h.FATsize);
     this.fntTable = new FileNameTable(this.fatTable, this.original, h.FNToffset, h.FNTsize);
     this.root = this.fntTable.root;
-    this.overlay9Table = new OverlayTable(
-      this.original,
-      h.ARM9overlayOffset,
-      h.ARM9overlaySize,
-      true
-    );
-    this.overlay7Table = new OverlayTable(
-      this.original,
-      h.ARM7overlayOffset,
-      h.ARM7overlaySize,
-      false
-    );
+    this.overlay9Table = new OverlayTable(this.original, h.ARM9overlayOffset, h.ARM9overlaySize, true);
+    this.overlay7Table = new OverlayTable(this.original, h.ARM7overlayOffset, h.ARM7overlaySize, false);
     const arm9Overlays = this.overlay9Table.readBasicOverlays(this.fatTable);
     this.root.folders.push({
       name: "overlay",
@@ -4012,7 +3969,7 @@ var NDSFile = class _NDSFile {
         if (this.paths.has(key(path))) throw new Error(`Duplicate ROM path: ${path}`);
         this.paths.set(key(path), { path, file });
       }
-      for (const child of folder.folders) visit(child, prefix + child.name + "/");
+      for (const child of folder.folders) visit(child, `${prefix + child.name}/`);
     };
     visit(this.root, "");
     if (h.unitCode & 2 && h.twlInternalFlags & 1 && h.tid_high && h.tid_high !== 4294967295) {
@@ -4057,15 +4014,8 @@ var NDSFile = class _NDSFile {
   toBuffer() {
     const fntReplacement = this.root.files.find((file) => file.name === "fnt.bin")?.replacement;
     if (fntReplacement) {
-      const replacementTree = new FileNameTable(
-        this.fatTable,
-        fntReplacement,
-        0,
-        fntReplacement.length
-      );
-      const collect = (folder) => [...folder.files.map((file) => file.id), ...folder.folders.flatMap(collect)].sort(
-        (a, b) => a - b
-      );
+      const replacementTree = new FileNameTable(this.fatTable, fntReplacement, 0, fntReplacement.length);
+      const collect = (folder) => [...folder.files.map((file) => file.id), ...folder.folders.flatMap(collect)].sort((a, b) => a - b);
       if (collect(replacementTree.root).join(",") !== collect(this.data).join(","))
         throw new Error("Replacement FNT must preserve existing file IDs");
     }
@@ -4110,8 +4060,7 @@ var NDSFile = class _NDSFile {
           item.reserved = (item.reserved & 4278190080 | size & 16777215) >>> 0;
         overlayIds.add(file.id);
       }
-      if (table2.entries.length !== files.length)
-        throw new Error("Changing overlay file count is unsupported");
+      if (table2.entries.length !== files.length) throw new Error("Changing overlay file count is unsupported");
       const encoded = table2.toBuffer();
       if (arm92) {
         h.ARM9overlayOffset = writer.position;
@@ -4195,158 +4144,10 @@ var NDSFile = class _NDSFile {
 // src/nitro-patch-helper.ts
 init_buffer();
 
-// src/patch/zip.ts
-init_buffer();
-var fail = (message) => {
-  throw new Error(`ZIP: ${message}`);
-};
-var utf8 = new TextDecoder("utf-8", { fatal: true });
-var cp437 = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
-function decodeUtf8(bytes2) {
-  try {
-    return utf8.decode(bytes2);
-  } catch {
-    return fail("invalid UTF-8 filename");
-  }
-}
-function boundOption(value, fallback, label) {
-  value ??= fallback;
-  if (!Number.isSafeInteger(value) || value < 0)
-    throw new RangeError(`${label} must be a non-negative safe integer`);
-  return value;
-}
-function checkRange(bytes2, offset, length, end = bytes2.length) {
-  if (offset < 0 || offset > end || length > end - offset)
-    fail(`truncated or out-of-bounds record at ${offset} (length ${length})`);
-}
-function extras(bytes2) {
-  const fields = /* @__PURE__ */ new Map();
-  let offset = 0;
-  while (offset < bytes2.length) {
-    checkRange(bytes2, offset, 4);
-    const id = bytes2.readUInt16LE(offset), length = bytes2.readUInt16LE(offset + 2);
-    offset += 4;
-    checkRange(bytes2, offset, length);
-    if (id === 1) fail("ZIP64 archives are unsupported");
-    fields.set(id, bytes2.subarray(offset, offset + length));
-    offset += length;
-  }
-  return fields;
-}
-function filename(raw, flags, fields) {
-  if (flags & 2048) return decodeUtf8(raw);
-  const unicode = fields.get(28789);
-  if (unicode && unicode.length >= 5 && unicode[0] === 1 && unicode.readUInt32LE(1) === crc32(raw))
-    return decodeUtf8(unicode.subarray(5));
-  let result = "";
-  for (const byte of raw) result += byte < 128 ? String.fromCharCode(byte) : cp437[byte - 128];
-  return result;
-}
-var readZip = (input, options = {}) => {
-  if (!(input instanceof Uint8Array))
-    throw new TypeError("ZIP input must be a Buffer or Uint8Array");
-  const bytes2 = import_buffer.Buffer.from(input.buffer, input.byteOffset, input.byteLength);
-  const maxSize = boundOption(
-    options.maxUncompressedSize,
-    1024 * 1024 * 1024,
-    "maxUncompressedSize"
-  );
-  const maxEntries = boundOption(options.maxEntries, 1e5, "maxEntries");
-  let eocd = -1;
-  for (let offset2 = bytes2.length - 22; offset2 >= Math.max(0, bytes2.length - 65557); offset2--) {
-    if (bytes2.readUInt32LE(offset2) === 101010256 && offset2 + 22 + bytes2.readUInt16LE(offset2 + 20) === bytes2.length) {
-      eocd = offset2;
-      break;
-    }
-  }
-  if (eocd < 0) fail("end of central directory not found or truncated");
-  const disk = bytes2.readUInt16LE(eocd + 4), centralDisk = bytes2.readUInt16LE(eocd + 6);
-  const diskEntries = bytes2.readUInt16LE(eocd + 8), count = bytes2.readUInt16LE(eocd + 10);
-  const centralSize = bytes2.readUInt32LE(eocd + 12), centralOffset = bytes2.readUInt32LE(eocd + 16);
-  if (count === 65535 || diskEntries === 65535 || centralSize === 4294967295 || centralOffset === 4294967295 || eocd >= 20 && bytes2.readUInt32LE(eocd - 20) === 117853008)
-    fail("ZIP64 archives are unsupported");
-  if (disk || centralDisk || diskEntries !== count)
-    fail("split or multiple-disk archives are unsupported");
-  if (count > maxEntries) fail(`entry count exceeds limit ${maxEntries}`);
-  checkRange(bytes2, centralOffset, centralSize, eocd);
-  if (centralOffset + centralSize !== eocd) fail("central directory size/offset mismatch");
-  if (count > Math.floor(centralSize / 46)) fail("entry count exceeds central directory size");
-  const result = /* @__PURE__ */ new Map();
-  const ranges = [];
-  let offset = centralOffset, totalSize = 0;
-  for (let index = 0; index < count; index++) {
-    checkRange(bytes2, offset, 46, eocd);
-    if (bytes2.readUInt32LE(offset) !== 33639248) fail("invalid central directory signature");
-    const flags = bytes2.readUInt16LE(offset + 8), method = bytes2.readUInt16LE(offset + 10);
-    const checksum = bytes2.readUInt32LE(offset + 16), compressedSize = bytes2.readUInt32LE(offset + 20), size = bytes2.readUInt32LE(offset + 24);
-    const nameLength = bytes2.readUInt16LE(offset + 28), extraLength = bytes2.readUInt16LE(offset + 30), commentLength = bytes2.readUInt16LE(offset + 32);
-    const startDisk = bytes2.readUInt16LE(offset + 34), localOffset = bytes2.readUInt32LE(offset + 42);
-    if (size === 4294967295 || compressedSize === 4294967295 || localOffset === 4294967295 || startDisk === 65535)
-      fail("ZIP64 entry is unsupported");
-    if (startDisk) fail("split or multiple-disk entry is unsupported");
-    if (flags & 8257) fail("encrypted entries are unsupported");
-    if (flags & ~2062) fail("unsupported general purpose flags");
-    if (method !== 0 && method !== 8) fail(`unsupported compression method ${method}`);
-    if (size > maxSize - totalSize) fail(`uncompressed size exceeds limit ${maxSize}`);
-    totalSize += size;
-    checkRange(bytes2, offset + 46, nameLength + extraLength + commentLength, eocd);
-    const rawName = bytes2.subarray(offset + 46, offset + 46 + nameLength);
-    const fields = extras(
-      bytes2.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength)
-    );
-    const name = filename(rawName, flags, fields).replaceAll("\\", "/").toLowerCase();
-    offset += 46 + nameLength + extraLength + commentLength;
-    checkRange(bytes2, localOffset, 30, centralOffset);
-    if (bytes2.readUInt32LE(localOffset) !== 67324752) fail("invalid local header signature");
-    if (bytes2.readUInt16LE(localOffset + 6) !== flags || bytes2.readUInt16LE(localOffset + 8) !== method)
-      fail("local header flags/compression method mismatch");
-    const localNameLength = bytes2.readUInt16LE(localOffset + 26), localExtraLength = bytes2.readUInt16LE(localOffset + 28);
-    const dataOffset = localOffset + 30 + localNameLength + localExtraLength;
-    checkRange(bytes2, localOffset + 30, localNameLength + localExtraLength, centralOffset);
-    if (!rawName.equals(bytes2.subarray(localOffset + 30, localOffset + 30 + localNameLength)))
-      fail("local filename differs from central directory");
-    extras(bytes2.subarray(localOffset + 30 + localNameLength, dataOffset));
-    if (!(flags & 8) && (bytes2.readUInt32LE(localOffset + 14) !== checksum || bytes2.readUInt32LE(localOffset + 18) !== compressedSize || bytes2.readUInt32LE(localOffset + 22) !== size))
-      fail("local header CRC/size mismatch");
-    checkRange(bytes2, dataOffset, compressedSize, centralOffset);
-    let dataEnd = dataOffset + compressedSize;
-    if (flags & 8) {
-      checkRange(bytes2, dataEnd, 12, centralOffset);
-      const matches = (at) => at + 12 <= centralOffset && bytes2.readUInt32LE(at) === checksum && bytes2.readUInt32LE(at + 4) === compressedSize && bytes2.readUInt32LE(at + 8) === size;
-      if (matches(dataEnd)) dataEnd += 12;
-      else if (bytes2.readUInt32LE(dataEnd) === 134695760 && matches(dataEnd + 4)) dataEnd += 16;
-      else fail("data descriptor CRC/size mismatch");
-    }
-    ranges.push({ start: localOffset, end: dataEnd });
-    const compressed = bytes2.subarray(dataOffset, dataOffset + compressedSize);
-    let data;
-    if (method === 0) {
-      if (compressedSize !== size) fail("stored entry compressed/uncompressed size mismatch");
-      data = import_buffer.Buffer.from(compressed);
-    } else {
-      try {
-        data = inflateRawSync(compressed, { maxOutputLength: Math.max(1, size) });
-      } catch (error) {
-        return fail(
-          `cannot inflate entry ${JSON.stringify(name)} within declared size: ${error instanceof Error ? error.message : String(error)}`
-        );
-      }
-    }
-    if (data.length !== size) fail(`uncompressed size mismatch for ${JSON.stringify(name)}`);
-    if (crc32(data) !== checksum) fail(`CRC32 mismatch for ${JSON.stringify(name)}`);
-    if (name && !name.endsWith("/")) result.set(name, data);
-  }
-  if (offset !== eocd) fail("central directory entry count/length mismatch");
-  ranges.sort((a, b) => a.start - b.start);
-  for (let i = 1; i < ranges.length; i++)
-    if (ranges[i].start < ranges[i - 1].end) fail("overlapping local entry ranges");
-  return result;
-};
-
 // src/patch/xdelta.ts
 init_buffer();
 var UINT32_MAX = 4294967295;
-var fail2 = (message) => {
+var fail = (message) => {
   throw new Error(`VCDIFF: ${message}`);
 };
 var Reader = class {
@@ -4354,12 +4155,14 @@ var Reader = class {
     this.bytes = bytes2;
     this.label = label;
   }
+  bytes;
+  label;
   pos = 0;
   get remaining() {
     return this.bytes.length - this.pos;
   }
   byte() {
-    if (!this.remaining) fail2(`truncated ${this.label}`);
+    if (!this.remaining) fail(`truncated ${this.label}`);
     return this.bytes[this.pos++];
   }
   integer() {
@@ -4367,14 +4170,13 @@ var Reader = class {
     for (let count = 0; count < 5; count++) {
       const byte = this.byte();
       value = value * 128 + (byte & 127);
-      if (value > UINT32_MAX) fail2(`integer exceeds 32-bit limit in ${this.label}`);
+      if (value > UINT32_MAX) fail(`integer exceeds 32-bit limit in ${this.label}`);
       if (!(byte & 128)) return value;
     }
-    return fail2(`invalid variable-length integer in ${this.label}`);
+    return fail(`invalid variable-length integer in ${this.label}`);
   }
   take(size) {
-    if (size > this.remaining)
-      fail2(`truncated ${this.label}: requested ${size} bytes, ${this.remaining} remain`);
+    if (size > this.remaining) fail(`truncated ${this.label}: requested ${size} bytes, ${this.remaining} remain`);
     const result = this.bytes.subarray(this.pos, this.pos + size);
     this.pos += size;
     return result;
@@ -4401,8 +4203,8 @@ function adler32(bytes2) {
   let a = 1, b = 0;
   for (let start = 0; start < bytes2.length; start += 5552) {
     const end = Math.min(start + 5552, bytes2.length);
-    for (let i = start; i < end; i++) {
-      a += bytes2[i];
+    for (let i2 = start; i2 < end; i2++) {
+      a += bytes2[i2];
       b += a;
     }
     a %= 65521;
@@ -4425,27 +4227,26 @@ var decodeXdelta = (source, patch, options = {}) => {
   const reader = new Reader(asBuffer(patch, "patch"));
   const maxOutput = limit(options.maxOutputSize, 1024 * 1024 * 1024, "maxOutputSize");
   const maxWindow = limit(options.maxWindowSize, 16 * 1024 * 1024, "maxWindowSize");
-  if (!reader.take(3).equals(import_buffer.Buffer.from([214, 195, 196]))) fail2("invalid file signature");
-  if (reader.byte() !== 0) fail2("unsupported version (expected 0)");
+  if (!reader.take(3).equals(import_buffer.Buffer.from([214, 195, 196]))) fail("invalid file signature");
+  if (reader.byte() !== 0) fail("unsupported version (expected 0)");
   const header = reader.byte();
-  if (header & ~7) fail2("unrecognized header indicator bits");
-  if (header & 1)
-    fail2("secondary compression is unsupported; recreate the patch using xdelta3 -S none");
-  if (header & 2) fail2("custom code table is unsupported");
+  if (header & ~7) fail("unrecognized header indicator bits");
+  if (header & 1) fail("secondary compression is unsupported; recreate the patch using xdelta3 -S none");
+  if (header & 2) fail("custom code table is unsupported");
   if (header & 4) reader.take(reader.integer());
   const windows = [];
   let total = 0;
   while (reader.remaining) {
     const indicator = reader.byte();
     if (indicator & ~7 || (indicator & 3) === 3)
-      fail2("invalid window indicator: source and target are mutually exclusive");
+      fail("invalid window indicator: source and target are mutually exclusive");
     let dictionary = import_buffer.Buffer.alloc(0);
     if (indicator & 3) {
       const length = reader.integer();
       const offset = reader.integer();
       const available = indicator & 1 ? sourceBytes.length : total;
       if (offset > available || length > available - offset)
-        fail2("source segment exceeds available source/target bounds");
+        fail("source segment exceeds available source/target bounds");
       if (indicator & 1) dictionary = sourceBytes.subarray(offset, offset + length);
       else {
         dictionary = import_buffer.Buffer.allocUnsafe(length);
@@ -4461,20 +4262,18 @@ var decodeXdelta = (source, patch, options = {}) => {
     const deltaLength = reader.integer();
     const delta = new Reader(reader.take(deltaLength), "delta window");
     const targetLength = delta.integer();
-    if (targetLength > maxWindow)
-      fail2(`window size ${targetLength} exceeds maximum limit ${maxWindow}`);
-    if (targetLength > maxOutput - total) fail2(`output size exceeds maximum limit ${maxOutput}`);
-    if (dictionary.length + targetLength > UINT32_MAX)
-      fail2("window address space exceeds 32-bit limit");
+    if (targetLength > maxWindow) fail(`window size ${targetLength} exceeds maximum limit ${maxWindow}`);
+    if (targetLength > maxOutput - total) fail(`output size exceeds maximum limit ${maxOutput}`);
+    if (dictionary.length + targetLength > UINT32_MAX) fail("window address space exceeds 32-bit limit");
     const compressed = delta.byte();
-    if (compressed & ~7) fail2("unrecognized delta indicator bits");
-    if (compressed) fail2("secondary compression in delta sections is unsupported");
+    if (compressed & ~7) fail("unrecognized delta indicator bits");
+    if (compressed) fail("secondary compression in delta sections is unsupported");
     const dataLength = delta.integer(), instructionLength = delta.integer(), addressLength = delta.integer();
     const checksum = indicator & 4 ? delta.take(4).readUInt32BE() : null;
     const data = new Reader(delta.take(dataLength), "data section");
     const instructions = new Reader(delta.take(instructionLength), "instruction section");
     const addresses = new Reader(delta.take(addressLength), "address section");
-    if (delta.remaining) fail2("delta encoding length does not match section lengths");
+    if (delta.remaining) fail("delta encoding length does not match section lengths");
     const target = import_buffer.Buffer.allocUnsafe(targetLength);
     const near = new Uint32Array(4), same = new Uint32Array(768);
     let nearIndex = 0, position = 0;
@@ -4482,7 +4281,7 @@ var decodeXdelta = (source, patch, options = {}) => {
       const operations = table[instructions.byte()];
       for (const { type, size: fixedSize, mode } of operations) {
         const size = fixedSize || instructions.integer();
-        if (size > targetLength - position) fail2(`${type} size exceeds target window length`);
+        if (size > targetLength - position) fail(`${type} size exceeds target window length`);
         if (type === "ADD") {
           data.take(size).copy(target, position);
         } else if (type === "RUN") {
@@ -4494,8 +4293,7 @@ var decodeXdelta = (source, patch, options = {}) => {
           else if (mode === 1) address = here - addresses.integer();
           else if (mode < 6) address = near[mode - 2] + addresses.integer();
           else address = same[(mode - 6) * 256 + addresses.byte()];
-          if (address < 0 || address >= here)
-            fail2(`COPY address ${address} is outside decoded address space ${here}`);
+          if (address < 0 || address >= here) fail(`COPY address ${address} is outside decoded address space ${here}`);
           near[nearIndex] = address;
           nearIndex = (nearIndex + 1) % near.length;
           same[address % same.length] = address;
@@ -4507,7 +4305,7 @@ var decodeXdelta = (source, patch, options = {}) => {
           const from = Math.max(0, address - dictionary.length);
           while (copied < size) {
             const count = Math.min(size - copied, position + copied - from);
-            if (count <= 0) fail2("COPY references unavailable target bytes");
+            if (count <= 0) fail("COPY references unavailable target bytes");
             target.copy(target, position + copied, from, from + count);
             copied += count;
           }
@@ -4515,16 +4313,162 @@ var decodeXdelta = (source, patch, options = {}) => {
         position += size;
       }
     }
-    if (position !== targetLength)
-      fail2(`target window length mismatch: decoded ${position}, expected ${targetLength}`);
-    if (data.remaining || addresses.remaining) fail2("unused bytes in data/address section");
-    if (checksum !== null && adler32(target) !== checksum) fail2("Adler32 checksum mismatch");
+    if (position !== targetLength) fail(`target window length mismatch: decoded ${position}, expected ${targetLength}`);
+    if (data.remaining || addresses.remaining) fail("unused bytes in data/address section");
+    if (checksum !== null && adler32(target) !== checksum) fail("Adler32 checksum mismatch");
     windows.push(target);
     total += targetLength;
   }
   return import_buffer.Buffer.concat(windows, total);
 };
 
+// src/patch/zip.ts
+init_buffer();
+var fail2 = (message) => {
+  throw new Error(`ZIP: ${message}`);
+};
+var utf8 = new TextDecoder("utf-8", { fatal: true });
+var cp437 = "\xC7\xFC\xE9\xE2\xE4\xE0\xE5\xE7\xEA\xEB\xE8\xEF\xEE\xEC\xC4\xC5\xC9\xE6\xC6\xF4\xF6\xF2\xFB\xF9\xFF\xD6\xDC\xA2\xA3\xA5\u20A7\u0192\xE1\xED\xF3\xFA\xF1\xD1\xAA\xBA\xBF\u2310\xAC\xBD\xBC\xA1\xAB\xBB\u2591\u2592\u2593\u2502\u2524\u2561\u2562\u2556\u2555\u2563\u2551\u2557\u255D\u255C\u255B\u2510\u2514\u2534\u252C\u251C\u2500\u253C\u255E\u255F\u255A\u2554\u2569\u2566\u2560\u2550\u256C\u2567\u2568\u2564\u2565\u2559\u2558\u2552\u2553\u256B\u256A\u2518\u250C\u2588\u2584\u258C\u2590\u2580\u03B1\xDF\u0393\u03C0\u03A3\u03C3\xB5\u03C4\u03A6\u0398\u03A9\u03B4\u221E\u03C6\u03B5\u2229\u2261\xB1\u2265\u2264\u2320\u2321\xF7\u2248\xB0\u2219\xB7\u221A\u207F\xB2\u25A0\xA0";
+function decodeUtf8(bytes2) {
+  try {
+    return utf8.decode(bytes2);
+  } catch {
+    return fail2("invalid UTF-8 filename");
+  }
+}
+function boundOption(value, fallback, label) {
+  value ??= fallback;
+  if (!Number.isSafeInteger(value) || value < 0) throw new RangeError(`${label} must be a non-negative safe integer`);
+  return value;
+}
+function checkRange(bytes2, offset, length, end = bytes2.length) {
+  if (offset < 0 || offset > end || length > end - offset)
+    fail2(`truncated or out-of-bounds record at ${offset} (length ${length})`);
+}
+function extras(bytes2) {
+  const fields = /* @__PURE__ */ new Map();
+  let offset = 0;
+  while (offset < bytes2.length) {
+    checkRange(bytes2, offset, 4);
+    const id = bytes2.readUInt16LE(offset), length = bytes2.readUInt16LE(offset + 2);
+    offset += 4;
+    checkRange(bytes2, offset, length);
+    if (id === 1) fail2("ZIP64 archives are unsupported");
+    fields.set(id, bytes2.subarray(offset, offset + length));
+    offset += length;
+  }
+  return fields;
+}
+function filename(raw, flags, fields) {
+  if (flags & 2048) return decodeUtf8(raw);
+  const unicode = fields.get(28789);
+  if (unicode && unicode.length >= 5 && unicode[0] === 1 && unicode.readUInt32LE(1) === crc32(raw))
+    return decodeUtf8(unicode.subarray(5));
+  let result = "";
+  for (const byte of raw) result += byte < 128 ? String.fromCharCode(byte) : cp437[byte - 128];
+  return result;
+}
+var readZip = (input, options = {}) => {
+  if (!(input instanceof Uint8Array)) throw new TypeError("ZIP input must be a Buffer or Uint8Array");
+  const bytes2 = import_buffer.Buffer.from(input.buffer, input.byteOffset, input.byteLength);
+  const maxSize = boundOption(options.maxUncompressedSize, 1024 * 1024 * 1024, "maxUncompressedSize");
+  const maxEntries = boundOption(options.maxEntries, 1e5, "maxEntries");
+  let eocd = -1;
+  for (let offset2 = bytes2.length - 22; offset2 >= Math.max(0, bytes2.length - 65557); offset2--) {
+    if (bytes2.readUInt32LE(offset2) === 101010256 && offset2 + 22 + bytes2.readUInt16LE(offset2 + 20) === bytes2.length) {
+      eocd = offset2;
+      break;
+    }
+  }
+  if (eocd < 0) fail2("end of central directory not found or truncated");
+  const disk = bytes2.readUInt16LE(eocd + 4), centralDisk = bytes2.readUInt16LE(eocd + 6);
+  const diskEntries = bytes2.readUInt16LE(eocd + 8), count = bytes2.readUInt16LE(eocd + 10);
+  const centralSize = bytes2.readUInt32LE(eocd + 12), centralOffset = bytes2.readUInt32LE(eocd + 16);
+  if (count === 65535 || diskEntries === 65535 || centralSize === 4294967295 || centralOffset === 4294967295 || eocd >= 20 && bytes2.readUInt32LE(eocd - 20) === 117853008)
+    fail2("ZIP64 archives are unsupported");
+  if (disk || centralDisk || diskEntries !== count) fail2("split or multiple-disk archives are unsupported");
+  if (count > maxEntries) fail2(`entry count exceeds limit ${maxEntries}`);
+  checkRange(bytes2, centralOffset, centralSize, eocd);
+  if (centralOffset + centralSize !== eocd) fail2("central directory size/offset mismatch");
+  if (count > Math.floor(centralSize / 46)) fail2("entry count exceeds central directory size");
+  const result = /* @__PURE__ */ new Map();
+  const ranges = [];
+  let offset = centralOffset, totalSize = 0;
+  for (let index = 0; index < count; index++) {
+    checkRange(bytes2, offset, 46, eocd);
+    if (bytes2.readUInt32LE(offset) !== 33639248) fail2("invalid central directory signature");
+    const flags = bytes2.readUInt16LE(offset + 8), method = bytes2.readUInt16LE(offset + 10);
+    const checksum = bytes2.readUInt32LE(offset + 16), compressedSize = bytes2.readUInt32LE(offset + 20), size = bytes2.readUInt32LE(offset + 24);
+    const nameLength = bytes2.readUInt16LE(offset + 28), extraLength = bytes2.readUInt16LE(offset + 30), commentLength = bytes2.readUInt16LE(offset + 32);
+    const startDisk = bytes2.readUInt16LE(offset + 34), localOffset = bytes2.readUInt32LE(offset + 42);
+    if (size === 4294967295 || compressedSize === 4294967295 || localOffset === 4294967295 || startDisk === 65535)
+      fail2("ZIP64 entry is unsupported");
+    if (startDisk) fail2("split or multiple-disk entry is unsupported");
+    if (flags & 8257) fail2("encrypted entries are unsupported");
+    if (flags & ~2062) fail2("unsupported general purpose flags");
+    if (method !== 0 && method !== 8) fail2(`unsupported compression method ${method}`);
+    if (size > maxSize - totalSize) fail2(`uncompressed size exceeds limit ${maxSize}`);
+    totalSize += size;
+    checkRange(bytes2, offset + 46, nameLength + extraLength + commentLength, eocd);
+    const rawName = bytes2.subarray(offset + 46, offset + 46 + nameLength);
+    const fields = extras(bytes2.subarray(offset + 46 + nameLength, offset + 46 + nameLength + extraLength));
+    const name = filename(rawName, flags, fields).replaceAll("\\", "/").toLowerCase();
+    offset += 46 + nameLength + extraLength + commentLength;
+    checkRange(bytes2, localOffset, 30, centralOffset);
+    if (bytes2.readUInt32LE(localOffset) !== 67324752) fail2("invalid local header signature");
+    if (bytes2.readUInt16LE(localOffset + 6) !== flags || bytes2.readUInt16LE(localOffset + 8) !== method)
+      fail2("local header flags/compression method mismatch");
+    const localNameLength = bytes2.readUInt16LE(localOffset + 26), localExtraLength = bytes2.readUInt16LE(localOffset + 28);
+    const dataOffset = localOffset + 30 + localNameLength + localExtraLength;
+    checkRange(bytes2, localOffset + 30, localNameLength + localExtraLength, centralOffset);
+    if (!rawName.equals(bytes2.subarray(localOffset + 30, localOffset + 30 + localNameLength)))
+      fail2("local filename differs from central directory");
+    extras(bytes2.subarray(localOffset + 30 + localNameLength, dataOffset));
+    if (!(flags & 8) && (bytes2.readUInt32LE(localOffset + 14) !== checksum || bytes2.readUInt32LE(localOffset + 18) !== compressedSize || bytes2.readUInt32LE(localOffset + 22) !== size))
+      fail2("local header CRC/size mismatch");
+    checkRange(bytes2, dataOffset, compressedSize, centralOffset);
+    let dataEnd = dataOffset + compressedSize;
+    if (flags & 8) {
+      checkRange(bytes2, dataEnd, 12, centralOffset);
+      const matches = (at) => at + 12 <= centralOffset && bytes2.readUInt32LE(at) === checksum && bytes2.readUInt32LE(at + 4) === compressedSize && bytes2.readUInt32LE(at + 8) === size;
+      if (matches(dataEnd)) dataEnd += 12;
+      else if (bytes2.readUInt32LE(dataEnd) === 134695760 && matches(dataEnd + 4)) dataEnd += 16;
+      else fail2("data descriptor CRC/size mismatch");
+    }
+    ranges.push({ start: localOffset, end: dataEnd });
+    const compressed = bytes2.subarray(dataOffset, dataOffset + compressedSize);
+    let data;
+    if (method === 0) {
+      if (compressedSize !== size) fail2("stored entry compressed/uncompressed size mismatch");
+      data = import_buffer.Buffer.from(compressed);
+    } else {
+      try {
+        data = inflateRawSync(compressed, { maxOutputLength: Math.max(1, size) });
+      } catch (error) {
+        return fail2(
+          `cannot inflate entry ${JSON.stringify(name)} within declared size: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (data.length !== size) fail2(`uncompressed size mismatch for ${JSON.stringify(name)}`);
+    if (crc32(data) !== checksum) fail2(`CRC32 mismatch for ${JSON.stringify(name)}`);
+    if (name && !name.endsWith("/")) result.set(name, data);
+  }
+  if (offset !== eocd) fail2("central directory entry count/length mismatch");
+  ranges.sort((a, b) => a.start - b.start);
+  for (let i2 = 1; i2 < ranges.length; i2++)
+    if (ranges[i2].start < ranges[i2 - 1].end) fail2("overlapping local entry ranges");
+  return result;
+};
+var extractZipEntry = (input, entryName, options = {}) => {
+  if (typeof entryName !== "string" || !entryName) throw new TypeError("ZIP entry name must be a non-empty string");
+  const normalized = entryName.replaceAll("\\", "/").toLowerCase();
+  if (normalized.endsWith("/")) fail2(`entry ${JSON.stringify(entryName)} is a directory`);
+  const entry = readZip(input, options).get(normalized);
+  if (entry === void 0) return fail2(`entry ${JSON.stringify(entryName)} not found`);
+  return entry;
+};
+
 // src/nitro-patch-helper.ts
 var PatchReturnValue = Object.freeze({
   SUCCESS: "SUCCESS",
@@ -4554,9 +4498,12 @@ var readMetadata = (files) => {
   const value = metadata;
   const result = {};
   for (const field2 of ["id", "author", "name", "homepage", "version"]) {
-    if (typeof value[field2] === "string") result[field2] = value[field2];
+    const fieldValue = value[field2];
+    if (fieldValue === void 0) continue;
+    if (typeof fieldValue === "string") result[field2] = fieldValue;
     else invalidMetadataField(field2, "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32\u3002");
   }
+  if (value.isBeta === void 0) return result;
   if (typeof value.isBeta === "boolean") result.isBeta = value.isBeta;
   else invalidMetadataField("isBeta", "\u5FC5\u987B\u662F\u5E03\u5C14\u503C\u3002");
   return result;
@@ -4587,6 +4534,7 @@ var readPatchInfo = (patch, options = {}) => {
   const files = readZip(patch, options);
   return { metadata: readMetadata(files), readme: readReadme(files) };
 };
+var extractZipEntry2 = (archive, entryName, options = {}) => extractZipEntry(archive, entryName, options);
 var readPatchMetadataFile = async (patchPath, options = {}) => readPatchMetadata(await readFile(patchPath), options);
 var readPatchReadmeFile = async (patchPath, options = {}) => readPatchReadme(await readFile(patchPath), options);
 var readPatchInfoFile = async (patchPath, options = {}) => readPatchInfo(await readFile(patchPath), options);
@@ -4595,10 +4543,7 @@ var patchBuffer = (original, patch, options = {}) => {
   const patches = readZip(patch, options);
   const inputMd5 = md52(input);
   const preprocessing = patches.get(`preprocessing/${inputMd5}.xdelta`);
-  const rom = new NDSFile(
-    preprocessing ? decodeXdelta(input, preprocessing, options) : input,
-    options
-  );
+  const rom = new NDSFile(preprocessing ? decodeXdelta(input, preprocessing, options) : input, options);
   let matched = true;
   const md5File = patches.get("md5.txt");
   if (md5File) {
@@ -4632,6 +4577,7 @@ var patchIt = async (originalPath, patchPath, options = {}) => {
   return patchBuffer(original, patch, options);
 };
 var PatchHelper = Object.freeze({
+  extractZipEntry: extractZipEntry2,
   patchBuffer,
   patchIt,
   readPatchInfo,
@@ -4675,7 +4621,9 @@ var patchBuffer2 = (original, archive, options = {}) => {
 var readPatchMetadata2 = (archive, options = {}) => readPatchMetadata(archive, options);
 var readPatchReadme2 = (archive, options = {}) => readPatchReadme(archive, options);
 var readPatchInfo2 = (archive, options = {}) => readPatchInfo(archive, options);
+var extractZipEntry3 = (archive, entryName, options = {}) => new Uint8Array(extractZipEntry2(archive, entryName, options));
 var PatchHelper2 = Object.freeze({
+  extractZipEntry: extractZipEntry3,
   patchBuffer: patchBuffer2,
   readPatchInfo: readPatchInfo2,
   readPatchMetadata: readPatchMetadata2,
@@ -4685,6 +4633,7 @@ var NitroHelper = Object.freeze({ inspectRom });
 export {
   NitroHelper,
   PatchHelper2 as PatchHelper,
+  extractZipEntry3 as extractZipEntry,
   inspectRom,
   patchBuffer2 as patchBuffer,
   readPatchInfo2 as readPatchInfo,