nitro-patcher 0.1.0

package/dist/browser.js

@@ -0,0 +1,4616 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+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 __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key2 of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key2) && key2 !== except)
+        __defProp(to, key2, { get: () => from[key2], enumerable: !(desc = __getOwnPropDesc(from, key2)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js
+var require_base64_js = __commonJS({
+  "node_modules/.pnpm/base64-js@1.5.1/node_modules/base64-js/index.js"(exports) {
+    "use strict";
+    init_buffer();
+    exports.byteLength = byteLength;
+    exports.toByteArray = toByteArray;
+    exports.fromByteArray = fromByteArray;
+    var lookup = [];
+    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;
+    }
+    var i;
+    var len;
+    revLookup["-".charCodeAt(0)] = 62;
+    revLookup["_".charCodeAt(0)] = 63;
+    function getLens(b64) {
+      var len2 = b64.length;
+      if (len2 % 4 > 0) {
+        throw new Error("Invalid string. Length must be a multiple of 4");
+      }
+      var validLen = b64.indexOf("=");
+      if (validLen === -1) validLen = len2;
+      var placeHoldersLen = validLen === len2 ? 0 : 4 - validLen % 4;
+      return [validLen, placeHoldersLen];
+    }
+    function byteLength(b64) {
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function _byteLength(b64, validLen, placeHoldersLen) {
+      return (validLen + placeHoldersLen) * 3 / 4 - placeHoldersLen;
+    }
+    function toByteArray(b64) {
+      var tmp;
+      var lens = getLens(b64);
+      var validLen = lens[0];
+      var placeHoldersLen = lens[1];
+      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)];
+        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;
+        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;
+        arr[curByte++] = tmp >> 8 & 255;
+        arr[curByte++] = tmp & 255;
+      }
+      return arr;
+    }
+    function tripletToBase64(num) {
+      return lookup[num >> 18 & 63] + lookup[num >> 12 & 63] + lookup[num >> 6 & 63] + lookup[num & 63];
+    }
+    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);
+        output.push(tripletToBase64(tmp));
+      }
+      return output.join("");
+    }
+    function fromByteArray(uint8) {
+      var tmp;
+      var len2 = uint8.length;
+      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));
+      }
+      if (extraBytes === 1) {
+        tmp = uint8[len2 - 1];
+        parts.push(
+          lookup[tmp >> 2] + lookup[tmp << 4 & 63] + "=="
+        );
+      } else if (extraBytes === 2) {
+        tmp = (uint8[len2 - 2] << 8) + uint8[len2 - 1];
+        parts.push(
+          lookup[tmp >> 10] + lookup[tmp >> 4 & 63] + lookup[tmp << 2 & 63] + "="
+        );
+      }
+      return parts.join("");
+    }
+  }
+});
+
+// node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js
+var require_ieee754 = __commonJS({
+  "node_modules/.pnpm/ieee754@1.2.1/node_modules/ieee754/index.js"(exports) {
+    init_buffer();
+    exports.read = function(buffer, offset, isLE2, mLen, nBytes) {
+      var e, m;
+      var eLen = nBytes * 8 - mLen - 1;
+      var eMax = (1 << eLen) - 1;
+      var eBias = eMax >> 1;
+      var nBits = -7;
+      var i = isLE2 ? nBytes - 1 : 0;
+      var d = isLE2 ? -1 : 1;
+      var s = buffer[offset + i];
+      i += d;
+      e = s & (1 << -nBits) - 1;
+      s >>= -nBits;
+      nBits += eLen;
+      for (; nBits > 0; e = e * 256 + buffer[offset + i], i += 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) {
+      }
+      if (e === 0) {
+        e = 1 - eBias;
+      } else if (e === eMax) {
+        return m ? NaN : (s ? -1 : 1) * Infinity;
+      } else {
+        m = m + Math.pow(2, mLen);
+        e = e - eBias;
+      }
+      return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
+    };
+    exports.write = function(buffer, value, offset, isLE2, mLen, nBytes) {
+      var e, m, c;
+      var eLen = nBytes * 8 - mLen - 1;
+      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 d = isLE2 ? 1 : -1;
+      var s = value < 0 || value === 0 && 1 / value < 0 ? 1 : 0;
+      value = Math.abs(value);
+      if (isNaN(value) || value === Infinity) {
+        m = isNaN(value) ? 1 : 0;
+        e = eMax;
+      } else {
+        e = Math.floor(Math.log(value) / Math.LN2);
+        if (value * (c = Math.pow(2, -e)) < 1) {
+          e--;
+          c *= 2;
+        }
+        if (e + eBias >= 1) {
+          value += rt / c;
+        } else {
+          value += rt * Math.pow(2, 1 - eBias);
+        }
+        if (value * c >= 2) {
+          e++;
+          c /= 2;
+        }
+        if (e + eBias >= eMax) {
+          m = 0;
+          e = eMax;
+        } else if (e + eBias >= 1) {
+          m = (value * c - 1) * Math.pow(2, mLen);
+          e = e + eBias;
+        } else {
+          m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
+          e = 0;
+        }
+      }
+      for (; mLen >= 8; buffer[offset + i] = m & 255, i += 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) {
+      }
+      buffer[offset + i - d] |= s * 128;
+    };
+  }
+});
+
+// node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js
+var require_buffer = __commonJS({
+  "node_modules/.pnpm/buffer@6.0.3/node_modules/buffer/index.js"(exports) {
+    "use strict";
+    init_buffer();
+    var base64 = require_base64_js();
+    var ieee754 = require_ieee754();
+    var customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
+    exports.Buffer = Buffer3;
+    exports.SlowBuffer = SlowBuffer;
+    exports.INSPECT_MAX_BYTES = 50;
+    var K_MAX_LENGTH = 2147483647;
+    exports.kMaxLength = K_MAX_LENGTH;
+    Buffer3.TYPED_ARRAY_SUPPORT = typedArraySupport();
+    if (!Buffer3.TYPED_ARRAY_SUPPORT && typeof console !== "undefined" && typeof console.error === "function") {
+      console.error(
+        "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support."
+      );
+    }
+    function typedArraySupport() {
+      try {
+        const arr = new Uint8Array(1);
+        const proto = { foo: function() {
+          return 42;
+        } };
+        Object.setPrototypeOf(proto, Uint8Array.prototype);
+        Object.setPrototypeOf(arr, proto);
+        return arr.foo() === 42;
+      } catch (e) {
+        return false;
+      }
+    }
+    Object.defineProperty(Buffer3.prototype, "parent", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this)) return void 0;
+        return this.buffer;
+      }
+    });
+    Object.defineProperty(Buffer3.prototype, "offset", {
+      enumerable: true,
+      get: function() {
+        if (!Buffer3.isBuffer(this)) return void 0;
+        return this.byteOffset;
+      }
+    });
+    function createBuffer(length) {
+      if (length > K_MAX_LENGTH) {
+        throw new RangeError('The value "' + length + '" is invalid for option "size"');
+      }
+      const buf = new Uint8Array(length);
+      Object.setPrototypeOf(buf, Buffer3.prototype);
+      return buf;
+    }
+    function Buffer3(arg, encodingOrOffset, length) {
+      if (typeof arg === "number") {
+        if (typeof encodingOrOffset === "string") {
+          throw new TypeError(
+            'The "string" argument must be of type string. Received type number'
+          );
+        }
+        return allocUnsafe(arg);
+      }
+      return from(arg, encodingOrOffset, length);
+    }
+    Buffer3.poolSize = 8192;
+    function from(value, encodingOrOffset, length) {
+      if (typeof value === "string") {
+        return fromString(value, encodingOrOffset);
+      }
+      if (ArrayBuffer.isView(value)) {
+        return fromArrayView(value);
+      }
+      if (value == null) {
+        throw new TypeError(
+          "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+        );
+      }
+      if (isInstance(value, ArrayBuffer) || value && isInstance(value.buffer, ArrayBuffer)) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (typeof SharedArrayBuffer !== "undefined" && (isInstance(value, SharedArrayBuffer) || value && isInstance(value.buffer, SharedArrayBuffer))) {
+        return fromArrayBuffer(value, encodingOrOffset, length);
+      }
+      if (typeof value === "number") {
+        throw new TypeError(
+          'The "value" argument must not be of type number. Received type number'
+        );
+      }
+      const valueOf = value.valueOf && value.valueOf();
+      if (valueOf != null && valueOf !== value) {
+        return Buffer3.from(valueOf, encodingOrOffset, length);
+      }
+      const b = fromObject(value);
+      if (b) return b;
+      if (typeof Symbol !== "undefined" && Symbol.toPrimitive != null && typeof value[Symbol.toPrimitive] === "function") {
+        return Buffer3.from(value[Symbol.toPrimitive]("string"), encodingOrOffset, length);
+      }
+      throw new TypeError(
+        "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + typeof value
+      );
+    }
+    Buffer3.from = function(value, encodingOrOffset, length) {
+      return from(value, encodingOrOffset, length);
+    };
+    Object.setPrototypeOf(Buffer3.prototype, Uint8Array.prototype);
+    Object.setPrototypeOf(Buffer3, Uint8Array);
+    function assertSize(size) {
+      if (typeof size !== "number") {
+        throw new TypeError('"size" argument must be of type number');
+      } else if (size < 0) {
+        throw new RangeError('The value "' + size + '" is invalid for option "size"');
+      }
+    }
+    function alloc(size, fill, encoding) {
+      assertSize(size);
+      if (size <= 0) {
+        return createBuffer(size);
+      }
+      if (fill !== void 0) {
+        return typeof encoding === "string" ? createBuffer(size).fill(fill, encoding) : createBuffer(size).fill(fill);
+      }
+      return createBuffer(size);
+    }
+    Buffer3.alloc = function(size, fill, encoding) {
+      return alloc(size, fill, encoding);
+    };
+    function allocUnsafe(size) {
+      assertSize(size);
+      return createBuffer(size < 0 ? 0 : checked(size) | 0);
+    }
+    Buffer3.allocUnsafe = function(size) {
+      return allocUnsafe(size);
+    };
+    Buffer3.allocUnsafeSlow = function(size) {
+      return allocUnsafe(size);
+    };
+    function fromString(string, encoding) {
+      if (typeof encoding !== "string" || encoding === "") {
+        encoding = "utf8";
+      }
+      if (!Buffer3.isEncoding(encoding)) {
+        throw new TypeError("Unknown encoding: " + encoding);
+      }
+      const length = byteLength(string, encoding) | 0;
+      let buf = createBuffer(length);
+      const actual = buf.write(string, encoding);
+      if (actual !== length) {
+        buf = buf.slice(0, actual);
+      }
+      return buf;
+    }
+    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;
+      }
+      return buf;
+    }
+    function fromArrayView(arrayView) {
+      if (isInstance(arrayView, Uint8Array)) {
+        const copy = new Uint8Array(arrayView);
+        return fromArrayBuffer(copy.buffer, copy.byteOffset, copy.byteLength);
+      }
+      return fromArrayLike(arrayView);
+    }
+    function fromArrayBuffer(array, byteOffset, length) {
+      if (byteOffset < 0 || array.byteLength < byteOffset) {
+        throw new RangeError('"offset" is outside of buffer bounds');
+      }
+      if (array.byteLength < byteOffset + (length || 0)) {
+        throw new RangeError('"length" is outside of buffer bounds');
+      }
+      let buf;
+      if (byteOffset === void 0 && length === void 0) {
+        buf = new Uint8Array(array);
+      } else if (length === void 0) {
+        buf = new Uint8Array(array, byteOffset);
+      } else {
+        buf = new Uint8Array(array, byteOffset, length);
+      }
+      Object.setPrototypeOf(buf, Buffer3.prototype);
+      return buf;
+    }
+    function fromObject(obj) {
+      if (Buffer3.isBuffer(obj)) {
+        const len = checked(obj.length) | 0;
+        const buf = createBuffer(len);
+        if (buf.length === 0) {
+          return buf;
+        }
+        obj.copy(buf, 0, 0, len);
+        return buf;
+      }
+      if (obj.length !== void 0) {
+        if (typeof obj.length !== "number" || numberIsNaN(obj.length)) {
+          return createBuffer(0);
+        }
+        return fromArrayLike(obj);
+      }
+      if (obj.type === "Buffer" && Array.isArray(obj.data)) {
+        return fromArrayLike(obj.data);
+      }
+    }
+    function checked(length) {
+      if (length >= K_MAX_LENGTH) {
+        throw new RangeError("Attempt to allocate Buffer larger than maximum size: 0x" + K_MAX_LENGTH.toString(16) + " bytes");
+      }
+      return length | 0;
+    }
+    function SlowBuffer(length) {
+      if (+length != length) {
+        length = 0;
+      }
+      return Buffer3.alloc(+length);
+    }
+    Buffer3.isBuffer = function isBuffer(b) {
+      return b != null && b._isBuffer === true && b !== Buffer3.prototype;
+    };
+    Buffer3.compare = function compare(a, b) {
+      if (isInstance(a, Uint8Array)) a = Buffer3.from(a, a.offset, a.byteLength);
+      if (isInstance(b, Uint8Array)) b = Buffer3.from(b, b.offset, b.byteLength);
+      if (!Buffer3.isBuffer(a) || !Buffer3.isBuffer(b)) {
+        throw new TypeError(
+          'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
+        );
+      }
+      if (a === b) return 0;
+      let x = 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];
+          break;
+        }
+      }
+      if (x < y) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    Buffer3.isEncoding = function isEncoding(encoding) {
+      switch (String(encoding).toLowerCase()) {
+        case "hex":
+        case "utf8":
+        case "utf-8":
+        case "ascii":
+        case "latin1":
+        case "binary":
+        case "base64":
+        case "ucs2":
+        case "ucs-2":
+        case "utf16le":
+        case "utf-16le":
+          return true;
+        default:
+          return false;
+      }
+    };
+    Buffer3.concat = function concat(list, length) {
+      if (!Array.isArray(list)) {
+        throw new TypeError('"list" argument must be an Array of Buffers');
+      }
+      if (list.length === 0) {
+        return Buffer3.alloc(0);
+      }
+      let i;
+      if (length === void 0) {
+        length = 0;
+        for (i = 0; i < list.length; ++i) {
+          length += list[i].length;
+        }
+      }
+      const buffer = Buffer3.allocUnsafe(length);
+      let pos = 0;
+      for (i = 0; i < list.length; ++i) {
+        let buf = list[i];
+        if (isInstance(buf, Uint8Array)) {
+          if (pos + buf.length > buffer.length) {
+            if (!Buffer3.isBuffer(buf)) buf = Buffer3.from(buf);
+            buf.copy(buffer, pos);
+          } else {
+            Uint8Array.prototype.set.call(
+              buffer,
+              buf,
+              pos
+            );
+          }
+        } else if (!Buffer3.isBuffer(buf)) {
+          throw new TypeError('"list" argument must be an Array of Buffers');
+        } else {
+          buf.copy(buffer, pos);
+        }
+        pos += buf.length;
+      }
+      return buffer;
+    };
+    function byteLength(string, encoding) {
+      if (Buffer3.isBuffer(string)) {
+        return string.length;
+      }
+      if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
+        return string.byteLength;
+      }
+      if (typeof string !== "string") {
+        throw new TypeError(
+          'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + typeof string
+        );
+      }
+      const len = string.length;
+      const mustMatch = arguments.length > 2 && arguments[2] === true;
+      if (!mustMatch && len === 0) return 0;
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return len;
+          case "utf8":
+          case "utf-8":
+            return utf8ToBytes(string).length;
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return len * 2;
+          case "hex":
+            return len >>> 1;
+          case "base64":
+            return base64ToBytes(string).length;
+          default:
+            if (loweredCase) {
+              return mustMatch ? -1 : utf8ToBytes(string).length;
+            }
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer3.byteLength = byteLength;
+    function slowToString(encoding, start, end) {
+      let loweredCase = false;
+      if (start === void 0 || start < 0) {
+        start = 0;
+      }
+      if (start > this.length) {
+        return "";
+      }
+      if (end === void 0 || end > this.length) {
+        end = this.length;
+      }
+      if (end <= 0) {
+        return "";
+      }
+      end >>>= 0;
+      start >>>= 0;
+      if (end <= start) {
+        return "";
+      }
+      if (!encoding) encoding = "utf8";
+      while (true) {
+        switch (encoding) {
+          case "hex":
+            return hexSlice(this, start, end);
+          case "utf8":
+          case "utf-8":
+            return utf8Slice(this, start, end);
+          case "ascii":
+            return asciiSlice(this, start, end);
+          case "latin1":
+          case "binary":
+            return latin1Slice(this, start, end);
+          case "base64":
+            return base64Slice(this, start, end);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return utf16leSlice(this, start, end);
+          default:
+            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+            encoding = (encoding + "").toLowerCase();
+            loweredCase = true;
+        }
+      }
+    }
+    Buffer3.prototype._isBuffer = true;
+    function swap(b, n, m) {
+      const i = b[n];
+      b[n] = b[m];
+      b[m] = i;
+    }
+    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);
+      }
+      return this;
+    };
+    Buffer3.prototype.swap32 = function swap32() {
+      const len = this.length;
+      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);
+      }
+      return this;
+    };
+    Buffer3.prototype.swap64 = function swap64() {
+      const len = this.length;
+      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);
+      }
+      return this;
+    };
+    Buffer3.prototype.toString = function toString() {
+      const length = this.length;
+      if (length === 0) return "";
+      if (arguments.length === 0) return utf8Slice(this, 0, length);
+      return slowToString.apply(this, arguments);
+    };
+    Buffer3.prototype.toLocaleString = Buffer3.prototype.toString;
+    Buffer3.prototype.equals = function equals(b) {
+      if (!Buffer3.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
+      if (this === b) return true;
+      return Buffer3.compare(this, b) === 0;
+    };
+    Buffer3.prototype.inspect = function inspect() {
+      let str = "";
+      const max2 = exports.INSPECT_MAX_BYTES;
+      str = this.toString("hex", 0, max2).replace(/(.{2})/g, "$1 ").trim();
+      if (this.length > max2) str += " ... ";
+      return "<Buffer " + str + ">";
+    };
+    if (customInspectSymbol) {
+      Buffer3.prototype[customInspectSymbol] = Buffer3.prototype.inspect;
+    }
+    Buffer3.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
+      if (isInstance(target, Uint8Array)) {
+        target = Buffer3.from(target, target.offset, target.byteLength);
+      }
+      if (!Buffer3.isBuffer(target)) {
+        throw new TypeError(
+          'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + typeof target
+        );
+      }
+      if (start === void 0) {
+        start = 0;
+      }
+      if (end === void 0) {
+        end = target ? target.length : 0;
+      }
+      if (thisStart === void 0) {
+        thisStart = 0;
+      }
+      if (thisEnd === void 0) {
+        thisEnd = this.length;
+      }
+      if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
+        throw new RangeError("out of range index");
+      }
+      if (thisStart >= thisEnd && start >= end) {
+        return 0;
+      }
+      if (thisStart >= thisEnd) {
+        return -1;
+      }
+      if (start >= end) {
+        return 1;
+      }
+      start >>>= 0;
+      end >>>= 0;
+      thisStart >>>= 0;
+      thisEnd >>>= 0;
+      if (this === target) return 0;
+      let x = thisEnd - thisStart;
+      let y = end - start;
+      const len = Math.min(x, 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];
+          break;
+        }
+      }
+      if (x < y) return -1;
+      if (y < x) return 1;
+      return 0;
+    };
+    function bidirectionalIndexOf(buffer, val, byteOffset, encoding, dir) {
+      if (buffer.length === 0) return -1;
+      if (typeof byteOffset === "string") {
+        encoding = byteOffset;
+        byteOffset = 0;
+      } else if (byteOffset > 2147483647) {
+        byteOffset = 2147483647;
+      } else if (byteOffset < -2147483648) {
+        byteOffset = -2147483648;
+      }
+      byteOffset = +byteOffset;
+      if (numberIsNaN(byteOffset)) {
+        byteOffset = dir ? 0 : buffer.length - 1;
+      }
+      if (byteOffset < 0) byteOffset = buffer.length + byteOffset;
+      if (byteOffset >= buffer.length) {
+        if (dir) return -1;
+        else byteOffset = buffer.length - 1;
+      } else if (byteOffset < 0) {
+        if (dir) byteOffset = 0;
+        else return -1;
+      }
+      if (typeof val === "string") {
+        val = Buffer3.from(val, encoding);
+      }
+      if (Buffer3.isBuffer(val)) {
+        if (val.length === 0) {
+          return -1;
+        }
+        return arrayIndexOf(buffer, val, byteOffset, encoding, dir);
+      } else if (typeof val === "number") {
+        val = val & 255;
+        if (typeof Uint8Array.prototype.indexOf === "function") {
+          if (dir) {
+            return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset);
+          } else {
+            return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset);
+          }
+        }
+        return arrayIndexOf(buffer, [val], byteOffset, encoding, dir);
+      }
+      throw new TypeError("val must be string, number or Buffer");
+    }
+    function arrayIndexOf(arr, val, byteOffset, encoding, dir) {
+      let indexSize = 1;
+      let arrLength = arr.length;
+      let valLength = val.length;
+      if (encoding !== void 0) {
+        encoding = String(encoding).toLowerCase();
+        if (encoding === "ucs2" || encoding === "ucs-2" || encoding === "utf16le" || encoding === "utf-16le") {
+          if (arr.length < 2 || val.length < 2) {
+            return -1;
+          }
+          indexSize = 2;
+          arrLength /= 2;
+          valLength /= 2;
+          byteOffset /= 2;
+        }
+      }
+      function read(buf, i2) {
+        if (indexSize === 1) {
+          return buf[i2];
+        } else {
+          return buf.readUInt16BE(i2 * indexSize);
+        }
+      }
+      let i;
+      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;
+          } else {
+            if (foundIndex !== -1) i -= i - foundIndex;
+            foundIndex = -1;
+          }
+        }
+      } else {
+        if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength;
+        for (i = byteOffset; i >= 0; i--) {
+          let found = true;
+          for (let j = 0; j < valLength; j++) {
+            if (read(arr, i + j) !== read(val, j)) {
+              found = false;
+              break;
+            }
+          }
+          if (found) return i;
+        }
+      }
+      return -1;
+    }
+    Buffer3.prototype.includes = function includes(val, byteOffset, encoding) {
+      return this.indexOf(val, byteOffset, encoding) !== -1;
+    };
+    Buffer3.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
+    };
+    Buffer3.prototype.lastIndexOf = function lastIndexOf(val, byteOffset, encoding) {
+      return bidirectionalIndexOf(this, val, byteOffset, encoding, false);
+    };
+    function hexWrite(buf, string, offset, length) {
+      offset = Number(offset) || 0;
+      const remaining = buf.length - offset;
+      if (!length) {
+        length = remaining;
+      } else {
+        length = Number(length);
+        if (length > remaining) {
+          length = remaining;
+        }
+      }
+      const strLen = string.length;
+      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;
+      }
+      return i;
+    }
+    function utf8Write(buf, string, offset, length) {
+      return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    function asciiWrite(buf, string, offset, length) {
+      return blitBuffer(asciiToBytes(string), buf, offset, length);
+    }
+    function base64Write(buf, string, offset, length) {
+      return blitBuffer(base64ToBytes(string), buf, offset, length);
+    }
+    function ucs2Write(buf, string, offset, length) {
+      return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length);
+    }
+    Buffer3.prototype.write = function write(string, offset, length, encoding) {
+      if (offset === void 0) {
+        encoding = "utf8";
+        length = this.length;
+        offset = 0;
+      } else if (length === void 0 && typeof offset === "string") {
+        encoding = offset;
+        length = this.length;
+        offset = 0;
+      } else if (isFinite(offset)) {
+        offset = offset >>> 0;
+        if (isFinite(length)) {
+          length = length >>> 0;
+          if (encoding === void 0) encoding = "utf8";
+        } else {
+          encoding = length;
+          length = void 0;
+        }
+      } else {
+        throw new Error(
+          "Buffer.write(string, encoding, offset[, length]) is no longer supported"
+        );
+      }
+      const remaining = this.length - offset;
+      if (length === void 0 || length > remaining) length = remaining;
+      if (string.length > 0 && (length < 0 || offset < 0) || offset > this.length) {
+        throw new RangeError("Attempt to write outside buffer bounds");
+      }
+      if (!encoding) encoding = "utf8";
+      let loweredCase = false;
+      for (; ; ) {
+        switch (encoding) {
+          case "hex":
+            return hexWrite(this, string, offset, length);
+          case "utf8":
+          case "utf-8":
+            return utf8Write(this, string, offset, length);
+          case "ascii":
+          case "latin1":
+          case "binary":
+            return asciiWrite(this, string, offset, length);
+          case "base64":
+            return base64Write(this, string, offset, length);
+          case "ucs2":
+          case "ucs-2":
+          case "utf16le":
+          case "utf-16le":
+            return ucs2Write(this, string, offset, length);
+          default:
+            if (loweredCase) throw new TypeError("Unknown encoding: " + encoding);
+            encoding = ("" + encoding).toLowerCase();
+            loweredCase = true;
+        }
+      }
+    };
+    Buffer3.prototype.toJSON = function toJSON() {
+      return {
+        type: "Buffer",
+        data: Array.prototype.slice.call(this._arr || this, 0)
+      };
+    };
+    function base64Slice(buf, start, end) {
+      if (start === 0 && end === buf.length) {
+        return base64.fromByteArray(buf);
+      } else {
+        return base64.fromByteArray(buf.slice(start, end));
+      }
+    }
+    function utf8Slice(buf, start, end) {
+      end = Math.min(buf.length, end);
+      const res = [];
+      let i = start;
+      while (i < end) {
+        const firstByte = buf[i];
+        let codePoint = null;
+        let bytesPerSequence = firstByte > 239 ? 4 : firstByte > 223 ? 3 : firstByte > 191 ? 2 : 1;
+        if (i + bytesPerSequence <= end) {
+          let secondByte, thirdByte, fourthByte, tempCodePoint;
+          switch (bytesPerSequence) {
+            case 1:
+              if (firstByte < 128) {
+                codePoint = firstByte;
+              }
+              break;
+            case 2:
+              secondByte = buf[i + 1];
+              if ((secondByte & 192) === 128) {
+                tempCodePoint = (firstByte & 31) << 6 | secondByte & 63;
+                if (tempCodePoint > 127) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 3:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 12 | (secondByte & 63) << 6 | thirdByte & 63;
+                if (tempCodePoint > 2047 && (tempCodePoint < 55296 || tempCodePoint > 57343)) {
+                  codePoint = tempCodePoint;
+                }
+              }
+              break;
+            case 4:
+              secondByte = buf[i + 1];
+              thirdByte = buf[i + 2];
+              fourthByte = buf[i + 3];
+              if ((secondByte & 192) === 128 && (thirdByte & 192) === 128 && (fourthByte & 192) === 128) {
+                tempCodePoint = (firstByte & 15) << 18 | (secondByte & 63) << 12 | (thirdByte & 63) << 6 | fourthByte & 63;
+                if (tempCodePoint > 65535 && tempCodePoint < 1114112) {
+                  codePoint = tempCodePoint;
+                }
+              }
+          }
+        }
+        if (codePoint === null) {
+          codePoint = 65533;
+          bytesPerSequence = 1;
+        } else if (codePoint > 65535) {
+          codePoint -= 65536;
+          res.push(codePoint >>> 10 & 1023 | 55296);
+          codePoint = 56320 | codePoint & 1023;
+        }
+        res.push(codePoint);
+        i += bytesPerSequence;
+      }
+      return decodeCodePointsArray(res);
+    }
+    var MAX_ARGUMENTS_LENGTH = 4096;
+    function decodeCodePointsArray(codePoints) {
+      const len = codePoints.length;
+      if (len <= MAX_ARGUMENTS_LENGTH) {
+        return String.fromCharCode.apply(String, codePoints);
+      }
+      let res = "";
+      let i = 0;
+      while (i < len) {
+        res += String.fromCharCode.apply(
+          String,
+          codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
+        );
+      }
+      return res;
+    }
+    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);
+      }
+      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]);
+      }
+      return ret;
+    }
+    function hexSlice(buf, start, end) {
+      const len = buf.length;
+      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]];
+      }
+      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);
+      }
+      return res;
+    }
+    Buffer3.prototype.slice = function slice2(start, end) {
+      const len = this.length;
+      start = ~~start;
+      end = end === void 0 ? len : ~~end;
+      if (start < 0) {
+        start += len;
+        if (start < 0) start = 0;
+      } else if (start > len) {
+        start = len;
+      }
+      if (end < 0) {
+        end += len;
+        if (end < 0) end = 0;
+      } else if (end > len) {
+        end = len;
+      }
+      if (end < start) end = start;
+      const newBuf = this.subarray(start, end);
+      Object.setPrototypeOf(newBuf, Buffer3.prototype);
+      return newBuf;
+    };
+    function checkOffset(offset, ext, length) {
+      if (offset % 1 !== 0 || offset < 0) throw new RangeError("offset is not uint");
+      if (offset + ext > length) throw new RangeError("Trying to access beyond buffer length");
+    }
+    Buffer3.prototype.readUintLE = Buffer3.prototype.readUIntLE = function readUIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      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;
+      }
+      return val;
+    };
+    Buffer3.prototype.readUintBE = Buffer3.prototype.readUIntBE = function readUIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        checkOffset(offset, byteLength2, this.length);
+      }
+      let val = this[offset + --byteLength2];
+      let mul3 = 1;
+      while (byteLength2 > 0 && (mul3 *= 256)) {
+        val += this[offset + --byteLength2] * mul3;
+      }
+      return val;
+    };
+    Buffer3.prototype.readUint8 = Buffer3.prototype.readUInt8 = function readUInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      return this[offset];
+    };
+    Buffer3.prototype.readUint16LE = Buffer3.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] | this[offset + 1] << 8;
+    };
+    Buffer3.prototype.readUint16BE = Buffer3.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      return this[offset] << 8 | this[offset + 1];
+    };
+    Buffer3.prototype.readUint32LE = Buffer3.prototype.readUInt32LE = function readUInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return (this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16) + this[offset + 3] * 16777216;
+    };
+    Buffer3.prototype.readUint32BE = Buffer3.prototype.readUInt32BE = function readUInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] * 16777216 + (this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3]);
+    };
+    Buffer3.prototype.readBigUInt64LE = defineBigIntMethod(function readBigUInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const lo = first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24;
+      const hi = this[++offset] + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + last * 2 ** 24;
+      return BigInt(lo) + (BigInt(hi) << BigInt(32));
+    });
+    Buffer3.prototype.readBigUInt64BE = defineBigIntMethod(function readBigUInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const hi = first * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      const lo = this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last;
+      return (BigInt(hi) << BigInt(32)) + BigInt(lo);
+    });
+    Buffer3.prototype.readIntLE = function readIntLE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      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;
+      }
+      mul3 *= 128;
+      if (val >= mul3) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer3.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) checkOffset(offset, byteLength2, this.length);
+      let i = byteLength2;
+      let mul3 = 1;
+      let val = this[offset + --i];
+      while (i > 0 && (mul3 *= 256)) {
+        val += this[offset + --i] * mul3;
+      }
+      mul3 *= 128;
+      if (val >= mul3) val -= Math.pow(2, 8 * byteLength2);
+      return val;
+    };
+    Buffer3.prototype.readInt8 = function readInt8(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 1, this.length);
+      if (!(this[offset] & 128)) return this[offset];
+      return (255 - this[offset] + 1) * -1;
+    };
+    Buffer3.prototype.readInt16LE = function readInt16LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset] | this[offset + 1] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer3.prototype.readInt16BE = function readInt16BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 2, this.length);
+      const val = this[offset + 1] | this[offset] << 8;
+      return val & 32768 ? val | 4294901760 : val;
+    };
+    Buffer3.prototype.readInt32LE = function readInt32LE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] | this[offset + 1] << 8 | this[offset + 2] << 16 | this[offset + 3] << 24;
+    };
+    Buffer3.prototype.readInt32BE = function readInt32BE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return this[offset] << 24 | this[offset + 1] << 16 | this[offset + 2] << 8 | this[offset + 3];
+    };
+    Buffer3.prototype.readBigInt64LE = defineBigIntMethod(function readBigInt64LE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = this[offset + 4] + this[offset + 5] * 2 ** 8 + this[offset + 6] * 2 ** 16 + (last << 24);
+      return (BigInt(val) << BigInt(32)) + BigInt(first + this[++offset] * 2 ** 8 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 24);
+    });
+    Buffer3.prototype.readBigInt64BE = defineBigIntMethod(function readBigInt64BE(offset) {
+      offset = offset >>> 0;
+      validateNumber(offset, "offset");
+      const first = this[offset];
+      const last = this[offset + 7];
+      if (first === void 0 || last === void 0) {
+        boundsError(offset, this.length - 8);
+      }
+      const val = (first << 24) + // Overflow
+      this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + this[++offset];
+      return (BigInt(val) << BigInt(32)) + BigInt(this[++offset] * 2 ** 24 + this[++offset] * 2 ** 16 + this[++offset] * 2 ** 8 + last);
+    });
+    Buffer3.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, true, 23, 4);
+    };
+    Buffer3.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 4, this.length);
+      return ieee754.read(this, offset, false, 23, 4);
+    };
+    Buffer3.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, true, 52, 8);
+    };
+    Buffer3.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
+      offset = offset >>> 0;
+      if (!noAssert) checkOffset(offset, 8, this.length);
+      return ieee754.read(this, offset, false, 52, 8);
+    };
+    function checkInt(buf, value, offset, ext, max2, min) {
+      if (!Buffer3.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
+      if (value > max2 || value < min) throw new RangeError('"value" argument is out of bounds');
+      if (offset + ext > buf.length) throw new RangeError("Index out of range");
+    }
+    Buffer3.prototype.writeUintLE = Buffer3.prototype.writeUIntLE = function writeUIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      let mul3 = 1;
+      let i = 0;
+      this[offset] = value & 255;
+      while (++i < byteLength2 && (mul3 *= 256)) {
+        this[offset + i] = value / mul3 & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeUintBE = Buffer3.prototype.writeUIntBE = function writeUIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      byteLength2 = byteLength2 >>> 0;
+      if (!noAssert) {
+        const maxBytes = Math.pow(2, 8 * byteLength2) - 1;
+        checkInt(this, value, offset, byteLength2, maxBytes, 0);
+      }
+      let i = byteLength2 - 1;
+      let mul3 = 1;
+      this[offset + i] = value & 255;
+      while (--i >= 0 && (mul3 *= 256)) {
+        this[offset + i] = value / mul3 & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeUint8 = Buffer3.prototype.writeUInt8 = function writeUInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 1, 255, 0);
+      this[offset] = value & 255;
+      return offset + 1;
+    };
+    Buffer3.prototype.writeUint16LE = Buffer3.prototype.writeUInt16LE = function writeUInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeUint16BE = Buffer3.prototype.writeUInt16BE = function writeUInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 65535, 0);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeUint32LE = Buffer3.prototype.writeUInt32LE = function writeUInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset + 3] = value >>> 24;
+      this[offset + 2] = value >>> 16;
+      this[offset + 1] = value >>> 8;
+      this[offset] = value & 255;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeUint32BE = Buffer3.prototype.writeUInt32BE = function writeUInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 4294967295, 0);
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    };
+    function wrtBigUInt64LE(buf, value, offset, min, max2) {
+      checkIntBI(value, min, max2, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      lo = lo >> 8;
+      buf[offset++] = lo;
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      hi = hi >> 8;
+      buf[offset++] = hi;
+      return offset;
+    }
+    function wrtBigUInt64BE(buf, value, offset, min, max2) {
+      checkIntBI(value, min, max2, buf, offset, 7);
+      let lo = Number(value & BigInt(4294967295));
+      buf[offset + 7] = lo;
+      lo = lo >> 8;
+      buf[offset + 6] = lo;
+      lo = lo >> 8;
+      buf[offset + 5] = lo;
+      lo = lo >> 8;
+      buf[offset + 4] = lo;
+      let hi = Number(value >> BigInt(32) & BigInt(4294967295));
+      buf[offset + 3] = hi;
+      hi = hi >> 8;
+      buf[offset + 2] = hi;
+      hi = hi >> 8;
+      buf[offset + 1] = hi;
+      hi = hi >> 8;
+      buf[offset] = hi;
+      return offset + 8;
+    }
+    Buffer3.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer3.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
+    });
+    Buffer3.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit2 = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit2 - 1, -limit2);
+      }
+      let i = 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) {
+          sub = 1;
+        }
+        this[offset + i] = (value / mul3 >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        const limit2 = Math.pow(2, 8 * byteLength2 - 1);
+        checkInt(this, value, offset, byteLength2, limit2 - 1, -limit2);
+      }
+      let i = 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) {
+          sub = 1;
+        }
+        this[offset + i] = (value / mul3 >> 0) - sub & 255;
+      }
+      return offset + byteLength2;
+    };
+    Buffer3.prototype.writeInt8 = function writeInt8(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 1, 127, -128);
+      if (value < 0) value = 255 + value + 1;
+      this[offset] = value & 255;
+      return offset + 1;
+    };
+    Buffer3.prototype.writeInt16LE = function writeInt16LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeInt16BE = function writeInt16BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 2, 32767, -32768);
+      this[offset] = value >>> 8;
+      this[offset + 1] = value & 255;
+      return offset + 2;
+    };
+    Buffer3.prototype.writeInt32LE = function writeInt32LE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      this[offset] = value & 255;
+      this[offset + 1] = value >>> 8;
+      this[offset + 2] = value >>> 16;
+      this[offset + 3] = value >>> 24;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeInt32BE = function writeInt32BE(value, offset, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) checkInt(this, value, offset, 4, 2147483647, -2147483648);
+      if (value < 0) value = 4294967295 + value + 1;
+      this[offset] = value >>> 24;
+      this[offset + 1] = value >>> 16;
+      this[offset + 2] = value >>> 8;
+      this[offset + 3] = value & 255;
+      return offset + 4;
+    };
+    Buffer3.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
+      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    Buffer3.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
+      return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
+    });
+    function checkIEEE754(buf, value, offset, ext, max2, min) {
+      if (offset + ext > buf.length) throw new RangeError("Index out of range");
+      if (offset < 0) throw new RangeError("Index out of range");
+    }
+    function writeFloat(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 4, 34028234663852886e22, -34028234663852886e22);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 23, 4);
+      return offset + 4;
+    }
+    Buffer3.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, true, noAssert);
+    };
+    Buffer3.prototype.writeFloatBE = function writeFloatBE(value, offset, noAssert) {
+      return writeFloat(this, value, offset, false, noAssert);
+    };
+    function writeDouble(buf, value, offset, littleEndian, noAssert) {
+      value = +value;
+      offset = offset >>> 0;
+      if (!noAssert) {
+        checkIEEE754(buf, value, offset, 8, 17976931348623157e292, -17976931348623157e292);
+      }
+      ieee754.write(buf, value, offset, littleEndian, 52, 8);
+      return offset + 8;
+    }
+    Buffer3.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, true, noAssert);
+    };
+    Buffer3.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
+      return writeDouble(this, value, offset, false, noAssert);
+    };
+    Buffer3.prototype.copy = function copy(target, targetStart, start, end) {
+      if (!Buffer3.isBuffer(target)) throw new TypeError("argument should be a Buffer");
+      if (!start) start = 0;
+      if (!end && end !== 0) end = this.length;
+      if (targetStart >= target.length) targetStart = target.length;
+      if (!targetStart) targetStart = 0;
+      if (end > 0 && end < start) end = start;
+      if (end === start) return 0;
+      if (target.length === 0 || this.length === 0) return 0;
+      if (targetStart < 0) {
+        throw new RangeError("targetStart out of bounds");
+      }
+      if (start < 0 || start >= this.length) throw new RangeError("Index out of range");
+      if (end < 0) throw new RangeError("sourceEnd out of bounds");
+      if (end > this.length) end = this.length;
+      if (target.length - targetStart < end - start) {
+        end = target.length - targetStart + start;
+      }
+      const len = end - start;
+      if (this === target && typeof Uint8Array.prototype.copyWithin === "function") {
+        this.copyWithin(targetStart, start, end);
+      } else {
+        Uint8Array.prototype.set.call(
+          target,
+          this.subarray(start, end),
+          targetStart
+        );
+      }
+      return len;
+    };
+    Buffer3.prototype.fill = function fill(val, start, end, encoding) {
+      if (typeof val === "string") {
+        if (typeof start === "string") {
+          encoding = start;
+          start = 0;
+          end = this.length;
+        } else if (typeof end === "string") {
+          encoding = end;
+          end = this.length;
+        }
+        if (encoding !== void 0 && typeof encoding !== "string") {
+          throw new TypeError("encoding must be a string");
+        }
+        if (typeof encoding === "string" && !Buffer3.isEncoding(encoding)) {
+          throw new TypeError("Unknown encoding: " + encoding);
+        }
+        if (val.length === 1) {
+          const code = val.charCodeAt(0);
+          if (encoding === "utf8" && code < 128 || encoding === "latin1") {
+            val = code;
+          }
+        }
+      } else if (typeof val === "number") {
+        val = val & 255;
+      } else if (typeof val === "boolean") {
+        val = Number(val);
+      }
+      if (start < 0 || this.length < start || this.length < end) {
+        throw new RangeError("Out of range index");
+      }
+      if (end <= start) {
+        return this;
+      }
+      start = start >>> 0;
+      end = end === void 0 ? this.length : end >>> 0;
+      if (!val) val = 0;
+      let i;
+      if (typeof val === "number") {
+        for (i = start; i < end; ++i) {
+          this[i] = val;
+        }
+      } else {
+        const bytes2 = Buffer3.isBuffer(val) ? val : Buffer3.from(val, encoding);
+        const len = bytes2.length;
+        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];
+        }
+      }
+      return this;
+    };
+    var errors = {};
+    function E(sym, getMessage, Base) {
+      errors[sym] = class NodeError extends Base {
+        constructor() {
+          super();
+          Object.defineProperty(this, "message", {
+            value: getMessage.apply(this, arguments),
+            writable: true,
+            configurable: true
+          });
+          this.name = `${this.name} [${sym}]`;
+          this.stack;
+          delete this.name;
+        }
+        get code() {
+          return sym;
+        }
+        set code(value) {
+          Object.defineProperty(this, "code", {
+            configurable: true,
+            enumerable: true,
+            value,
+            writable: true
+          });
+        }
+        toString() {
+          return `${this.name} [${sym}]: ${this.message}`;
+        }
+      };
+    }
+    E(
+      "ERR_BUFFER_OUT_OF_BOUNDS",
+      function(name) {
+        if (name) {
+          return `${name} is outside of buffer bounds`;
+        }
+        return "Attempt to access memory outside buffer bounds";
+      },
+      RangeError
+    );
+    E(
+      "ERR_INVALID_ARG_TYPE",
+      function(name, actual) {
+        return `The "${name}" argument must be of type number. Received type ${typeof actual}`;
+      },
+      TypeError
+    );
+    E(
+      "ERR_OUT_OF_RANGE",
+      function(str, range2, input) {
+        let msg = `The value of "${str}" is out of range.`;
+        let received = input;
+        if (Number.isInteger(input) && Math.abs(input) > 2 ** 32) {
+          received = addNumericalSeparator(String(input));
+        } else if (typeof input === "bigint") {
+          received = String(input);
+          if (input > BigInt(2) ** BigInt(32) || input < -(BigInt(2) ** BigInt(32))) {
+            received = addNumericalSeparator(received);
+          }
+          received += "n";
+        }
+        msg += ` It must be ${range2}. Received ${received}`;
+        return msg;
+      },
+      RangeError
+    );
+    function addNumericalSeparator(val) {
+      let res = "";
+      let i = val.length;
+      const start = val[0] === "-" ? 1 : 0;
+      for (; i >= start + 4; i -= 3) {
+        res = `_${val.slice(i - 3, i)}${res}`;
+      }
+      return `${val.slice(0, i)}${res}`;
+    }
+    function checkBounds(buf, offset, byteLength2) {
+      validateNumber(offset, "offset");
+      if (buf[offset] === void 0 || buf[offset + byteLength2] === void 0) {
+        boundsError(offset, buf.length - (byteLength2 + 1));
+      }
+    }
+    function checkIntBI(value, min, max2, buf, offset, byteLength2) {
+      if (value > max2 || value < min) {
+        const n = typeof min === "bigint" ? "n" : "";
+        let range2;
+        if (byteLength2 > 3) {
+          if (min === 0 || min === BigInt(0)) {
+            range2 = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
+          } else {
+            range2 = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
+          }
+        } else {
+          range2 = `>= ${min}${n} and <= ${max2}${n}`;
+        }
+        throw new errors.ERR_OUT_OF_RANGE("value", range2, value);
+      }
+      checkBounds(buf, offset, byteLength2);
+    }
+    function validateNumber(value, name) {
+      if (typeof value !== "number") {
+        throw new errors.ERR_INVALID_ARG_TYPE(name, "number", value);
+      }
+    }
+    function boundsError(value, length, type) {
+      if (Math.floor(value) !== value) {
+        validateNumber(value, type);
+        throw new errors.ERR_OUT_OF_RANGE(type || "offset", "an integer", value);
+      }
+      if (length < 0) {
+        throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
+      }
+      throw new errors.ERR_OUT_OF_RANGE(
+        type || "offset",
+        `>= ${type ? 1 : 0} and <= ${length}`,
+        value
+      );
+    }
+    var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g;
+    function base64clean(str) {
+      str = str.split("=")[0];
+      str = str.trim().replace(INVALID_BASE64_RE, "");
+      if (str.length < 2) return "";
+      while (str.length % 4 !== 0) {
+        str = str + "=";
+      }
+      return str;
+    }
+    function utf8ToBytes(string, units) {
+      units = units || Infinity;
+      let codePoint;
+      const length = string.length;
+      let leadSurrogate = null;
+      const bytes2 = [];
+      for (let i = 0; i < length; ++i) {
+        codePoint = string.charCodeAt(i);
+        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) {
+              if ((units -= 3) > -1) bytes2.push(239, 191, 189);
+              continue;
+            }
+            leadSurrogate = codePoint;
+            continue;
+          }
+          if (codePoint < 56320) {
+            if ((units -= 3) > -1) bytes2.push(239, 191, 189);
+            leadSurrogate = codePoint;
+            continue;
+          }
+          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
+        } else if (leadSurrogate) {
+          if ((units -= 3) > -1) bytes2.push(239, 191, 189);
+        }
+        leadSurrogate = null;
+        if (codePoint < 128) {
+          if ((units -= 1) < 0) break;
+          bytes2.push(codePoint);
+        } else if (codePoint < 2048) {
+          if ((units -= 2) < 0) break;
+          bytes2.push(
+            codePoint >> 6 | 192,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 65536) {
+          if ((units -= 3) < 0) break;
+          bytes2.push(
+            codePoint >> 12 | 224,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else if (codePoint < 1114112) {
+          if ((units -= 4) < 0) break;
+          bytes2.push(
+            codePoint >> 18 | 240,
+            codePoint >> 12 & 63 | 128,
+            codePoint >> 6 & 63 | 128,
+            codePoint & 63 | 128
+          );
+        } else {
+          throw new Error("Invalid code point");
+        }
+      }
+      return bytes2;
+    }
+    function asciiToBytes(str) {
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        byteArray.push(str.charCodeAt(i) & 255);
+      }
+      return byteArray;
+    }
+    function utf16leToBytes(str, units) {
+      let c, hi, lo;
+      const byteArray = [];
+      for (let i = 0; i < str.length; ++i) {
+        if ((units -= 2) < 0) break;
+        c = str.charCodeAt(i);
+        hi = c >> 8;
+        lo = c % 256;
+        byteArray.push(lo);
+        byteArray.push(hi);
+      }
+      return byteArray;
+    }
+    function base64ToBytes(str) {
+      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];
+      }
+      return i;
+    }
+    function isInstance(obj, type) {
+      return obj instanceof type || obj != null && obj.constructor != null && obj.constructor.name != null && obj.constructor.name === type.name;
+    }
+    function numberIsNaN(obj) {
+      return obj !== obj;
+    }
+    var hexSliceLookupTable = (function() {
+      const alphabet = "0123456789abcdef";
+      const table2 = new Array(256);
+      for (let i = 0; i < 16; ++i) {
+        const i16 = i * 16;
+        for (let j = 0; j < 16; ++j) {
+          table2[i16 + j] = alphabet[i] + alphabet[j];
+        }
+      }
+      return table2;
+    })();
+    function defineBigIntMethod(fn) {
+      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
+    }
+    function BufferBigIntNotDefined() {
+      throw new Error("BigInt not supported");
+    }
+  }
+});
+
+// src/browser/buffer.ts
+var import_buffer;
+var init_buffer = __esm({
+  "src/browser/buffer.ts"() {
+    "use strict";
+    import_buffer = __toESM(require_buffer(), 1);
+  }
+});
+
+// src/browser.ts
+init_buffer();
+
+// src/nitro/nds-file.ts
+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
+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 isBytes(a) {
+  return a instanceof Uint8Array || ArrayBuffer.isView(a) && a.constructor.name === "Uint8Array" && "BYTES_PER_ELEMENT" in a && a.BYTES_PER_ELEMENT === 1;
+}
+var atitle = (title) => title ? `"${title}" ` : "";
+function anumber(n, title = "") {
+  if (typeof n !== "number")
+    throw new TypeError(atitle(title) + "expected number, got " + typeof n);
+  if (!Number.isSafeInteger(n) || n < 0)
+    throw new RangeError(atitle(title) + "expected integer >= 0, got " + n);
+  return n;
+}
+function abytes(value, length, title = "") {
+  if (isBytes(value) && (length === void 0 || value.length === length))
+    return value;
+  if (length !== void 0)
+    anumber(length, "length");
+  const bytes2 = isBytes(value);
+  const ofLen = length !== void 0 ? ` of length ${length}` : "";
+  const got = bytes2 ? `length=${value.length}` : `type=${typeof value}`;
+  const message = atitle(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");
+  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 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 i = 0; i < arrays.length; i++) {
+    arrays[i].fill(0);
+  }
+}
+function createView(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 = createView(this.buffer);
+  }
+  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;
+  }
+  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);
+    }
+    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 to;
+  }
+  clone() {
+    return this._cloneInto();
+  }
+};
+
+// node_modules/.pnpm/@noble+hashes@2.4.0/node_modules/@noble/hashes/legacy.js
+var SHA1_IV = /* @__PURE__ */ Uint32Array.from([
+  1732584193,
+  4023233417,
+  2562383102,
+  271733878,
+  3285377520
+]);
+var SHA1_W = /* @__PURE__ */ new Uint32Array(80);
+var _SHA1 = class extends HashMD {
+  A = SHA1_IV[0] | 0;
+  B = SHA1_IV[1] | 0;
+  C = SHA1_IV[2] | 0;
+  D = SHA1_IV[3] | 0;
+  E = SHA1_IV[4] | 0;
+  constructor() {
+    super(64, 20, 8, false);
+  }
+  get() {
+    const { A, B, C, D, E } = this;
+    return [A, B, C, D, E];
+  }
+  set(A, B, C, D, E) {
+    this.A = A | 0;
+    this.B = B | 0;
+    this.C = C | 0;
+    this.D = D | 0;
+    this.E = E | 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)
+      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);
+    let { A, B, C, D, E } = this;
+    for (let i = 0; i < 80; i++) {
+      let F, K2;
+      if (i < 20) {
+        F = Chi(B, C, D);
+        K2 = 1518500249;
+      } else if (i < 40) {
+        F = B ^ C ^ D;
+        K2 = 1859775393;
+      } else if (i < 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);
+      }
+    };
+    return wrCipher;
+  }
+  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);
+  }
+  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;
+  }
+  clean2(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 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];
+    }
+  }
+  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;
+  }
+  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];
+  }
+  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];
+  }
+  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;
+  }
+  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;
+  }
+  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);
+  }
+  if (dst !== void 0) {
+    getOutput(data.length, dst);
+    complexOverlapBytes(data, dst);
+  }
+}
+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;
+  }
+  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 i = 0; i < 16; i++) {
+    const shouldCheck = i - lastByte >>> 31;
+    const eq = (data[len - 1 - i] ^ 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 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);
+    }
+  };
+});
+
+// node_modules/.pnpm/fflate@0.8.3/node_modules/fflate/esm/browser.js
+init_buffer();
+var u82 = Uint8Array;
+var u16 = Uint16Array;
+var i32 = Int32Array;
+var fleb = new u82([
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  1,
+  1,
+  2,
+  2,
+  2,
+  2,
+  3,
+  3,
+  3,
+  3,
+  4,
+  4,
+  4,
+  4,
+  5,
+  5,
+  5,
+  5,
+  0,
+  /* unused */
+  0,
+  0,
+  /* impossible */
+  0
+]);
+var fdeb = new u82([
+  0,
+  0,
+  0,
+  0,
+  1,
+  1,
+  2,
+  2,
+  3,
+  3,
+  4,
+  4,
+  5,
+  5,
+  6,
+  6,
+  7,
+  7,
+  8,
+  8,
+  9,
+  9,
+  10,
+  10,
+  11,
+  11,
+  12,
+  12,
+  13,
+  13,
+  /* unused */
+  0,
+  0
+]);
+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];
+  }
+  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;
+    }
+  }
+  return { b, r };
+};
+var _a = freb(fleb, 2);
+var fl = _a.b;
+var revfl = _a.r;
+fl[28] = 258, revfl[258] = 28;
+var _b = freb(fdeb, 0);
+var fd = _b.b;
+var revfd = _b.r;
+var rev = new u16(32768);
+for (i = 0; i < 32768; ++i) {
+  x = (i & 43690) >> 1 | (i & 21845) << 1;
+  x = (x & 52428) >> 2 | (x & 13107) << 2;
+  x = (x & 61680) >> 4 | (x & 3855) << 4;
+  rev[i] = ((x & 65280) >> 8 | (x & 255) << 8) >> 1;
+}
+var x;
+var i;
+var hMap = (function(cd, mb, r) {
+  var s = cd.length;
+  var i = 0;
+  var l = new u16(mb);
+  for (; i < s; ++i) {
+    if (cd[i])
+      ++l[cd[i] - 1];
+  }
+  var le = new u16(mb);
+  for (i = 1; i < mb; ++i) {
+    le[i] = le[i - 1] + l[i - 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 (var m = v | (1 << r_1) - 1; v <= m; ++v) {
+          co[rev[v] >> rvb] = sv;
+        }
+      }
+    }
+  } else {
+    co = new u16(s);
+    for (i = 0; i < s; ++i) {
+      if (cd[i]) {
+        co[i] = rev[le[cd[i] - 1]++] >> 15 - cd[i];
+      }
+    }
+  }
+  return co;
+});
+var flt = new u82(288);
+for (i = 0; i < 144; ++i)
+  flt[i] = 8;
+var i;
+for (i = 144; i < 256; ++i)
+  flt[i] = 9;
+var i;
+for (i = 256; i < 280; ++i)
+  flt[i] = 7;
+var i;
+for (i = 280; i < 288; ++i)
+  flt[i] = 8;
+var i;
+var fdt = new u82(32);
+for (i = 0; i < 32; ++i)
+  fdt[i] = 5;
+var i;
+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];
+  }
+  return m;
+};
+var bits = function(d, p, m) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8) >> (p & 7) & m;
+};
+var bits16 = function(d, p) {
+  var o = p / 8 | 0;
+  return (d[o] | d[o + 1] << 8 | d[o + 2] << 16) >> (p & 7);
+};
+var shft = function(p) {
+  return (p + 7) / 8 | 0;
+};
+var slc = function(v, s, e) {
+  if (s == null || s < 0)
+    s = 0;
+  if (e == null || e > v.length)
+    e = v.length;
+  return new u82(v.subarray(s, e));
+};
+var ec = [
+  "unexpected EOF",
+  "invalid block type",
+  "invalid length/literal",
+  "invalid distance",
+  "stream finished",
+  "no stream handler",
+  ,
+  // determined by compression function
+  "no callback",
+  "invalid UTF-8 data",
+  "extra field too long",
+  "date not in range 1980-2099",
+  "filename too long",
+  "stream finishing",
+  "invalid zip data"
+  // determined by unknown compression method
+];
+var err = function(ind, msg, nt) {
+  var e = new Error(msg || ec[ind]);
+  e.code = ind;
+  if (Error.captureStackTrace)
+    Error.captureStackTrace(e, err);
+  if (!nt)
+    throw e;
+  return e;
+};
+var inflt = function(dat, st, buf, dict) {
+  var sl = dat.length, dl = dict ? dict.length : 0;
+  if (!sl || st.f && !st.l)
+    return buf || new u82(0);
+  var noBuf = !buf;
+  var resize = noBuf || st.i != 2;
+  var noSt = st.i;
+  if (noBuf)
+    buf = new u82(sl * 3);
+  var cbuf = function(l2) {
+    var bl = buf.length;
+    if (l2 > bl) {
+      var nbuf = new u82(Math.max(bl * 2, l2));
+      nbuf.set(buf);
+      buf = nbuf;
+    }
+  };
+  var final = st.f || 0, pos = st.p || 0, bt = st.b || 0, lm = st.l, dm = st.d, lbt = st.m, dbt = st.n;
+  var tbts = sl * 8;
+  do {
+    if (!lm) {
+      final = bits(dat, pos, 1);
+      var type = bits(dat, pos + 1, 3);
+      pos += 3;
+      if (!type) {
+        var s = shft(pos) + 4, l = dat[s - 4] | dat[s - 3] << 8, t = s + l;
+        if (t > sl) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + l);
+        buf.set(dat.subarray(s, t), bt);
+        st.b = bt += l, st.p = pos = t * 8, st.f = final;
+        continue;
+      } else if (type == 1)
+        lm = flrm, dm = fdrm, lbt = 9, dbt = 5;
+      else if (type == 2) {
+        var hLit = bits(dat, pos, 31) + 257, hcLen = bits(dat, pos + 10, 15) + 4;
+        var tl = hLit + bits(dat, pos + 5, 31) + 1;
+        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);
+        }
+        pos += hcLen * 3;
+        var clb = max(clt), clbmsk = (1 << clb) - 1;
+        var clm = hMap(clt, clb, 1);
+        for (var i = 0; i < tl; ) {
+          var r = clm[bits(dat, pos, clbmsk)];
+          pos += r & 15;
+          var s = r >> 4;
+          if (s < 16) {
+            ldt[i++] = s;
+          } else {
+            var c = 0, n = 0;
+            if (s == 16)
+              n = 3 + bits(dat, pos, 3), pos += 2, c = ldt[i - 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;
+          }
+        }
+        var lt = ldt.subarray(0, hLit), dt = ldt.subarray(hLit);
+        lbt = max(lt);
+        dbt = max(dt);
+        lm = hMap(lt, lbt, 1);
+        dm = hMap(dt, dbt, 1);
+      } else
+        err(1);
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+    }
+    if (resize)
+      cbuf(bt + 131072);
+    var lms = (1 << lbt) - 1, dms = (1 << dbt) - 1;
+    var lpos = pos;
+    for (; ; lpos = pos) {
+      var c = lm[bits16(dat, pos) & lms], sym = c >> 4;
+      pos += c & 15;
+      if (pos > tbts) {
+        if (noSt)
+          err(0);
+        break;
+      }
+      if (!c)
+        err(2);
+      if (sym < 256)
+        buf[bt++] = sym;
+      else if (sym == 256) {
+        lpos = pos, lm = null;
+        break;
+      } else {
+        var add = sym - 254;
+        if (sym > 264) {
+          var i = sym - 257, b = fleb[i];
+          add = bits(dat, pos, (1 << b) - 1) + fl[i];
+          pos += b;
+        }
+        var d = dm[bits16(dat, pos) & dms], dsym = d >> 4;
+        if (!d)
+          err(3);
+        pos += d & 15;
+        var dt = fd[dsym];
+        if (dsym > 3) {
+          var b = fdeb[dsym];
+          dt += bits16(dat, pos) & (1 << b) - 1, pos += b;
+        }
+        if (pos > tbts) {
+          if (noSt)
+            err(0);
+          break;
+        }
+        if (resize)
+          cbuf(bt + 131072);
+        var end = bt + add;
+        if (bt < dt) {
+          var shift = dl - dt, dend = Math.min(dt, end);
+          if (shift + bt < 0)
+            err(3);
+          for (; bt < dend; ++bt)
+            buf[bt] = dict[shift + bt];
+        }
+        for (; bt < end; ++bt)
+          buf[bt] = buf[bt - dt];
+      }
+    }
+    st.l = lm, st.p = lpos, st.b = bt, st.f = final;
+    if (lm)
+      final = 1, st.m = lbt, st.d = dm, st.n = dbt;
+  } while (!final);
+  return bt != buf.length && noBuf ? slc(buf, 0, bt) : buf.subarray(0, bt);
+};
+var et = /* @__PURE__ */ new u82(0);
+var Inflate = /* @__PURE__ */ (function() {
+  function Inflate2(opts, cb) {
+    if (typeof opts == "function")
+      cb = opts, opts = {};
+    this.ondata = cb;
+    var dict = opts && opts.dictionary && opts.dictionary.subarray(-32768);
+    this.s = { i: 0, b: dict ? dict.length : 0 };
+    this.o = new u82(32768);
+    this.p = new u82(0);
+    if (dict)
+      this.o.set(dict);
+  }
+  Inflate2.prototype.e = function(c) {
+    if (!this.ondata)
+      err(5);
+    if (this.d)
+      err(4);
+    if (!this.p.length)
+      this.p = c;
+    else if (c.length) {
+      var n = new u82(this.p.length + c.length);
+      n.set(this.p), n.set(c, this.p.length), this.p = n;
+    }
+  };
+  Inflate2.prototype.c = function(final) {
+    this.s.i = +(this.d = final || false);
+    var bts = this.s.b;
+    var dt = inflt(this.p, this.s, this.o);
+    this.ondata(slc(dt, bts, this.s.b), this.d);
+    this.o = slc(dt, this.s.b - 32768), this.s.b = this.o.length;
+    this.p = slc(this.p, this.s.p / 8 | 0), this.s.p &= 7;
+  };
+  Inflate2.prototype.push = function(chunk, final) {
+    this.e(chunk), this.c(final);
+  };
+  return Inflate2;
+})();
+var td = typeof TextDecoder != "undefined" && /* @__PURE__ */ new TextDecoder();
+var tds = 0;
+try {
+  td.decode(et, { stream: true });
+  tds = 1;
+} catch (e) {
+}
+
+// src/runtime/browser.ts
+var hashDigest = (algorithm, data) => import_buffer.Buffer.from((algorithm === "md5" ? md5 : sha1)(data));
+var hmacSha1 = (key2, data) => import_buffer.Buffer.from(hmac(sha1, key2, data));
+var createAesBlockCipher = (key2) => (block) => import_buffer.Buffer.from(ecb(key2, { disablePadding: true }).encrypt(block));
+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");
+    output.set(chunk, length);
+    length += chunk.length;
+  });
+  for (let offset = 0; offset < data.length; offset += 1024) {
+    stream.push(data.subarray(offset, offset + 1024), offset + 1024 >= data.length);
+  }
+  if (!data.length) stream.push(data, true);
+  return output.subarray(0, length);
+};
+var nodeOnly = () => {
+  throw new Error("Filesystem and RSA APIs are only available in the Node entry");
+};
+var readFile = nodeOnly;
+var writeFile = nodeOnly;
+var readFileSync = nodeOnly;
+
+// src/nitro/binary.ts
+init_buffer();
+var DEFAULT_MAX_SIZE = 1073741824;
+var bytes = (value, name = "input") => {
+  if (!(value instanceof Uint8Array)) throw new TypeError(`${name} must be a Buffer or Uint8Array`);
+  return import_buffer.Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+};
+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}`
+    );
+  }
+  return buffer.subarray(offset, offset + size);
+};
+var align = (value, alignment = 512) => {
+  return Math.ceil(value / alignment) * alignment;
+};
+var BinaryWriter = class {
+  maxSize;
+  buffer;
+  position;
+  length;
+  constructor(initialSize = 65536, maxSize = DEFAULT_MAX_SIZE) {
+    if (!Number.isSafeInteger(maxSize) || maxSize < 1 || maxSize > 4294967295)
+      throw new RangeError("Invalid output size limit");
+    this.maxSize = maxSize;
+    this.buffer = import_buffer.Buffer.alloc(Math.min(initialSize, maxSize));
+    this.position = 0;
+    this.length = 0;
+  }
+  ensure(end) {
+    if (!Number.isSafeInteger(end) || end < 0 || end > this.maxSize)
+      throw new RangeError(`Output exceeds size limit (${this.maxSize} bytes)`);
+    if (end <= this.buffer.length) return;
+    const next = import_buffer.Buffer.alloc(Math.min(this.maxSize, Math.max(end, this.buffer.length * 2, 1024)));
+    this.buffer.copy(next, 0, 0, this.length);
+    this.buffer = next;
+  }
+  write(data) {
+    data = bytes(data);
+    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;
+    this.length = Math.max(this.length, this.position);
+  }
+  fillTo(end, fill = 255) {
+    this.ensure(end);
+    if (end <= this.position) return;
+    this.buffer.fill(fill, this.position, end);
+    this.position = end;
+    this.length = Math.max(this.length, end);
+  }
+  pad(alignment, fill = 255) {
+    this.fillTo(align(this.position, alignment), fill);
+  }
+  toBuffer() {
+    return this.buffer.subarray(0, this.length);
+  }
+};
+
+// 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(
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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 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})`;
+  }
+};
+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, 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);
+
+// src/nitro/banner.ts
+init_buffer();
+var titles = [
+  "japaneseTitle",
+  "englishTitle",
+  "frenchTitle",
+  "germanTitle",
+  "italianTitle",
+  "spanishTitle",
+  "chineseTitle",
+  "koreanTitle"
+];
+var Banner = class {
+  version;
+  raw;
+  bannerCRC;
+  tileData;
+  palette;
+  japaneseTitle = "";
+  englishTitle = "";
+  frenchTitle = "";
+  germanTitle = "";
+  italianTitle = "";
+  spanishTitle = "";
+  chineseTitle = "";
+  koreanTitle = "";
+  constructor(input, offset = 0, hardSize = 0) {
+    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;
+    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] : "";
+  }
+  get titleCount() {
+    return this.version >= 3 ? 8 : this.version >= 2 ? 7 : 6;
+  }
+  getDefSize(hardSize = 0) {
+    if (this.version === 2) return 2368;
+    if (this.version === 3) return 2624;
+    if (this.version === 259) return hardSize > 0 && hardSize !== 4294967295 ? hardSize : 9152;
+    return 2112;
+  }
+  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");
+    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);
+    }
+    output.writeUInt16LE(crc16(output.subarray(32, 2112)), 2);
+    if (this.version >= 2) output.writeUInt16LE(crc16(output.subarray(32, 2368)), 4);
+    if (this.version >= 3) output.writeUInt16LE(crc16(output.subarray(32, 2624)), 6);
+    if (this.version >>> 8 >= 1) output.writeUInt16LE(crc16(output.subarray(4672, 9152)), 8);
+    return output;
+  }
+};
+
+// src/nitro/filesystem.ts
+init_buffer();
+var FileAllocationTable = class {
+  entries;
+  sortedIDs;
+  constructor(input, offset, size) {
+    const data = bytes(input);
+    const table2 = range(data, offset, size, "FAT");
+    if (size % 8 || size / 8 > 65535) throw new Error("Invalid FAT entry count");
+    this.entries = [];
+    for (let p = 0; p < size; p += 8) {
+      const start = table2.readUInt32LE(p), end = table2.readUInt32LE(p + 4);
+      range(data, start, end - start, `FAT entry ${p / 8}`);
+      this.entries.push({ id: p / 8, offset: start, size: end - start });
+    }
+    this.sortedIDs = [...this.entries].sort((a, b) => a.offset - b.offset || a.id - b.id).map((entry) => entry.id);
+  }
+};
+var FileNameTable = class _FileNameTable {
+  root;
+  constructor(fat, input, offset, size) {
+    const table2 = range(bytes(input), offset, size, "FNT");
+    range(table2, 0, 8, "FNT root directory");
+    const count = table2.readUInt16LE(6);
+    if (count < 1 || count > 4096) throw new Error("Invalid FNT directory count");
+    range(table2, 0, count * 8, "FNT directory table");
+    const decoder = new TextDecoder("shift_jis");
+    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");
+      visited.add(index);
+      let cursor = table2.readUInt32LE(index * 8);
+      let fileId = table2.readUInt16LE(index * 8 + 4);
+      if (cursor < count * 8) throw new Error("FNT directory names overlap directory table");
+      const folder = {
+        name,
+        id: index === 0 ? 65535 : 61440 + index,
+        files: [],
+        folders: []
+      };
+      const names = /* @__PURE__ */ new Set();
+      while (true) {
+        const tag = range(table2, cursor++, 1, "FNT name")[0];
+        if (!tag) break;
+        const length = tag & 127;
+        if (!length) throw new Error("Empty FNT directory name");
+        const filename2 = decoder.decode(range(table2, cursor, length, "FNT filename"));
+        cursor += length;
+        if (filename2.includes("/") || filename2.includes("\\") || filename2.includes("\0") || filename2 === "." || filename2 === "..")
+          throw new Error("Invalid FNT path component");
+        const normalized = filename2.toLowerCase();
+        if (names.has(normalized)) throw new Error(`Duplicate FNT path: ${filename2}`);
+        names.add(normalized);
+        if (tag & 128) {
+          const id = range(table2, cursor, 2, "FNT directory id").readUInt16LE();
+          cursor += 2;
+          if (id < 61440) throw new Error("Invalid FNT directory id");
+          folder.folders.push(parse(id & 4095, filename2, depth + 1));
+        } else {
+          const entry = fat.entries[fileId++];
+          if (!entry) throw new Error("FNT file id is outside FAT");
+          if (fileIds.has(entry.id)) throw new Error(`Duplicate FNT file id: ${entry.id}`);
+          fileIds.add(entry.id);
+          folder.files.push({ name: filename2, ...entry });
+        }
+      }
+      return folder;
+    };
+    this.root = { name: "root", id: 65535, files: [], folders: [parse(0, "data", 0)] };
+  }
+  static findFile(id, folder) {
+    for (const file of folder.files) if (file.id === id) return file;
+    for (const subfolder of folder.folders) {
+      const file = _FileNameTable.findFile(id, subfolder);
+      if (file) return file;
+    }
+    return void 0;
+  }
+};
+var overlayFields = [
+  "overlayId",
+  "ramAddress",
+  "ramSize",
+  "bssSize",
+  "staticInitialiserStartAddress",
+  "staticInitialiserEndAddress",
+  "fileId",
+  "reserved"
+];
+var OverlayTable = class {
+  constructor(input, offset, size, isArm9) {
+    this.isArm9 = isArm9;
+    if (!size) return;
+    const table2 = range(bytes(input), offset, size, "overlay table");
+    if (size % 32) throw new Error("Invalid overlay table size");
+    for (let p = 0; p < size; p += 32) {
+      if (table2.readUInt32LE(p) === 4294967295) break;
+      this.entries.push({
+        overlayId: table2.readUInt32LE(p),
+        ramAddress: table2.readUInt32LE(p + 4),
+        ramSize: table2.readUInt32LE(p + 8),
+        bssSize: table2.readUInt32LE(p + 12),
+        staticInitialiserStartAddress: table2.readUInt32LE(p + 16),
+        staticInitialiserEndAddress: table2.readUInt32LE(p + 20),
+        fileId: table2.readUInt32LE(p + 24),
+        reserved: table2.readUInt32LE(p + 28)
+      });
+    }
+  }
+  entries = [];
+  readBasicOverlays(fat) {
+    return this.entries.map((item) => {
+      const file = fat.entries[item.fileId];
+      if (!file) throw new Error("Overlay file id is outside FAT");
+      return {
+        ...file,
+        name: `overlay${this.isArm9 ? "" : "7"}_${String(item.overlayId).padStart(4, "0")}.bin`
+      };
+    });
+  }
+  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))
+    );
+    return data;
+  }
+};
+
+// src/nitro/twl.ts
+init_buffer();
+
+// src/nitro/blz.ts
+init_buffer();
+var decompressBLZ = (input, maxSize = 268435456) => {
+  if (input.length < 8) throw new Error("BLZ footer is truncated");
+  const diff = input.readUInt32LE(input.length - 4);
+  const packed = input.readUInt32LE(input.length - 8), header = packed >>> 24, length = packed & 16777215;
+  const size = input.length + diff, prefix = input.length - length;
+  if (header < 8 || header > length || length > input.length || size > maxSize)
+    throw new Error("Invalid BLZ size or footer");
+  const out = import_buffer.Buffer.alloc(size);
+  input.copy(out, 0, 0, prefix);
+  let src = input.length - header, dst = size;
+  while (src > prefix) {
+    const flags = input[--src];
+    for (let bit = 128; bit && src > prefix; bit >>= 1) {
+      if (!(flags & bit)) {
+        if (dst <= prefix) throw new Error("BLZ output overflow");
+        out[--dst] = input[--src];
+      } else {
+        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");
+        for (let j = 0; j < count; j++) {
+          --dst;
+          out[dst] = out[dst + offset];
+        }
+      }
+    }
+  }
+  if (dst !== prefix) throw new Error("BLZ decompressed size mismatch");
+  return out;
+};
+var compressBLZ = (input) => {
+  if (input.length > 16777215) throw new Error("BLZ input exceeds 24-bit format limit");
+  const temp = import_buffer.Buffer.alloc(input.length);
+  let src = input.length, dst = input.length;
+  const heads = new Int32Array(256).fill(-1);
+  const next = new Int32Array(input.length);
+  let indexedFrom = input.length;
+  while (src > 0) {
+    if (dst < 1) return import_buffer.Buffer.alloc(0);
+    const flagPos = --dst;
+    let flags = 0;
+    for (let bit = 0; bit < 8; bit++) {
+      flags <<= 1;
+      if (!src) continue;
+      while (indexedFrom > src) {
+        const p = --indexedFrom;
+        next[p] = heads[input[p]];
+        heads[input[p]] = p;
+      }
+      const maxCount = Math.min(src, 18);
+      let best = 0, offset = 0;
+      for (let p = heads[input[src - 1]]; p >= 0; p = next[p]) {
+        const d = p - src + 1;
+        if (d > 4098) break;
+        let n = 0;
+        const limit2 = Math.min(d, maxCount);
+        while (n < limit2 && input[src - 1 - n] === input[src + d - 1 - n]) n++;
+        if (n > best) {
+          best = n;
+          offset = d;
+          if (best === maxCount) break;
+        }
+      }
+      if (best < 3) {
+        if (dst < 1) return import_buffer.Buffer.alloc(0);
+        temp[--dst] = input[--src];
+      } else {
+        if (dst < 2) return import_buffer.Buffer.alloc(0);
+        src -= best;
+        dst -= 2;
+        temp[dst] = offset - 3 & 255;
+        temp[dst + 1] = best - 3 << 4 | offset - 3 >>> 8;
+        flags |= 1;
+      }
+    }
+    temp[flagPos] = flags;
+  }
+  let packed = temp.subarray(dst), sourcePos = input.length, compressedPos = packed.length, prefix = 0, skip = 0;
+  outer: while (sourcePos > 0) {
+    const flags = packed[--compressedPos];
+    for (let bit = 128; bit && sourcePos > 0; bit >>= 1) {
+      if (!(flags & bit)) {
+        compressedPos--;
+        sourcePos--;
+      } else {
+        sourcePos -= (packed[compressedPos - 1] >>> 4) + 3;
+        compressedPos -= 2;
+        if (sourcePos < compressedPos) {
+          prefix = sourcePos;
+          skip = compressedPos;
+          break outer;
+        }
+      }
+    }
+  }
+  packed = import_buffer.Buffer.concat([input.subarray(0, prefix), packed.subarray(skip)]);
+  const aligned = Math.ceil(packed.length / 4) * 4, finalSize = aligned + 8;
+  if (finalSize >= input.length) return import_buffer.Buffer.alloc(0);
+  const out = import_buffer.Buffer.alloc(finalSize, 255);
+  packed.copy(out);
+  const header = finalSize - packed.length, length = packed.length - prefix + header;
+  out.writeUInt32LE((header << 24 | length) >>> 0, finalSize - 8);
+  out.writeUInt32LE(input.length - finalSize, finalSize - 4);
+  return out;
+};
+var decompressArm9 = (data, header) => {
+  if (data.length < 24) throw new Error("ARM9 data too short");
+  const nitro = data.readUInt32LE(12) === 3737126433 ? 12 : 0;
+  const init = header.reserved2.readUInt32LE(0) & 16383;
+  const ptr = init ? data.readUInt32LE(init + 20) : header.ARM9ramAddress + header.ARM9size;
+  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)
+  };
+};
+var compressArm9 = (data, header, postSize = 0) => {
+  if (data.length < 16384) throw new Error("ARM9 secure area is truncated");
+  const nitro = data.readUInt32LE(12) === 3737126433 ? 12 : 0;
+  const packed = compressBLZ(data.subarray(16384, data.length - nitro));
+  if (!packed.length) throw new Error("ARM9 BLZ compression produced no smaller representation");
+  const out = import_buffer.Buffer.concat([data.subarray(0, 16384), packed, data.subarray(data.length - nitro)]);
+  const init = header.reserved2.readUInt32LE(0) & 16383;
+  if (init) out.writeUInt32LE(out.length - postSize + header.ARM9ramAddress, init + 20);
+  return out;
+};
+
+// src/nitro/twl.ts
+var HMAC_SHA1_KEY = import_buffer.Buffer.from(
+  "2106c0deba98ce3fa692e39d46f2ed0176e3cc08562363facad4ecdf9a6278348f6d633cfe22ca9220889723d2cfaec232678dfeca836498acfd3e3787465824",
+  "hex"
+);
+var hash = (data) => hmacSha1(HMAC_SHA1_KEY, data);
+function slice(data, start, size, label) {
+  if (!Number.isSafeInteger(start) || !Number.isSafeInteger(size) || start < 0 || size < 0 || start + size > data.length)
+    throw new RangeError(`${label} outside data range`);
+  return data.subarray(start, start + size);
+}
+function validate(h) {
+  for (const field2 of [
+    "digest_ntr_start",
+    "digest_ntr_size",
+    "digest_twl_start",
+    "digest_twl_size",
+    "sector_hashtable_start",
+    "sector_hashtable_size",
+    "block_hashtable_start",
+    "block_hashtable_size",
+    "dsi9_rom_offset",
+    "dsi9_size",
+    "dsi7_rom_offset",
+    "dsi7_size",
+    "modcrypt1_start",
+    "modcrypt1_size",
+    "modcrypt2_start",
+    "modcrypt2_size",
+    "total_rom_size"
+  ]) {
+    if (!Number.isSafeInteger(h[field2]) || h[field2] < 0 || h[field2] > 4294967295) {
+      throw new Error(`Invalid TWL ${field2}`);
+    }
+  }
+  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(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)
+    throw new Error("Invalid TWL digest region size");
+  const hashes = (h.digest_ntr_size + h.digest_twl_size) / s;
+  if (hashes * 20 > h.sector_hashtable_size || Math.ceil(h.sector_hashtable_size / (h.digest_block_sectorcount * 20)) * 20 > h.block_hashtable_size)
+    throw new Error("TWL hash tables are too small");
+}
+var TWL = class {
+  firstDSiHashOffset;
+  dsiHashSize;
+  Hashtable1Data;
+  Hashtable2Data;
+  Header2Data;
+  Overlays9Sha1Hmac;
+  twlEncrypted;
+  DSi9Data;
+  DSi7Data;
+  constructor(header, overlays, original) {
+    validate(header);
+    const h = header;
+    this.firstDSiHashOffset = h.digest_ntr_size / h.digest_sector_size * 20;
+    this.dsiHashSize = h.digest_twl_size / h.digest_sector_size * 20;
+    this.Hashtable1Data = import_buffer.Buffer.from(
+      slice(original, h.sector_hashtable_start, h.sector_hashtable_size, "Sector hash table")
+    );
+    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.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"))
+    );
+    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;
+    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"
+        )
+      );
+      encrypted = !actual.equals(
+        slice(
+          this.Hashtable1Data,
+          this.firstDSiHashOffset + index * 20,
+          20,
+          "Modcrypt sector hash"
+        )
+      );
+    }
+    if (encrypted) this.cryptSections(h);
+    this.twlEncrypted = !!(h.twlInternalFlags & 2);
+  }
+  cryptSections(h, writer) {
+    const key2 = modcryptKey(h);
+    for (const [id, data, start, counter] of [
+      [1, this.DSi9Data, h.dsi9_rom_offset, h.hmac_arm9],
+      [2, this.DSi7Data, h.dsi7_rom_offset, h.hmac_arm7]
+    ]) {
+      const size = h[`modcrypt${id}_size`];
+      if (!size) continue;
+      const off = h[`modcrypt${id}_start`] - start;
+      const result = aes128CtrCrypt(
+        key2,
+        slice(counter, 0, 16, "Modcrypt counter"),
+        slice(data, off, size, "Modcrypt payload")
+      );
+      if (writer) {
+        writer.position = start + off;
+        writer.write(result);
+      } else result.copy(data, off);
+    }
+  }
+  importArm9iData(data, offset = 0, size) {
+    this.DSi9Data = this.importData(data, offset, size);
+  }
+  importArm7iData(data, offset = 0, size) {
+    this.DSi7Data = this.importData(data, offset, size);
+  }
+  importData(data, offset, size) {
+    if (typeof data === "string") data = readFileSync(data);
+    size ??= data.length - offset;
+    const src = slice(data, offset, size, "DSi import");
+    const out = import_buffer.Buffer.alloc(Math.ceil(size / 16) * 16, 255);
+    src.copy(out);
+    return out;
+  }
+  updateOverlays9Sha1Hmac(arm9Data, header, overlays) {
+    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);
+    const init = header.reserved2.readUInt32LE(0) & 16383;
+    const hdrptr = arm9Data.readUInt32LE(init + 20) - header.ARM9ramAddress;
+    const unpacked = decompressArm9(arm9Data, header);
+    const end = unpacked.data.readUInt32LE(init + 8) - header.ARM9ramAddress;
+    let found = -1;
+    for (let p = Math.min(end - hashes.length * 20, unpacked.data.length - hashes.length * 20); p >= 0; p--) {
+      if (unpacked.data.subarray(p, p + 20).equals(this.Overlays9Sha1Hmac[0])) {
+        found = p;
+        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));
+    return unpacked.compressed ? compressArm9(unpacked.data, header, arm9Data.length - hdrptr) : unpacked.data;
+  }
+  writeTo(writer, h) {
+    validate(h);
+    if (writer.position > h.sector_hashtable_start) {
+      throw new Error("NTR output overlaps the fixed DSi sector hash table");
+    }
+    if (h.sector_hashtable_start + h.sector_hashtable_size > h.block_hashtable_start || h.block_hashtable_start + h.block_hashtable_size > h.dsi9_rom_offset || h.dsi9_rom_offset + this.DSi9Data.length > h.dsi7_rom_offset || h.dsi7_rom_offset + this.DSi7Data.length > h.total_rom_size) {
+      throw new Error("DSi sections overlap or exceed the ROM size");
+    }
+    const fill = (end) => {
+      if (writer.position < end) writer.fillTo(end, 255);
+    };
+    fill(h.sector_hashtable_start);
+    writer.position = h.sector_hashtable_start + h.sector_hashtable_size;
+    fill(h.block_hashtable_start);
+    writer.position = h.block_hashtable_start + h.block_hashtable_size;
+    fill(h.dsi9_rom_offset);
+    if (this.Header2Data && !h.trimmedRom) {
+      writer.position = h.digest_twl_start - 12288;
+      this.Header2Data.forEach((b) => writer.write(b));
+    }
+    writer.position = h.dsi9_rom_offset;
+    writer.write(this.DSi9Data);
+    fill(h.dsi7_rom_offset);
+    writer.position = h.dsi7_rom_offset;
+    writer.write(this.DSi7Data);
+    fill(h.total_rom_size);
+    const finalPosition = writer.position;
+    const read = (p, n) => slice(writer.buffer.subarray(0, writer.length), p, n, "TWL output digest");
+    let secure = import_buffer.Buffer.from(read(h.digest_ntr_start, 16384));
+    if (h.decrypted) secure = encryptSecureArea(h.gameCode, secure);
+    let index = 0;
+    const put = (b) => {
+      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 = 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)
+      put(read(p, h.digest_sector_size));
+    index = 0;
+    for (let p = h.sector_hashtable_start; p < h.sector_hashtable_start + h.sector_hashtable_size; p += h.digest_block_sectorcount * 20) {
+      const digest = hash(read(p, h.digest_block_sectorcount * 20));
+      writer.position = h.block_hashtable_start + index++ * 20;
+      writer.write(digest);
+    }
+    h.hmac_digest_master = hash(read(h.block_hashtable_start, h.block_hashtable_size));
+    if (this.twlEncrypted) this.cryptSections(h, writer);
+    writer.position = finalPosition;
+    return h.hmac_digest_master;
+  }
+};
+
+// src/nitro/nds-file.ts
+var key = (path) => path.replaceAll("\\", "/").toLowerCase();
+var NDSFile = class _NDSFile {
+  original;
+  header;
+  banner;
+  fatTable;
+  fntTable;
+  overlay9Table;
+  overlay7Table;
+  root;
+  twl;
+  warnings = [];
+  paths = /* @__PURE__ */ new Map();
+  maxOutputSize;
+  constructor(input, options = {}) {
+    this.original = bytes(input, "ROM");
+    this.maxOutputSize = options.maxOutputSize ?? DEFAULT_MAX_SIZE;
+    this.header = new Header(this.original);
+    const h = this.header;
+    range(this.original, h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0), "ARM9");
+    range(this.original, h.ARM7romOffset, h.ARM7size, "ARM7");
+    this.banner = new Banner(this.original, h.bannerOffset, h.banner_size);
+    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
+    );
+    const arm9Overlays = this.overlay9Table.readBasicOverlays(this.fatTable);
+    this.root.folders.push({
+      name: "overlay",
+      id: 65535,
+      files: [...arm9Overlays, ...this.overlay7Table.readBasicOverlays(this.fatTable)],
+      folders: []
+    });
+    const system = (name, offset, size) => {
+      range(this.original, offset, size, name);
+      this.root.files.push({ name, id: 65535, offset, size });
+    };
+    system("header.bin", 0, h.headerSize);
+    system("banner.bin", h.bannerOffset, this.banner.raw.length);
+    system("fnt.bin", h.FNToffset, h.FNTsize);
+    system("fat.bin", h.FAToffset, h.FATsize);
+    system("arm9.bin", h.ARM9romOffset, h.ARM9size + (h.nitrocode ? 12 : 0));
+    system("arm7.bin", h.ARM7romOffset, h.ARM7size);
+    if (h.ARM9overlaySize) system("overarm9.bin", h.ARM9overlayOffset, h.ARM9overlaySize);
+    if (h.ARM7overlaySize) system("overarm7.bin", h.ARM7overlayOffset, h.ARM7overlaySize);
+    const visit = (folder, prefix) => {
+      for (const file of folder.files) {
+        const path = prefix + file.name;
+        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 + "/");
+    };
+    visit(this.root, "");
+    if (h.unitCode & 2 && h.twlInternalFlags & 1 && h.tid_high && h.tid_high !== 4294967295) {
+      this.twl = new TWL(h, arm9Overlays, this.original);
+    }
+  }
+  static async fromFile(path, options = {}) {
+    return new _NDSFile(await readFile(path), options);
+  }
+  get data() {
+    return this.root.folders[0];
+  }
+  get overlay() {
+    return this.root.folders[1];
+  }
+  listFiles() {
+    return [...this.paths.values()].map(({ path, file }) => ({
+      path,
+      id: file.id,
+      offset: file.offset,
+      size: file.replacement?.length ?? file.size
+    }));
+  }
+  hasFile(path) {
+    return this.paths.has(key(path));
+  }
+  getFile(path) {
+    const entry = this.paths.get(key(path));
+    if (!entry) throw new Error(`ROM file not found: ${path}`);
+    return import_buffer.Buffer.from(this.fileBytes(entry.file));
+  }
+  /** Replace an existing file. Adding or deleting filesystem entries is not supported. */
+  replaceFile(path, content) {
+    const entry = this.paths.get(key(path));
+    if (!entry) throw new Error(`ROM file not found: ${path}`);
+    entry.file.replacement = import_buffer.Buffer.from(bytes(content));
+  }
+  fileBytes(file) {
+    return file.replacement ?? range(this.original, file.offset, file.size, file.name);
+  }
+  /** Rebuild offsets, allocation table, CRCs and ROM padding. Safe to call repeatedly. */
+  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
+      );
+      if (collect(replacementTree.root).join(",") !== collect(this.data).join(","))
+        throw new Error("Replacement FNT must preserve existing file IDs");
+    }
+    const h = new Header(this.header.toBuffer());
+    h.nitrocode = this.header.nitrocode;
+    h.decrypted = this.header.decrypted;
+    h.trimmedRom = this.header.trimmedRom;
+    h.dlp_signature = this.header.dlp_signature;
+    const writer = new BinaryWriter(65536, this.maxOutputSize);
+    const system = (name) => {
+      const file = this.root.files.find((file2) => file2.name === name);
+      if (!file) throw new Error(`Missing ROM system file: ${name}`);
+      return file;
+    };
+    const replacedHeader = system("header.bin").replacement;
+    if (replacedHeader) {
+      const replacement = new Header(replacedHeader);
+      h.gameTitle = replacement.gameTitle;
+      h.gameCode = replacement.gameCode;
+    }
+    const placements = /* @__PURE__ */ new Map();
+    const write = (file, padding = true) => {
+      const start = writer.position;
+      writer.write(this.fileBytes(file));
+      if (file.id !== 65535) placements.set(file.id, { start, end: writer.position });
+      if (padding) writer.pad(512);
+    };
+    const overlayIds = /* @__PURE__ */ new Set();
+    const writeOverlays = (arm92) => {
+      const originalTable = arm92 ? this.overlay9Table : this.overlay7Table;
+      const name = arm92 ? "overarm9.bin" : "overarm7.bin";
+      const entry = this.root.files.find((file) => file.name === name);
+      if (!entry) return;
+      const raw = entry.replacement ?? originalTable.toBuffer();
+      const table2 = new OverlayTable(raw, 0, raw.length, arm92);
+      const files = this.overlay.files.filter((file) => file.name.startsWith(arm92 ? "overlay_" : "overlay7_")).sort((a, b) => a.id - b.id);
+      for (const file of files) {
+        const item = table2.entries.find((item2) => item2.fileId === file.id);
+        if (!item) throw new Error(`Replacement overlay table is missing file id ${file.id}`);
+        const size = this.fileBytes(file).length;
+        if (item.reserved >>> 24 & 1 || !arm92 && item.reserved > 0)
+          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");
+      const encoded = table2.toBuffer();
+      if (arm92) {
+        h.ARM9overlayOffset = writer.position;
+        h.ARM9overlaySize = encoded.length;
+      } else {
+        h.ARM7overlayOffset = writer.position;
+        h.ARM7overlaySize = encoded.length;
+      }
+      writer.write(encoded);
+      writer.pad(512);
+      for (const file of files) write(file);
+    };
+    writer.position = h.headerSize;
+    h.ARM9romOffset = writer.position;
+    const arm9 = system("arm9.bin");
+    const arm9Bytes = this.fileBytes(arm9);
+    if (arm9.replacement) {
+      h.nitrocode = arm9Bytes.length >= 12 && arm9Bytes.readUInt32LE(arm9Bytes.length - 12) === 3737126433;
+    }
+    h.ARM9size = arm9Bytes.length - (h.nitrocode ? 12 : 0);
+    write(arm9);
+    h.ARM9overlayOffset = 0;
+    writeOverlays(true);
+    h.ARM7romOffset = writer.position;
+    h.ARM7size = this.fileBytes(system("arm7.bin")).length;
+    write(system("arm7.bin"));
+    h.ARM7overlayOffset = 0;
+    writeOverlays(false);
+    h.FNToffset = writer.position;
+    h.FNTsize = this.fileBytes(system("fnt.bin")).length;
+    write(system("fnt.bin"));
+    h.FAToffset = writer.position;
+    h.FATsize = this.fatTable.entries.length * 8;
+    writer.write(import_buffer.Buffer.alloc(h.FATsize));
+    writer.pad(512);
+    h.bannerOffset = writer.position;
+    const bannerFile = system("banner.bin");
+    const banner = bannerFile.replacement ? new Banner(bannerFile.replacement, 0, bannerFile.replacement.length) : this.banner;
+    const bannerBytes = banner.toBuffer();
+    if (h.unitCode & 2 && h.headerSize > 512) h.banner_size = bannerBytes.length;
+    writer.write(bannerBytes);
+    writer.pad(512);
+    for (const [index, id] of this.fatTable.sortedIDs.entries()) {
+      if (overlayIds.has(id)) continue;
+      const file = FileNameTable.findFile(id, this.root);
+      if (file) write(file, index < this.fatTable.sortedIDs.length - 1);
+      else {
+        const entry = this.fatTable.entries[id];
+        if (entry.size > 0) {
+          write({ ...entry, name: `FAT entry ${id}` }, index < this.fatTable.sortedIDs.length - 1);
+        }
+      }
+    }
+    const logicalEnd = writer.position;
+    const fat = import_buffer.Buffer.alloc(h.FATsize);
+    for (const [id, location] of placements) {
+      fat.writeUInt32LE(location.start, id * 8);
+      fat.writeUInt32LE(location.end, id * 8 + 4);
+    }
+    writer.position = h.FAToffset;
+    writer.write(fat);
+    writer.position = logicalEnd;
+    h.decrypted = writer.length >= 16392 && writer.buffer.readBigUInt64LE(16384) === 0xe7ffdeffe7ffdeffn;
+    if (this.twl) this.twl.writeTo(writer, h);
+    h.ROMsize = writer.position;
+    h.size = 2 ** Math.ceil(Math.log2(Math.max(h.ROMsize + h.dlp_signature.length, 131072)));
+    const secure = writer.toBuffer().subarray(16384, 32768);
+    h.secureCRC16 = crc16(h.decrypted ? encryptSecureArea(h.gameCode, secure) : secure);
+    writer.position = 0;
+    writer.write(h.toBuffer());
+    writer.position = h.ROMsize;
+    writer.write(h.dlp_signature);
+    writer.fillTo(h.size);
+    return writer.toBuffer();
+  }
+  async saveAs(path) {
+    await writeFile(path, this.toBuffer());
+  }
+};
+
+// 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) => {
+  throw new Error(`VCDIFF: ${message}`);
+};
+var Reader = class {
+  constructor(bytes2, label = "patch") {
+    this.bytes = bytes2;
+    this.label = label;
+  }
+  pos = 0;
+  get remaining() {
+    return this.bytes.length - this.pos;
+  }
+  byte() {
+    if (!this.remaining) fail2(`truncated ${this.label}`);
+    return this.bytes[this.pos++];
+  }
+  integer() {
+    let value = 0;
+    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 (!(byte & 128)) return value;
+    }
+    return fail2(`invalid variable-length integer in ${this.label}`);
+  }
+  take(size) {
+    if (size > this.remaining)
+      fail2(`truncated ${this.label}: requested ${size} bytes, ${this.remaining} remain`);
+    const result = this.bytes.subarray(this.pos, this.pos + size);
+    this.pos += size;
+    return result;
+  }
+};
+var table = [];
+var op = (type, size, mode = 0) => ({ type, size, mode });
+table.push([op("RUN", 0)]);
+for (let size = 0; size <= 17; size++) table.push([op("ADD", size)]);
+for (let mode = 0; mode <= 8; mode++) {
+  table.push([op("COPY", 0, mode)]);
+  for (let size = 4; size <= 18; size++) table.push([op("COPY", size, mode)]);
+}
+for (let mode = 0; mode <= 5; mode++) {
+  for (let add = 1; add <= 4; add++) {
+    for (let copy = 4; copy <= 6; copy++) table.push([op("ADD", add), op("COPY", copy, mode)]);
+  }
+}
+for (let mode = 6; mode <= 8; mode++) {
+  for (let add = 1; add <= 4; add++) table.push([op("ADD", add), op("COPY", 4, mode)]);
+}
+for (let mode = 0; mode <= 8; mode++) table.push([op("COPY", 4, mode), op("ADD", 1)]);
+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];
+      b += a;
+    }
+    a %= 65521;
+    b %= 65521;
+  }
+  return b * 65536 + a >>> 0;
+}
+function asBuffer(value, name) {
+  if (!(value instanceof Uint8Array)) throw new TypeError(`${name} must be a Buffer or Uint8Array`);
+  return import_buffer.Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+}
+function limit(value, fallback, name) {
+  value ??= fallback;
+  if (!Number.isSafeInteger(value) || value < 0 || value > UINT32_MAX)
+    throw new RangeError(`${name} must be an integer between 0 and ${UINT32_MAX}`);
+  return value;
+}
+var decodeXdelta = (source, patch, options = {}) => {
+  const sourceBytes = asBuffer(source, "source");
+  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)");
+  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 & 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");
+    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");
+      if (indicator & 1) dictionary = sourceBytes.subarray(offset, offset + length);
+      else {
+        dictionary = import_buffer.Buffer.allocUnsafe(length);
+        let base = 0;
+        for (const previous of windows) {
+          const start = Math.max(offset, base), end = Math.min(offset + length, base + previous.length);
+          if (end > start) previous.copy(dictionary, start - offset, start - base, end - base);
+          base += previous.length;
+          if (base >= offset + length) break;
+        }
+      }
+    }
+    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");
+    const compressed = delta.byte();
+    if (compressed & ~7) fail2("unrecognized delta indicator bits");
+    if (compressed) fail2("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");
+    const target = import_buffer.Buffer.allocUnsafe(targetLength);
+    const near = new Uint32Array(4), same = new Uint32Array(768);
+    let nearIndex = 0, position = 0;
+    while (instructions.remaining) {
+      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 (type === "ADD") {
+          data.take(size).copy(target, position);
+        } else if (type === "RUN") {
+          target.fill(data.byte(), position, position + size);
+        } else {
+          const here = dictionary.length + position;
+          let address;
+          if (mode === 0) address = addresses.integer();
+          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}`);
+          near[nearIndex] = address;
+          nearIndex = (nearIndex + 1) % near.length;
+          same[address % same.length] = address;
+          let copied = 0;
+          if (address < dictionary.length) {
+            copied = Math.min(size, dictionary.length - address);
+            dictionary.copy(target, position, address, address + copied);
+          }
+          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");
+            target.copy(target, position + copied, from, from + count);
+            copied += count;
+          }
+        }
+        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");
+    windows.push(target);
+    total += targetLength;
+  }
+  return import_buffer.Buffer.concat(windows, total);
+};
+
+// src/nitro-patch-helper.ts
+var PatchReturnValue = Object.freeze({
+  SUCCESS: "SUCCESS",
+  MD5_MISMATCH: "MD5_MISMATCH"
+});
+var md52 = (data) => hashDigest("md5", data).toString("hex");
+var patchBuffer = (original, patch, options = {}) => {
+  const input = bytes(original, "original ROM");
+  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
+  );
+  let matched = true;
+  const md5File = patches.get("md5.txt");
+  if (md5File) {
+    matched = false;
+    for (const line of md5File.toString("utf8").split("\n")) {
+      const expected = line.trim();
+      if (!expected || expected.startsWith("#")) continue;
+      if (expected.length !== 32) throw new Error("md5.txt \u683C\u5F0F\u9519\u8BEF\uFF0C\u53EF\u80FD\u662F\u56E0\u4E3A\u8865\u4E01\u5305\u5DF2\u635F\u574F\u3002");
+      if (expected.toLowerCase() === inputMd5) {
+        matched = true;
+        break;
+      }
+    }
+  }
+  for (const { path } of rom.listFiles()) {
+    const normalized = path.replaceAll("\\", "/").toLowerCase();
+    const delta = patches.get(`xdelta/${normalized}`);
+    const replacement = delta ? decodeXdelta(rom.getFile(path), delta, options) : patches.get(normalized);
+    if (replacement) rom.replaceFile(path, replacement);
+  }
+  const buffer = rom.toBuffer();
+  return {
+    buffer,
+    returnValue: matched ? PatchReturnValue.SUCCESS : PatchReturnValue.MD5_MISMATCH,
+    inputMd5,
+    outputMd5: md52(buffer)
+  };
+};
+var patchIt = async (originalPath, patchPath, options = {}) => {
+  const [original, patch] = await Promise.all([readFile(originalPath), readFile(patchPath)]);
+  return patchBuffer(original, patch, options);
+};
+var PatchHelper = Object.freeze({ patchBuffer, patchIt });
+
+// src/browser.ts
+var inspectRom = (bytes2) => {
+  const rom = new NDSFile(bytes2);
+  return {
+    gameTitle: rom.header.gameTitle,
+    gameCode: rom.header.gameCode,
+    size: bytes2.byteLength,
+    fileCount: rom.listFiles().length,
+    checksums: {
+      header: rom.header.headerCRC,
+      logo: rom.header.logoCRC,
+      secureArea: rom.header.secureCRC,
+      banner: rom.banner.bannerCRC
+    }
+  };
+};
+var patchBuffer2 = (original, archive, options = {}) => {
+  const result = patchBuffer(original, archive, options);
+  const buffer = new Uint8Array(
+    result.buffer.buffer,
+    result.buffer.byteOffset,
+    result.buffer.byteLength
+  );
+  return {
+    buffer,
+    returnValue: result.returnValue,
+    inputMd5: result.inputMd5,
+    outputMd5: result.outputMd5
+  };
+};
+var PatchHelper2 = Object.freeze({ patchBuffer: patchBuffer2 });
+var NitroHelper = Object.freeze({ inspectRom });
+export {
+  NitroHelper,
+  PatchHelper2 as PatchHelper,
+  inspectRom,
+  patchBuffer2 as patchBuffer
+};
+/*! For license information please see browser.js.LEGAL.txt */
+//# sourceMappingURL=browser.js.map