@rpgjs/tiledmap 5.0.0-beta.2 → 5.0.0-beta.3

package/dist/server/index3.js

@@ -1,4943 +1,53 @@
-var TiledLayerType = /* @__PURE__ */ ((TiledLayerType2) => {
-  TiledLayerType2["Tile"] = "tilelayer";
-  TiledLayerType2["ObjectGroup"] = "objectgroup";
-  TiledLayerType2["Image"] = "imagelayer";
-  TiledLayerType2["Group"] = "group";
-  return TiledLayerType2;
-})(TiledLayerType || {});
-function getAugmentedNamespace(n) {
-  if (Object.prototype.hasOwnProperty.call(n, "__esModule")) return n;
-  var f = n.default;
-  if (typeof f == "function") {
-    var a = function a2() {
-      if (this instanceof a2) {
-        return Reflect.construct(f, arguments, this.constructor);
-      }
-      return f.apply(this, arguments);
-    };
-    a.prototype = f.prototype;
-  } else a = {};
-  Object.defineProperty(a, "__esModule", { value: true });
-  Object.keys(n).forEach(function(k) {
-    var d = Object.getOwnPropertyDescriptor(n, k);
-    Object.defineProperty(a, k, d.get ? d : {
-      enumerable: true,
-      get: function() {
-        return n[k];
-      }
-    });
-  });
-  return a;
-}
-var sax = {};
-const __viteBrowserExternal = {};
-const __viteBrowserExternal$1 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
-  __proto__: null,
-  default: __viteBrowserExternal
-}, Symbol.toStringTag, { value: "Module" }));
-const require$$0 = /* @__PURE__ */ getAugmentedNamespace(__viteBrowserExternal$1);
-var string_decoder = {};
-var safeBuffer = { exports: {} };
-var buffer = {};
-var base64Js = {};
-var hasRequiredBase64Js;
-function requireBase64Js() {
-  if (hasRequiredBase64Js) return base64Js;
-  hasRequiredBase64Js = 1;
-  base64Js.byteLength = byteLength;
-  base64Js.toByteArray = toByteArray;
-  base64Js.fromByteArray = fromByteArray;
-  var lookup = [];
-  var revLookup = [];
-  var Arr = typeof Uint8Array !== "undefined" ? Uint8Array : Array;
-  var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
-  for (var i = 0, len = code.length; i < len; ++i) {
-    lookup[i] = code[i];
-    revLookup[code.charCodeAt(i)] = i;
-  }
-  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("");
-  }
-  return base64Js;
-}
-var ieee754 = {};
-var hasRequiredIeee754;
-function requireIeee754() {
-  if (hasRequiredIeee754) return ieee754;
-  hasRequiredIeee754 = 1;
-  ieee754.read = function(buffer2, offset, isLE, 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 = isLE ? nBytes - 1 : 0;
-    var d = isLE ? -1 : 1;
-    var s = buffer2[offset + i];
-    i += d;
-    e = s & (1 << -nBits) - 1;
-    s >>= -nBits;
-    nBits += eLen;
-    for (; nBits > 0; e = e * 256 + buffer2[offset + i], i += d, nBits -= 8) {
-    }
-    m = e & (1 << -nBits) - 1;
-    e >>= -nBits;
-    nBits += mLen;
-    for (; nBits > 0; m = m * 256 + buffer2[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);
-  };
-  ieee754.write = function(buffer2, value, offset, isLE, 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 = isLE ? 0 : nBytes - 1;
-    var d = isLE ? 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; buffer2[offset + i] = m & 255, i += d, m /= 256, mLen -= 8) {
-    }
-    e = e << mLen | m;
-    eLen += mLen;
-    for (; eLen > 0; buffer2[offset + i] = e & 255, i += d, e /= 256, eLen -= 8) {
-    }
-    buffer2[offset + i - d] |= s * 128;
-  };
-  return ieee754;
-}
-var hasRequiredBuffer;
-function requireBuffer() {
-  if (hasRequiredBuffer) return buffer;
-  hasRequiredBuffer = 1;
-  (function(exports) {
-    const base64 = requireBase64Js();
-    const ieee7542 = requireIeee754();
-    const customInspectSymbol = typeof Symbol === "function" && typeof Symbol["for"] === "function" ? Symbol["for"]("nodejs.util.inspect.custom") : null;
-    exports.Buffer = Buffer2;
-    exports.SlowBuffer = SlowBuffer;
-    exports.INSPECT_MAX_BYTES = 50;
-    const K_MAX_LENGTH = 2147483647;
-    exports.kMaxLength = K_MAX_LENGTH;
-    Buffer2.TYPED_ARRAY_SUPPORT = typedArraySupport();
-    if (!Buffer2.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(Buffer2.prototype, "parent", {
-      enumerable: true,
-      get: function() {
-        if (!Buffer2.isBuffer(this)) return void 0;
-        return this.buffer;
-      }
-    });
-    Object.defineProperty(Buffer2.prototype, "offset", {
-      enumerable: true,
-      get: function() {
-        if (!Buffer2.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, Buffer2.prototype);
-      return buf;
-    }
-    function Buffer2(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);
-    }
-    Buffer2.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 Buffer2.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 Buffer2.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
-      );
-    }
-    Buffer2.from = function(value, encodingOrOffset, length) {
-      return from(value, encodingOrOffset, length);
-    };
-    Object.setPrototypeOf(Buffer2.prototype, Uint8Array.prototype);
-    Object.setPrototypeOf(Buffer2, 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);
-    }
-    Buffer2.alloc = function(size, fill, encoding) {
-      return alloc(size, fill, encoding);
-    };
-    function allocUnsafe(size) {
-      assertSize(size);
-      return createBuffer(size < 0 ? 0 : checked(size) | 0);
-    }
-    Buffer2.allocUnsafe = function(size) {
-      return allocUnsafe(size);
-    };
-    Buffer2.allocUnsafeSlow = function(size) {
-      return allocUnsafe(size);
-    };
-    function fromString(string, encoding) {
-      if (typeof encoding !== "string" || encoding === "") {
-        encoding = "utf8";
-      }
-      if (!Buffer2.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, Buffer2.prototype);
-      return buf;
-    }
-    function fromObject(obj) {
-      if (Buffer2.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 Buffer2.alloc(+length);
-    }
-    Buffer2.isBuffer = function isBuffer(b) {
-      return b != null && b._isBuffer === true && b !== Buffer2.prototype;
-    };
-    Buffer2.compare = function compare(a, b) {
-      if (isInstance(a, Uint8Array)) a = Buffer2.from(a, a.offset, a.byteLength);
-      if (isInstance(b, Uint8Array)) b = Buffer2.from(b, b.offset, b.byteLength);
-      if (!Buffer2.isBuffer(a) || !Buffer2.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;
-    };
-    Buffer2.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;
-      }
-    };
-    Buffer2.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 Buffer2.alloc(0);
-      }
-      let i;
-      if (length === void 0) {
-        length = 0;
-        for (i = 0; i < list.length; ++i) {
-          length += list[i].length;
-        }
-      }
-      const buffer2 = Buffer2.allocUnsafe(length);
-      let pos = 0;
-      for (i = 0; i < list.length; ++i) {
-        let buf = list[i];
-        if (isInstance(buf, Uint8Array)) {
-          if (pos + buf.length > buffer2.length) {
-            if (!Buffer2.isBuffer(buf)) buf = Buffer2.from(buf);
-            buf.copy(buffer2, pos);
-          } else {
-            Uint8Array.prototype.set.call(
-              buffer2,
-              buf,
-              pos
-            );
-          }
-        } else if (!Buffer2.isBuffer(buf)) {
-          throw new TypeError('"list" argument must be an Array of Buffers');
-        } else {
-          buf.copy(buffer2, pos);
-        }
-        pos += buf.length;
-      }
-      return buffer2;
-    };
-    function byteLength(string, encoding) {
-      if (Buffer2.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;
-        }
-      }
-    }
-    Buffer2.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;
-        }
-      }
-    }
-    Buffer2.prototype._isBuffer = true;
-    function swap(b, n, m) {
-      const i = b[n];
-      b[n] = b[m];
-      b[m] = i;
-    }
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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);
-    };
-    Buffer2.prototype.toLocaleString = Buffer2.prototype.toString;
-    Buffer2.prototype.equals = function equals(b) {
-      if (!Buffer2.isBuffer(b)) throw new TypeError("Argument must be a Buffer");
-      if (this === b) return true;
-      return Buffer2.compare(this, b) === 0;
-    };
-    Buffer2.prototype.inspect = function inspect() {
-      let str = "";
-      const max = exports.INSPECT_MAX_BYTES;
-      str = this.toString("hex", 0, max).replace(/(.{2})/g, "$1 ").trim();
-      if (this.length > max) str += " ... ";
-      return "<Buffer " + str + ">";
-    };
-    if (customInspectSymbol) {
-      Buffer2.prototype[customInspectSymbol] = Buffer2.prototype.inspect;
-    }
-    Buffer2.prototype.compare = function compare(target, start, end, thisStart, thisEnd) {
-      if (isInstance(target, Uint8Array)) {
-        target = Buffer2.from(target, target.offset, target.byteLength);
-      }
-      if (!Buffer2.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(buffer2, val, byteOffset, encoding, dir) {
-      if (buffer2.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 : buffer2.length - 1;
-      }
-      if (byteOffset < 0) byteOffset = buffer2.length + byteOffset;
-      if (byteOffset >= buffer2.length) {
-        if (dir) return -1;
-        else byteOffset = buffer2.length - 1;
-      } else if (byteOffset < 0) {
-        if (dir) byteOffset = 0;
-        else return -1;
-      }
-      if (typeof val === "string") {
-        val = Buffer2.from(val, encoding);
-      }
-      if (Buffer2.isBuffer(val)) {
-        if (val.length === 0) {
-          return -1;
-        }
-        return arrayIndexOf(buffer2, 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(buffer2, val, byteOffset);
-          } else {
-            return Uint8Array.prototype.lastIndexOf.call(buffer2, val, byteOffset);
-          }
-        }
-        return arrayIndexOf(buffer2, [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;
-    }
-    Buffer2.prototype.includes = function includes(val, byteOffset, encoding) {
-      return this.indexOf(val, byteOffset, encoding) !== -1;
-    };
-    Buffer2.prototype.indexOf = function indexOf(val, byteOffset, encoding) {
-      return bidirectionalIndexOf(this, val, byteOffset, encoding, true);
-    };
-    Buffer2.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);
-    }
-    Buffer2.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;
-        }
-      }
-    };
-    Buffer2.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);
-    }
-    const 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 bytes = buf.slice(start, end);
-      let res = "";
-      for (let i = 0; i < bytes.length - 1; i += 2) {
-        res += String.fromCharCode(bytes[i] + bytes[i + 1] * 256);
-      }
-      return res;
-    }
-    Buffer2.prototype.slice = function slice(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, Buffer2.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");
-    }
-    Buffer2.prototype.readUintLE = Buffer2.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 mul = 1;
-      let i = 0;
-      while (++i < byteLength2 && (mul *= 256)) {
-        val += this[offset + i] * mul;
-      }
-      return val;
-    };
-    Buffer2.prototype.readUintBE = Buffer2.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 mul = 1;
-      while (byteLength2 > 0 && (mul *= 256)) {
-        val += this[offset + --byteLength2] * mul;
-      }
-      return val;
-    };
-    Buffer2.prototype.readUint8 = Buffer2.prototype.readUInt8 = function readUInt8(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 1, this.length);
-      return this[offset];
-    };
-    Buffer2.prototype.readUint16LE = Buffer2.prototype.readUInt16LE = function readUInt16LE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 2, this.length);
-      return this[offset] | this[offset + 1] << 8;
-    };
-    Buffer2.prototype.readUint16BE = Buffer2.prototype.readUInt16BE = function readUInt16BE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 2, this.length);
-      return this[offset] << 8 | this[offset + 1];
-    };
-    Buffer2.prototype.readUint32LE = Buffer2.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;
-    };
-    Buffer2.prototype.readUint32BE = Buffer2.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]);
-    };
-    Buffer2.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));
-    });
-    Buffer2.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);
-    });
-    Buffer2.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 mul = 1;
-      let i = 0;
-      while (++i < byteLength2 && (mul *= 256)) {
-        val += this[offset + i] * mul;
-      }
-      mul *= 128;
-      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
-      return val;
-    };
-    Buffer2.prototype.readIntBE = function readIntBE(offset, byteLength2, noAssert) {
-      offset = offset >>> 0;
-      byteLength2 = byteLength2 >>> 0;
-      if (!noAssert) checkOffset(offset, byteLength2, this.length);
-      let i = byteLength2;
-      let mul = 1;
-      let val = this[offset + --i];
-      while (i > 0 && (mul *= 256)) {
-        val += this[offset + --i] * mul;
-      }
-      mul *= 128;
-      if (val >= mul) val -= Math.pow(2, 8 * byteLength2);
-      return val;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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];
-    };
-    Buffer2.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);
-    });
-    Buffer2.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);
-    });
-    Buffer2.prototype.readFloatLE = function readFloatLE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 4, this.length);
-      return ieee7542.read(this, offset, true, 23, 4);
-    };
-    Buffer2.prototype.readFloatBE = function readFloatBE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 4, this.length);
-      return ieee7542.read(this, offset, false, 23, 4);
-    };
-    Buffer2.prototype.readDoubleLE = function readDoubleLE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 8, this.length);
-      return ieee7542.read(this, offset, true, 52, 8);
-    };
-    Buffer2.prototype.readDoubleBE = function readDoubleBE(offset, noAssert) {
-      offset = offset >>> 0;
-      if (!noAssert) checkOffset(offset, 8, this.length);
-      return ieee7542.read(this, offset, false, 52, 8);
-    };
-    function checkInt(buf, value, offset, ext, max, min) {
-      if (!Buffer2.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance');
-      if (value > max || value < min) throw new RangeError('"value" argument is out of bounds');
-      if (offset + ext > buf.length) throw new RangeError("Index out of range");
-    }
-    Buffer2.prototype.writeUintLE = Buffer2.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 mul = 1;
-      let i = 0;
-      this[offset] = value & 255;
-      while (++i < byteLength2 && (mul *= 256)) {
-        this[offset + i] = value / mul & 255;
-      }
-      return offset + byteLength2;
-    };
-    Buffer2.prototype.writeUintBE = Buffer2.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 mul = 1;
-      this[offset + i] = value & 255;
-      while (--i >= 0 && (mul *= 256)) {
-        this[offset + i] = value / mul & 255;
-      }
-      return offset + byteLength2;
-    };
-    Buffer2.prototype.writeUint8 = Buffer2.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;
-    };
-    Buffer2.prototype.writeUint16LE = Buffer2.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;
-    };
-    Buffer2.prototype.writeUint16BE = Buffer2.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;
-    };
-    Buffer2.prototype.writeUint32LE = Buffer2.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;
-    };
-    Buffer2.prototype.writeUint32BE = Buffer2.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, max) {
-      checkIntBI(value, min, max, 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, max) {
-      checkIntBI(value, min, max, 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;
-    }
-    Buffer2.prototype.writeBigUInt64LE = defineBigIntMethod(function writeBigUInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
-    Buffer2.prototype.writeBigUInt64BE = defineBigIntMethod(function writeBigUInt64BE(value, offset = 0) {
-      return wrtBigUInt64BE(this, value, offset, BigInt(0), BigInt("0xffffffffffffffff"));
-    });
-    Buffer2.prototype.writeIntLE = function writeIntLE(value, offset, byteLength2, noAssert) {
-      value = +value;
-      offset = offset >>> 0;
-      if (!noAssert) {
-        const limit = Math.pow(2, 8 * byteLength2 - 1);
-        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
-      }
-      let i = 0;
-      let mul = 1;
-      let sub = 0;
-      this[offset] = value & 255;
-      while (++i < byteLength2 && (mul *= 256)) {
-        if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
-          sub = 1;
-        }
-        this[offset + i] = (value / mul >> 0) - sub & 255;
-      }
-      return offset + byteLength2;
-    };
-    Buffer2.prototype.writeIntBE = function writeIntBE(value, offset, byteLength2, noAssert) {
-      value = +value;
-      offset = offset >>> 0;
-      if (!noAssert) {
-        const limit = Math.pow(2, 8 * byteLength2 - 1);
-        checkInt(this, value, offset, byteLength2, limit - 1, -limit);
-      }
-      let i = byteLength2 - 1;
-      let mul = 1;
-      let sub = 0;
-      this[offset + i] = value & 255;
-      while (--i >= 0 && (mul *= 256)) {
-        if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
-          sub = 1;
-        }
-        this[offset + i] = (value / mul >> 0) - sub & 255;
-      }
-      return offset + byteLength2;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.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;
-    };
-    Buffer2.prototype.writeBigInt64LE = defineBigIntMethod(function writeBigInt64LE(value, offset = 0) {
-      return wrtBigUInt64LE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-    });
-    Buffer2.prototype.writeBigInt64BE = defineBigIntMethod(function writeBigInt64BE(value, offset = 0) {
-      return wrtBigUInt64BE(this, value, offset, -BigInt("0x8000000000000000"), BigInt("0x7fffffffffffffff"));
-    });
-    function checkIEEE754(buf, value, offset, ext, max, 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);
-      }
-      ieee7542.write(buf, value, offset, littleEndian, 23, 4);
-      return offset + 4;
-    }
-    Buffer2.prototype.writeFloatLE = function writeFloatLE(value, offset, noAssert) {
-      return writeFloat(this, value, offset, true, noAssert);
-    };
-    Buffer2.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);
-      }
-      ieee7542.write(buf, value, offset, littleEndian, 52, 8);
-      return offset + 8;
-    }
-    Buffer2.prototype.writeDoubleLE = function writeDoubleLE(value, offset, noAssert) {
-      return writeDouble(this, value, offset, true, noAssert);
-    };
-    Buffer2.prototype.writeDoubleBE = function writeDoubleBE(value, offset, noAssert) {
-      return writeDouble(this, value, offset, false, noAssert);
-    };
-    Buffer2.prototype.copy = function copy(target, targetStart, start, end) {
-      if (!Buffer2.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;
-    };
-    Buffer2.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" && !Buffer2.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 bytes = Buffer2.isBuffer(val) ? val : Buffer2.from(val, encoding);
-        const len = bytes.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] = bytes[i % len];
-        }
-      }
-      return this;
-    };
-    const 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, range, 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 ${range}. 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, max, buf, offset, byteLength2) {
-      if (value > max || value < min) {
-        const n = typeof min === "bigint" ? "n" : "";
-        let range;
-        {
-          if (min === 0 || min === BigInt(0)) {
-            range = `>= 0${n} and < 2${n} ** ${(byteLength2 + 1) * 8}${n}`;
-          } else {
-            range = `>= -(2${n} ** ${(byteLength2 + 1) * 8 - 1}${n}) and < 2 ** ${(byteLength2 + 1) * 8 - 1}${n}`;
-          }
-        }
-        throw new errors.ERR_OUT_OF_RANGE("value", range, 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("offset", "an integer", value);
-      }
-      if (length < 0) {
-        throw new errors.ERR_BUFFER_OUT_OF_BOUNDS();
-      }
-      throw new errors.ERR_OUT_OF_RANGE(
-        "offset",
-        `>= ${0} and <= ${length}`,
-        value
-      );
-    }
-    const 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 bytes = [];
-      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) bytes.push(239, 191, 189);
-              continue;
-            } else if (i + 1 === length) {
-              if ((units -= 3) > -1) bytes.push(239, 191, 189);
-              continue;
-            }
-            leadSurrogate = codePoint;
-            continue;
-          }
-          if (codePoint < 56320) {
-            if ((units -= 3) > -1) bytes.push(239, 191, 189);
-            leadSurrogate = codePoint;
-            continue;
-          }
-          codePoint = (leadSurrogate - 55296 << 10 | codePoint - 56320) + 65536;
-        } else if (leadSurrogate) {
-          if ((units -= 3) > -1) bytes.push(239, 191, 189);
-        }
-        leadSurrogate = null;
-        if (codePoint < 128) {
-          if ((units -= 1) < 0) break;
-          bytes.push(codePoint);
-        } else if (codePoint < 2048) {
-          if ((units -= 2) < 0) break;
-          bytes.push(
-            codePoint >> 6 | 192,
-            codePoint & 63 | 128
-          );
-        } else if (codePoint < 65536) {
-          if ((units -= 3) < 0) break;
-          bytes.push(
-            codePoint >> 12 | 224,
-            codePoint >> 6 & 63 | 128,
-            codePoint & 63 | 128
-          );
-        } else if (codePoint < 1114112) {
-          if ((units -= 4) < 0) break;
-          bytes.push(
-            codePoint >> 18 | 240,
-            codePoint >> 12 & 63 | 128,
-            codePoint >> 6 & 63 | 128,
-            codePoint & 63 | 128
-          );
-        } else {
-          throw new Error("Invalid code point");
-        }
-      }
-      return bytes;
-    }
-    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;
-    }
-    const hexSliceLookupTable = (function() {
-      const alphabet = "0123456789abcdef";
-      const table = new Array(256);
-      for (let i = 0; i < 16; ++i) {
-        const i16 = i * 16;
-        for (let j = 0; j < 16; ++j) {
-          table[i16 + j] = alphabet[i] + alphabet[j];
-        }
-      }
-      return table;
-    })();
-    function defineBigIntMethod(fn) {
-      return typeof BigInt === "undefined" ? BufferBigIntNotDefined : fn;
-    }
-    function BufferBigIntNotDefined() {
-      throw new Error("BigInt not supported");
-    }
-  })(buffer);
-  return buffer;
-}
-var hasRequiredSafeBuffer;
-function requireSafeBuffer() {
-  if (hasRequiredSafeBuffer) return safeBuffer.exports;
-  hasRequiredSafeBuffer = 1;
-  (function(module, exports) {
-    var buffer2 = requireBuffer();
-    var Buffer2 = buffer2.Buffer;
-    function copyProps(src, dst) {
-      for (var key in src) {
-        dst[key] = src[key];
-      }
-    }
-    if (Buffer2.from && Buffer2.alloc && Buffer2.allocUnsafe && Buffer2.allocUnsafeSlow) {
-      module.exports = buffer2;
-    } else {
-      copyProps(buffer2, exports);
-      exports.Buffer = SafeBuffer;
-    }
-    function SafeBuffer(arg, encodingOrOffset, length) {
-      return Buffer2(arg, encodingOrOffset, length);
-    }
-    SafeBuffer.prototype = Object.create(Buffer2.prototype);
-    copyProps(Buffer2, SafeBuffer);
-    SafeBuffer.from = function(arg, encodingOrOffset, length) {
-      if (typeof arg === "number") {
-        throw new TypeError("Argument must not be a number");
-      }
-      return Buffer2(arg, encodingOrOffset, length);
-    };
-    SafeBuffer.alloc = function(size, fill, encoding) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      var buf = Buffer2(size);
-      if (fill !== void 0) {
-        if (typeof encoding === "string") {
-          buf.fill(fill, encoding);
-        } else {
-          buf.fill(fill);
-        }
-      } else {
-        buf.fill(0);
-      }
-      return buf;
-    };
-    SafeBuffer.allocUnsafe = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return Buffer2(size);
-    };
-    SafeBuffer.allocUnsafeSlow = function(size) {
-      if (typeof size !== "number") {
-        throw new TypeError("Argument must be a number");
-      }
-      return buffer2.SlowBuffer(size);
-    };
-  })(safeBuffer, safeBuffer.exports);
-  return safeBuffer.exports;
-}
-var hasRequiredString_decoder;
-function requireString_decoder() {
-  if (hasRequiredString_decoder) return string_decoder;
-  hasRequiredString_decoder = 1;
-  var Buffer2 = requireSafeBuffer().Buffer;
-  var isEncoding = Buffer2.isEncoding || function(encoding) {
-    encoding = "" + encoding;
-    switch (encoding && encoding.toLowerCase()) {
-      case "hex":
-      case "utf8":
-      case "utf-8":
-      case "ascii":
-      case "binary":
-      case "base64":
-      case "ucs2":
-      case "ucs-2":
-      case "utf16le":
-      case "utf-16le":
-      case "raw":
-        return true;
-      default:
-        return false;
-    }
-  };
-  function _normalizeEncoding(enc) {
-    if (!enc) return "utf8";
-    var retried;
-    while (true) {
-      switch (enc) {
-        case "utf8":
-        case "utf-8":
-          return "utf8";
-        case "ucs2":
-        case "ucs-2":
-        case "utf16le":
-        case "utf-16le":
-          return "utf16le";
-        case "latin1":
-        case "binary":
-          return "latin1";
-        case "base64":
-        case "ascii":
-        case "hex":
-          return enc;
-        default:
-          if (retried) return;
-          enc = ("" + enc).toLowerCase();
-          retried = true;
-      }
-    }
-  }
-  function normalizeEncoding(enc) {
-    var nenc = _normalizeEncoding(enc);
-    if (typeof nenc !== "string" && (Buffer2.isEncoding === isEncoding || !isEncoding(enc))) throw new Error("Unknown encoding: " + enc);
-    return nenc || enc;
-  }
-  string_decoder.StringDecoder = StringDecoder;
-  function StringDecoder(encoding) {
-    this.encoding = normalizeEncoding(encoding);
-    var nb;
-    switch (this.encoding) {
-      case "utf16le":
-        this.text = utf16Text;
-        this.end = utf16End;
-        nb = 4;
-        break;
-      case "utf8":
-        this.fillLast = utf8FillLast;
-        nb = 4;
-        break;
-      case "base64":
-        this.text = base64Text;
-        this.end = base64End;
-        nb = 3;
-        break;
-      default:
-        this.write = simpleWrite;
-        this.end = simpleEnd;
-        return;
-    }
-    this.lastNeed = 0;
-    this.lastTotal = 0;
-    this.lastChar = Buffer2.allocUnsafe(nb);
-  }
-  StringDecoder.prototype.write = function(buf) {
-    if (buf.length === 0) return "";
-    var r;
-    var i;
-    if (this.lastNeed) {
-      r = this.fillLast(buf);
-      if (r === void 0) return "";
-      i = this.lastNeed;
-      this.lastNeed = 0;
-    } else {
-      i = 0;
-    }
-    if (i < buf.length) return r ? r + this.text(buf, i) : this.text(buf, i);
-    return r || "";
-  };
-  StringDecoder.prototype.end = utf8End;
-  StringDecoder.prototype.text = utf8Text;
-  StringDecoder.prototype.fillLast = function(buf) {
-    if (this.lastNeed <= buf.length) {
-      buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, this.lastNeed);
-      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
-    }
-    buf.copy(this.lastChar, this.lastTotal - this.lastNeed, 0, buf.length);
-    this.lastNeed -= buf.length;
-  };
-  function utf8CheckByte(byte) {
-    if (byte <= 127) return 0;
-    else if (byte >> 5 === 6) return 2;
-    else if (byte >> 4 === 14) return 3;
-    else if (byte >> 3 === 30) return 4;
-    return byte >> 6 === 2 ? -1 : -2;
-  }
-  function utf8CheckIncomplete(self, buf, i) {
-    var j = buf.length - 1;
-    if (j < i) return 0;
-    var nb = utf8CheckByte(buf[j]);
-    if (nb >= 0) {
-      if (nb > 0) self.lastNeed = nb - 1;
-      return nb;
-    }
-    if (--j < i || nb === -2) return 0;
-    nb = utf8CheckByte(buf[j]);
-    if (nb >= 0) {
-      if (nb > 0) self.lastNeed = nb - 2;
-      return nb;
-    }
-    if (--j < i || nb === -2) return 0;
-    nb = utf8CheckByte(buf[j]);
-    if (nb >= 0) {
-      if (nb > 0) {
-        if (nb === 2) nb = 0;
-        else self.lastNeed = nb - 3;
-      }
-      return nb;
-    }
-    return 0;
-  }
-  function utf8CheckExtraBytes(self, buf, p) {
-    if ((buf[0] & 192) !== 128) {
-      self.lastNeed = 0;
-      return "�";
-    }
-    if (self.lastNeed > 1 && buf.length > 1) {
-      if ((buf[1] & 192) !== 128) {
-        self.lastNeed = 1;
-        return "�";
-      }
-      if (self.lastNeed > 2 && buf.length > 2) {
-        if ((buf[2] & 192) !== 128) {
-          self.lastNeed = 2;
-          return "�";
-        }
-      }
-    }
-  }
-  function utf8FillLast(buf) {
-    var p = this.lastTotal - this.lastNeed;
-    var r = utf8CheckExtraBytes(this, buf);
-    if (r !== void 0) return r;
-    if (this.lastNeed <= buf.length) {
-      buf.copy(this.lastChar, p, 0, this.lastNeed);
-      return this.lastChar.toString(this.encoding, 0, this.lastTotal);
-    }
-    buf.copy(this.lastChar, p, 0, buf.length);
-    this.lastNeed -= buf.length;
-  }
-  function utf8Text(buf, i) {
-    var total = utf8CheckIncomplete(this, buf, i);
-    if (!this.lastNeed) return buf.toString("utf8", i);
-    this.lastTotal = total;
-    var end = buf.length - (total - this.lastNeed);
-    buf.copy(this.lastChar, 0, end);
-    return buf.toString("utf8", i, end);
-  }
-  function utf8End(buf) {
-    var r = buf && buf.length ? this.write(buf) : "";
-    if (this.lastNeed) return r + "�";
-    return r;
-  }
-  function utf16Text(buf, i) {
-    if ((buf.length - i) % 2 === 0) {
-      var r = buf.toString("utf16le", i);
-      if (r) {
-        var c = r.charCodeAt(r.length - 1);
-        if (c >= 55296 && c <= 56319) {
-          this.lastNeed = 2;
-          this.lastTotal = 4;
-          this.lastChar[0] = buf[buf.length - 2];
-          this.lastChar[1] = buf[buf.length - 1];
-          return r.slice(0, -1);
-        }
-      }
-      return r;
-    }
-    this.lastNeed = 1;
-    this.lastTotal = 2;
-    this.lastChar[0] = buf[buf.length - 1];
-    return buf.toString("utf16le", i, buf.length - 1);
-  }
-  function utf16End(buf) {
-    var r = buf && buf.length ? this.write(buf) : "";
-    if (this.lastNeed) {
-      var end = this.lastTotal - this.lastNeed;
-      return r + this.lastChar.toString("utf16le", 0, end);
-    }
-    return r;
-  }
-  function base64Text(buf, i) {
-    var n = (buf.length - i) % 3;
-    if (n === 0) return buf.toString("base64", i);
-    this.lastNeed = 3 - n;
-    this.lastTotal = 3;
-    if (n === 1) {
-      this.lastChar[0] = buf[buf.length - 1];
-    } else {
-      this.lastChar[0] = buf[buf.length - 2];
-      this.lastChar[1] = buf[buf.length - 1];
-    }
-    return buf.toString("base64", i, buf.length - n);
-  }
-  function base64End(buf) {
-    var r = buf && buf.length ? this.write(buf) : "";
-    if (this.lastNeed) return r + this.lastChar.toString("base64", 0, 3 - this.lastNeed);
-    return r;
-  }
-  function simpleWrite(buf) {
-    return buf.toString(this.encoding);
-  }
-  function simpleEnd(buf) {
-    return buf && buf.length ? this.write(buf) : "";
-  }
-  return string_decoder;
-}
-var hasRequiredSax;
-function requireSax() {
-  if (hasRequiredSax) return sax;
-  hasRequiredSax = 1;
-  (function(exports) {
-    (function(sax2) {
-      sax2.parser = function(strict, opt) {
-        return new SAXParser(strict, opt);
-      };
-      sax2.SAXParser = SAXParser;
-      sax2.SAXStream = SAXStream;
-      sax2.createStream = createStream;
-      sax2.MAX_BUFFER_LENGTH = 64 * 1024;
-      var buffers = [
-        "comment",
-        "sgmlDecl",
-        "textNode",
-        "tagName",
-        "doctype",
-        "procInstName",
-        "procInstBody",
-        "entity",
-        "attribName",
-        "attribValue",
-        "cdata",
-        "script"
-      ];
-      sax2.EVENTS = [
-        "text",
-        "processinginstruction",
-        "sgmldeclaration",
-        "doctype",
-        "comment",
-        "opentagstart",
-        "attribute",
-        "opentag",
-        "closetag",
-        "opencdata",
-        "cdata",
-        "closecdata",
-        "error",
-        "end",
-        "ready",
-        "script",
-        "opennamespace",
-        "closenamespace"
-      ];
-      function SAXParser(strict, opt) {
-        if (!(this instanceof SAXParser)) {
-          return new SAXParser(strict, opt);
-        }
-        var parser = this;
-        clearBuffers(parser);
-        parser.q = parser.c = "";
-        parser.bufferCheckPosition = sax2.MAX_BUFFER_LENGTH;
-        parser.opt = opt || {};
-        parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
-        parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
-        parser.tags = [];
-        parser.closed = parser.closedRoot = parser.sawRoot = false;
-        parser.tag = parser.error = null;
-        parser.strict = !!strict;
-        parser.noscript = !!(strict || parser.opt.noscript);
-        parser.state = S.BEGIN;
-        parser.strictEntities = parser.opt.strictEntities;
-        parser.ENTITIES = parser.strictEntities ? Object.create(sax2.XML_ENTITIES) : Object.create(sax2.ENTITIES);
-        parser.attribList = [];
-        if (parser.opt.xmlns) {
-          parser.ns = Object.create(rootNS);
-        }
-        if (parser.opt.unquotedAttributeValues === void 0) {
-          parser.opt.unquotedAttributeValues = !strict;
-        }
-        parser.trackPosition = parser.opt.position !== false;
-        if (parser.trackPosition) {
-          parser.position = parser.line = parser.column = 0;
-        }
-        emit(parser, "onready");
-      }
-      if (!Object.create) {
-        Object.create = function(o) {
-          function F() {
-          }
-          F.prototype = o;
-          var newf = new F();
-          return newf;
-        };
-      }
-      if (!Object.keys) {
-        Object.keys = function(o) {
-          var a = [];
-          for (var i in o) if (o.hasOwnProperty(i)) a.push(i);
-          return a;
-        };
-      }
-      function checkBufferLength(parser) {
-        var maxAllowed = Math.max(sax2.MAX_BUFFER_LENGTH, 10);
-        var maxActual = 0;
-        for (var i = 0, l = buffers.length; i < l; i++) {
-          var len = parser[buffers[i]].length;
-          if (len > maxAllowed) {
-            switch (buffers[i]) {
-              case "textNode":
-                closeText(parser);
-                break;
-              case "cdata":
-                emitNode(parser, "oncdata", parser.cdata);
-                parser.cdata = "";
-                break;
-              case "script":
-                emitNode(parser, "onscript", parser.script);
-                parser.script = "";
-                break;
-              default:
-                error(parser, "Max buffer length exceeded: " + buffers[i]);
-            }
-          }
-          maxActual = Math.max(maxActual, len);
-        }
-        var m = sax2.MAX_BUFFER_LENGTH - maxActual;
-        parser.bufferCheckPosition = m + parser.position;
-      }
-      function clearBuffers(parser) {
-        for (var i = 0, l = buffers.length; i < l; i++) {
-          parser[buffers[i]] = "";
-        }
-      }
-      function flushBuffers(parser) {
-        closeText(parser);
-        if (parser.cdata !== "") {
-          emitNode(parser, "oncdata", parser.cdata);
-          parser.cdata = "";
-        }
-        if (parser.script !== "") {
-          emitNode(parser, "onscript", parser.script);
-          parser.script = "";
-        }
-      }
-      SAXParser.prototype = {
-        end: function() {
-          end(this);
-        },
-        write,
-        resume: function() {
-          this.error = null;
-          return this;
-        },
-        close: function() {
-          return this.write(null);
-        },
-        flush: function() {
-          flushBuffers(this);
-        }
-      };
-      var Stream;
-      try {
-        Stream = require$$0.Stream;
-      } catch (ex) {
-        Stream = function() {
-        };
-      }
-      if (!Stream) Stream = function() {
-      };
-      var streamWraps = sax2.EVENTS.filter(function(ev) {
-        return ev !== "error" && ev !== "end";
-      });
-      function createStream(strict, opt) {
-        return new SAXStream(strict, opt);
-      }
-      function SAXStream(strict, opt) {
-        if (!(this instanceof SAXStream)) {
-          return new SAXStream(strict, opt);
-        }
-        Stream.apply(this);
-        this._parser = new SAXParser(strict, opt);
-        this.writable = true;
-        this.readable = true;
-        var me = this;
-        this._parser.onend = function() {
-          me.emit("end");
-        };
-        this._parser.onerror = function(er) {
-          me.emit("error", er);
-          me._parser.error = null;
-        };
-        this._decoder = null;
-        streamWraps.forEach(function(ev) {
-          Object.defineProperty(me, "on" + ev, {
-            get: function() {
-              return me._parser["on" + ev];
-            },
-            set: function(h) {
-              if (!h) {
-                me.removeAllListeners(ev);
-                me._parser["on" + ev] = h;
-                return h;
-              }
-              me.on(ev, h);
-            },
-            enumerable: true,
-            configurable: false
-          });
-        });
-      }
-      SAXStream.prototype = Object.create(Stream.prototype, {
-        constructor: {
-          value: SAXStream
-        }
-      });
-      SAXStream.prototype.write = function(data) {
-        if (typeof Buffer === "function" && typeof Buffer.isBuffer === "function" && Buffer.isBuffer(data)) {
-          if (!this._decoder) {
-            var SD = requireString_decoder().StringDecoder;
-            this._decoder = new SD("utf8");
-          }
-          data = this._decoder.write(data);
-        }
-        this._parser.write(data.toString());
-        this.emit("data", data);
-        return true;
-      };
-      SAXStream.prototype.end = function(chunk) {
-        if (chunk && chunk.length) {
-          this.write(chunk);
-        }
-        this._parser.end();
-        return true;
-      };
-      SAXStream.prototype.on = function(ev, handler) {
-        var me = this;
-        if (!me._parser["on" + ev] && streamWraps.indexOf(ev) !== -1) {
-          me._parser["on" + ev] = function() {
-            var args = arguments.length === 1 ? [arguments[0]] : Array.apply(null, arguments);
-            args.splice(0, 0, ev);
-            me.emit.apply(me, args);
-          };
-        }
-        return Stream.prototype.on.call(me, ev, handler);
-      };
-      var CDATA = "[CDATA[";
-      var DOCTYPE = "DOCTYPE";
-      var XML_NAMESPACE = "http://www.w3.org/XML/1998/namespace";
-      var XMLNS_NAMESPACE = "http://www.w3.org/2000/xmlns/";
-      var rootNS = { xml: XML_NAMESPACE, xmlns: XMLNS_NAMESPACE };
-      var nameStart = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-      var nameBody = /[:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-      var entityStart = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD]/;
-      var entityBody = /[#:_A-Za-z\u00C0-\u00D6\u00D8-\u00F6\u00F8-\u02FF\u0370-\u037D\u037F-\u1FFF\u200C-\u200D\u2070-\u218F\u2C00-\u2FEF\u3001-\uD7FF\uF900-\uFDCF\uFDF0-\uFFFD\u00B7\u0300-\u036F\u203F-\u2040.\d-]/;
-      function isWhitespace(c) {
-        return c === " " || c === "\n" || c === "\r" || c === "	";
-      }
-      function isQuote(c) {
-        return c === '"' || c === "'";
-      }
-      function isAttribEnd(c) {
-        return c === ">" || isWhitespace(c);
-      }
-      function isMatch(regex, c) {
-        return regex.test(c);
-      }
-      function notMatch(regex, c) {
-        return !isMatch(regex, c);
-      }
-      var S = 0;
-      sax2.STATE = {
-        BEGIN: S++,
-        // leading byte order mark or whitespace
-        BEGIN_WHITESPACE: S++,
-        // leading whitespace
-        TEXT: S++,
-        // general stuff
-        TEXT_ENTITY: S++,
-        // &amp and such.
-        OPEN_WAKA: S++,
-        // <
-        SGML_DECL: S++,
-        // <!BLARG
-        SGML_DECL_QUOTED: S++,
-        // <!BLARG foo "bar
-        DOCTYPE: S++,
-        // <!DOCTYPE
-        DOCTYPE_QUOTED: S++,
-        // <!DOCTYPE "//blah
-        DOCTYPE_DTD: S++,
-        // <!DOCTYPE "//blah" [ ...
-        DOCTYPE_DTD_QUOTED: S++,
-        // <!DOCTYPE "//blah" [ "foo
-        COMMENT_STARTING: S++,
-        // <!-
-        COMMENT: S++,
-        // <!--
-        COMMENT_ENDING: S++,
-        // <!-- blah -
-        COMMENT_ENDED: S++,
-        // <!-- blah --
-        CDATA: S++,
-        // <![CDATA[ something
-        CDATA_ENDING: S++,
-        // ]
-        CDATA_ENDING_2: S++,
-        // ]]
-        PROC_INST: S++,
-        // <?hi
-        PROC_INST_BODY: S++,
-        // <?hi there
-        PROC_INST_ENDING: S++,
-        // <?hi "there" ?
-        OPEN_TAG: S++,
-        // <strong
-        OPEN_TAG_SLASH: S++,
-        // <strong /
-        ATTRIB: S++,
-        // <a
-        ATTRIB_NAME: S++,
-        // <a foo
-        ATTRIB_NAME_SAW_WHITE: S++,
-        // <a foo _
-        ATTRIB_VALUE: S++,
-        // <a foo=
-        ATTRIB_VALUE_QUOTED: S++,
-        // <a foo="bar
-        ATTRIB_VALUE_CLOSED: S++,
-        // <a foo="bar"
-        ATTRIB_VALUE_UNQUOTED: S++,
-        // <a foo=bar
-        ATTRIB_VALUE_ENTITY_Q: S++,
-        // <foo bar="&quot;"
-        ATTRIB_VALUE_ENTITY_U: S++,
-        // <foo bar=&quot
-        CLOSE_TAG: S++,
-        // </a
-        CLOSE_TAG_SAW_WHITE: S++,
-        // </a   >
-        SCRIPT: S++,
-        // <script> ...
-        SCRIPT_ENDING: S++
-        // <script> ... <
-      };
-      sax2.XML_ENTITIES = {
-        "amp": "&",
-        "gt": ">",
-        "lt": "<",
-        "quot": '"',
-        "apos": "'"
-      };
-      sax2.ENTITIES = {
-        "amp": "&",
-        "gt": ">",
-        "lt": "<",
-        "quot": '"',
-        "apos": "'",
-        "AElig": 198,
-        "Aacute": 193,
-        "Acirc": 194,
-        "Agrave": 192,
-        "Aring": 197,
-        "Atilde": 195,
-        "Auml": 196,
-        "Ccedil": 199,
-        "ETH": 208,
-        "Eacute": 201,
-        "Ecirc": 202,
-        "Egrave": 200,
-        "Euml": 203,
-        "Iacute": 205,
-        "Icirc": 206,
-        "Igrave": 204,
-        "Iuml": 207,
-        "Ntilde": 209,
-        "Oacute": 211,
-        "Ocirc": 212,
-        "Ograve": 210,
-        "Oslash": 216,
-        "Otilde": 213,
-        "Ouml": 214,
-        "THORN": 222,
-        "Uacute": 218,
-        "Ucirc": 219,
-        "Ugrave": 217,
-        "Uuml": 220,
-        "Yacute": 221,
-        "aacute": 225,
-        "acirc": 226,
-        "aelig": 230,
-        "agrave": 224,
-        "aring": 229,
-        "atilde": 227,
-        "auml": 228,
-        "ccedil": 231,
-        "eacute": 233,
-        "ecirc": 234,
-        "egrave": 232,
-        "eth": 240,
-        "euml": 235,
-        "iacute": 237,
-        "icirc": 238,
-        "igrave": 236,
-        "iuml": 239,
-        "ntilde": 241,
-        "oacute": 243,
-        "ocirc": 244,
-        "ograve": 242,
-        "oslash": 248,
-        "otilde": 245,
-        "ouml": 246,
-        "szlig": 223,
-        "thorn": 254,
-        "uacute": 250,
-        "ucirc": 251,
-        "ugrave": 249,
-        "uuml": 252,
-        "yacute": 253,
-        "yuml": 255,
-        "copy": 169,
-        "reg": 174,
-        "nbsp": 160,
-        "iexcl": 161,
-        "cent": 162,
-        "pound": 163,
-        "curren": 164,
-        "yen": 165,
-        "brvbar": 166,
-        "sect": 167,
-        "uml": 168,
-        "ordf": 170,
-        "laquo": 171,
-        "not": 172,
-        "shy": 173,
-        "macr": 175,
-        "deg": 176,
-        "plusmn": 177,
-        "sup1": 185,
-        "sup2": 178,
-        "sup3": 179,
-        "acute": 180,
-        "micro": 181,
-        "para": 182,
-        "middot": 183,
-        "cedil": 184,
-        "ordm": 186,
-        "raquo": 187,
-        "frac14": 188,
-        "frac12": 189,
-        "frac34": 190,
-        "iquest": 191,
-        "times": 215,
-        "divide": 247,
-        "OElig": 338,
-        "oelig": 339,
-        "Scaron": 352,
-        "scaron": 353,
-        "Yuml": 376,
-        "fnof": 402,
-        "circ": 710,
-        "tilde": 732,
-        "Alpha": 913,
-        "Beta": 914,
-        "Gamma": 915,
-        "Delta": 916,
-        "Epsilon": 917,
-        "Zeta": 918,
-        "Eta": 919,
-        "Theta": 920,
-        "Iota": 921,
-        "Kappa": 922,
-        "Lambda": 923,
-        "Mu": 924,
-        "Nu": 925,
-        "Xi": 926,
-        "Omicron": 927,
-        "Pi": 928,
-        "Rho": 929,
-        "Sigma": 931,
-        "Tau": 932,
-        "Upsilon": 933,
-        "Phi": 934,
-        "Chi": 935,
-        "Psi": 936,
-        "Omega": 937,
-        "alpha": 945,
-        "beta": 946,
-        "gamma": 947,
-        "delta": 948,
-        "epsilon": 949,
-        "zeta": 950,
-        "eta": 951,
-        "theta": 952,
-        "iota": 953,
-        "kappa": 954,
-        "lambda": 955,
-        "mu": 956,
-        "nu": 957,
-        "xi": 958,
-        "omicron": 959,
-        "pi": 960,
-        "rho": 961,
-        "sigmaf": 962,
-        "sigma": 963,
-        "tau": 964,
-        "upsilon": 965,
-        "phi": 966,
-        "chi": 967,
-        "psi": 968,
-        "omega": 969,
-        "thetasym": 977,
-        "upsih": 978,
-        "piv": 982,
-        "ensp": 8194,
-        "emsp": 8195,
-        "thinsp": 8201,
-        "zwnj": 8204,
-        "zwj": 8205,
-        "lrm": 8206,
-        "rlm": 8207,
-        "ndash": 8211,
-        "mdash": 8212,
-        "lsquo": 8216,
-        "rsquo": 8217,
-        "sbquo": 8218,
-        "ldquo": 8220,
-        "rdquo": 8221,
-        "bdquo": 8222,
-        "dagger": 8224,
-        "Dagger": 8225,
-        "bull": 8226,
-        "hellip": 8230,
-        "permil": 8240,
-        "prime": 8242,
-        "Prime": 8243,
-        "lsaquo": 8249,
-        "rsaquo": 8250,
-        "oline": 8254,
-        "frasl": 8260,
-        "euro": 8364,
-        "image": 8465,
-        "weierp": 8472,
-        "real": 8476,
-        "trade": 8482,
-        "alefsym": 8501,
-        "larr": 8592,
-        "uarr": 8593,
-        "rarr": 8594,
-        "darr": 8595,
-        "harr": 8596,
-        "crarr": 8629,
-        "lArr": 8656,
-        "uArr": 8657,
-        "rArr": 8658,
-        "dArr": 8659,
-        "hArr": 8660,
-        "forall": 8704,
-        "part": 8706,
-        "exist": 8707,
-        "empty": 8709,
-        "nabla": 8711,
-        "isin": 8712,
-        "notin": 8713,
-        "ni": 8715,
-        "prod": 8719,
-        "sum": 8721,
-        "minus": 8722,
-        "lowast": 8727,
-        "radic": 8730,
-        "prop": 8733,
-        "infin": 8734,
-        "ang": 8736,
-        "and": 8743,
-        "or": 8744,
-        "cap": 8745,
-        "cup": 8746,
-        "int": 8747,
-        "there4": 8756,
-        "sim": 8764,
-        "cong": 8773,
-        "asymp": 8776,
-        "ne": 8800,
-        "equiv": 8801,
-        "le": 8804,
-        "ge": 8805,
-        "sub": 8834,
-        "sup": 8835,
-        "nsub": 8836,
-        "sube": 8838,
-        "supe": 8839,
-        "oplus": 8853,
-        "otimes": 8855,
-        "perp": 8869,
-        "sdot": 8901,
-        "lceil": 8968,
-        "rceil": 8969,
-        "lfloor": 8970,
-        "rfloor": 8971,
-        "lang": 9001,
-        "rang": 9002,
-        "loz": 9674,
-        "spades": 9824,
-        "clubs": 9827,
-        "hearts": 9829,
-        "diams": 9830
-      };
-      Object.keys(sax2.ENTITIES).forEach(function(key) {
-        var e = sax2.ENTITIES[key];
-        var s2 = typeof e === "number" ? String.fromCharCode(e) : e;
-        sax2.ENTITIES[key] = s2;
-      });
-      for (var s in sax2.STATE) {
-        sax2.STATE[sax2.STATE[s]] = s;
-      }
-      S = sax2.STATE;
-      function emit(parser, event, data) {
-        parser[event] && parser[event](data);
-      }
-      function emitNode(parser, nodeType, data) {
-        if (parser.textNode) closeText(parser);
-        emit(parser, nodeType, data);
-      }
-      function closeText(parser) {
-        parser.textNode = textopts(parser.opt, parser.textNode);
-        if (parser.textNode) emit(parser, "ontext", parser.textNode);
-        parser.textNode = "";
-      }
-      function textopts(opt, text) {
-        if (opt.trim) text = text.trim();
-        if (opt.normalize) text = text.replace(/\s+/g, " ");
-        return text;
-      }
-      function error(parser, er) {
-        closeText(parser);
-        if (parser.trackPosition) {
-          er += "\nLine: " + parser.line + "\nColumn: " + parser.column + "\nChar: " + parser.c;
-        }
-        er = new Error(er);
-        parser.error = er;
-        emit(parser, "onerror", er);
-        return parser;
-      }
-      function end(parser) {
-        if (parser.sawRoot && !parser.closedRoot) strictFail(parser, "Unclosed root tag");
-        if (parser.state !== S.BEGIN && parser.state !== S.BEGIN_WHITESPACE && parser.state !== S.TEXT) {
-          error(parser, "Unexpected end");
-        }
-        closeText(parser);
-        parser.c = "";
-        parser.closed = true;
-        emit(parser, "onend");
-        SAXParser.call(parser, parser.strict, parser.opt);
-        return parser;
-      }
-      function strictFail(parser, message) {
-        if (typeof parser !== "object" || !(parser instanceof SAXParser)) {
-          throw new Error("bad call to strictFail");
-        }
-        if (parser.strict) {
-          error(parser, message);
-        }
-      }
-      function newTag(parser) {
-        if (!parser.strict) parser.tagName = parser.tagName[parser.looseCase]();
-        var parent = parser.tags[parser.tags.length - 1] || parser;
-        var tag = parser.tag = { name: parser.tagName, attributes: {} };
-        if (parser.opt.xmlns) {
-          tag.ns = parent.ns;
-        }
-        parser.attribList.length = 0;
-        emitNode(parser, "onopentagstart", tag);
-      }
-      function qname(name, attribute) {
-        var i = name.indexOf(":");
-        var qualName = i < 0 ? ["", name] : name.split(":");
-        var prefix = qualName[0];
-        var local = qualName[1];
-        if (attribute && name === "xmlns") {
-          prefix = "xmlns";
-          local = "";
-        }
-        return { prefix, local };
-      }
-      function attrib(parser) {
-        if (!parser.strict) {
-          parser.attribName = parser.attribName[parser.looseCase]();
-        }
-        if (parser.attribList.indexOf(parser.attribName) !== -1 || parser.tag.attributes.hasOwnProperty(parser.attribName)) {
-          parser.attribName = parser.attribValue = "";
-          return;
-        }
-        if (parser.opt.xmlns) {
-          var qn = qname(parser.attribName, true);
-          var prefix = qn.prefix;
-          var local = qn.local;
-          if (prefix === "xmlns") {
-            if (local === "xml" && parser.attribValue !== XML_NAMESPACE) {
-              strictFail(
-                parser,
-                "xml: prefix must be bound to " + XML_NAMESPACE + "\nActual: " + parser.attribValue
-              );
-            } else if (local === "xmlns" && parser.attribValue !== XMLNS_NAMESPACE) {
-              strictFail(
-                parser,
-                "xmlns: prefix must be bound to " + XMLNS_NAMESPACE + "\nActual: " + parser.attribValue
-              );
-            } else {
-              var tag = parser.tag;
-              var parent = parser.tags[parser.tags.length - 1] || parser;
-              if (tag.ns === parent.ns) {
-                tag.ns = Object.create(parent.ns);
-              }
-              tag.ns[local] = parser.attribValue;
-            }
-          }
-          parser.attribList.push([parser.attribName, parser.attribValue]);
-        } else {
-          parser.tag.attributes[parser.attribName] = parser.attribValue;
-          emitNode(parser, "onattribute", {
-            name: parser.attribName,
-            value: parser.attribValue
-          });
-        }
-        parser.attribName = parser.attribValue = "";
-      }
-      function openTag(parser, selfClosing) {
-        if (parser.opt.xmlns) {
-          var tag = parser.tag;
-          var qn = qname(parser.tagName);
-          tag.prefix = qn.prefix;
-          tag.local = qn.local;
-          tag.uri = tag.ns[qn.prefix] || "";
-          if (tag.prefix && !tag.uri) {
-            strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(parser.tagName));
-            tag.uri = qn.prefix;
-          }
-          var parent = parser.tags[parser.tags.length - 1] || parser;
-          if (tag.ns && parent.ns !== tag.ns) {
-            Object.keys(tag.ns).forEach(function(p) {
-              emitNode(parser, "onopennamespace", {
-                prefix: p,
-                uri: tag.ns[p]
-              });
-            });
-          }
-          for (var i = 0, l = parser.attribList.length; i < l; i++) {
-            var nv = parser.attribList[i];
-            var name = nv[0];
-            var value = nv[1];
-            var qualName = qname(name, true);
-            var prefix = qualName.prefix;
-            var local = qualName.local;
-            var uri = prefix === "" ? "" : tag.ns[prefix] || "";
-            var a = {
-              name,
-              value,
-              prefix,
-              local,
-              uri
-            };
-            if (prefix && prefix !== "xmlns" && !uri) {
-              strictFail(parser, "Unbound namespace prefix: " + JSON.stringify(prefix));
-              a.uri = prefix;
-            }
-            parser.tag.attributes[name] = a;
-            emitNode(parser, "onattribute", a);
-          }
-          parser.attribList.length = 0;
-        }
-        parser.tag.isSelfClosing = !!selfClosing;
-        parser.sawRoot = true;
-        parser.tags.push(parser.tag);
-        emitNode(parser, "onopentag", parser.tag);
-        if (!selfClosing) {
-          if (!parser.noscript && parser.tagName.toLowerCase() === "script") {
-            parser.state = S.SCRIPT;
-          } else {
-            parser.state = S.TEXT;
-          }
-          parser.tag = null;
-          parser.tagName = "";
-        }
-        parser.attribName = parser.attribValue = "";
-        parser.attribList.length = 0;
-      }
-      function closeTag(parser) {
-        if (!parser.tagName) {
-          strictFail(parser, "Weird empty close tag.");
-          parser.textNode += "</>";
-          parser.state = S.TEXT;
-          return;
-        }
-        if (parser.script) {
-          if (parser.tagName !== "script") {
-            parser.script += "</" + parser.tagName + ">";
-            parser.tagName = "";
-            parser.state = S.SCRIPT;
-            return;
-          }
-          emitNode(parser, "onscript", parser.script);
-          parser.script = "";
-        }
-        var t = parser.tags.length;
-        var tagName = parser.tagName;
-        if (!parser.strict) {
-          tagName = tagName[parser.looseCase]();
-        }
-        var closeTo = tagName;
-        while (t--) {
-          var close = parser.tags[t];
-          if (close.name !== closeTo) {
-            strictFail(parser, "Unexpected close tag");
-          } else {
-            break;
-          }
-        }
-        if (t < 0) {
-          strictFail(parser, "Unmatched closing tag: " + parser.tagName);
-          parser.textNode += "</" + parser.tagName + ">";
-          parser.state = S.TEXT;
-          return;
-        }
-        parser.tagName = tagName;
-        var s2 = parser.tags.length;
-        while (s2-- > t) {
-          var tag = parser.tag = parser.tags.pop();
-          parser.tagName = parser.tag.name;
-          emitNode(parser, "onclosetag", parser.tagName);
-          var x = {};
-          for (var i in tag.ns) {
-            x[i] = tag.ns[i];
-          }
-          var parent = parser.tags[parser.tags.length - 1] || parser;
-          if (parser.opt.xmlns && tag.ns !== parent.ns) {
-            Object.keys(tag.ns).forEach(function(p) {
-              var n = tag.ns[p];
-              emitNode(parser, "onclosenamespace", { prefix: p, uri: n });
-            });
-          }
-        }
-        if (t === 0) parser.closedRoot = true;
-        parser.tagName = parser.attribValue = parser.attribName = "";
-        parser.attribList.length = 0;
-        parser.state = S.TEXT;
-      }
-      function parseEntity(parser) {
-        var entity = parser.entity;
-        var entityLC = entity.toLowerCase();
-        var num;
-        var numStr = "";
-        if (parser.ENTITIES[entity]) {
-          return parser.ENTITIES[entity];
-        }
-        if (parser.ENTITIES[entityLC]) {
-          return parser.ENTITIES[entityLC];
-        }
-        entity = entityLC;
-        if (entity.charAt(0) === "#") {
-          if (entity.charAt(1) === "x") {
-            entity = entity.slice(2);
-            num = parseInt(entity, 16);
-            numStr = num.toString(16);
-          } else {
-            entity = entity.slice(1);
-            num = parseInt(entity, 10);
-            numStr = num.toString(10);
-          }
-        }
-        entity = entity.replace(/^0+/, "");
-        if (isNaN(num) || numStr.toLowerCase() !== entity) {
-          strictFail(parser, "Invalid character entity");
-          return "&" + parser.entity + ";";
-        }
-        return String.fromCodePoint(num);
-      }
-      function beginWhiteSpace(parser, c) {
-        if (c === "<") {
-          parser.state = S.OPEN_WAKA;
-          parser.startTagPosition = parser.position;
-        } else if (!isWhitespace(c)) {
-          strictFail(parser, "Non-whitespace before first tag.");
-          parser.textNode = c;
-          parser.state = S.TEXT;
-        }
-      }
-      function charAt(chunk, i) {
-        var result = "";
-        if (i < chunk.length) {
-          result = chunk.charAt(i);
-        }
-        return result;
-      }
-      function write(chunk) {
-        var parser = this;
-        if (this.error) {
-          throw this.error;
-        }
-        if (parser.closed) {
-          return error(
-            parser,
-            "Cannot write after close. Assign an onready handler."
-          );
-        }
-        if (chunk === null) {
-          return end(parser);
-        }
-        if (typeof chunk === "object") {
-          chunk = chunk.toString();
-        }
-        var i = 0;
-        var c = "";
-        while (true) {
-          c = charAt(chunk, i++);
-          parser.c = c;
-          if (!c) {
-            break;
-          }
-          if (parser.trackPosition) {
-            parser.position++;
-            if (c === "\n") {
-              parser.line++;
-              parser.column = 0;
-            } else {
-              parser.column++;
-            }
-          }
-          switch (parser.state) {
-            case S.BEGIN:
-              parser.state = S.BEGIN_WHITESPACE;
-              if (c === "\uFEFF") {
-                continue;
-              }
-              beginWhiteSpace(parser, c);
-              continue;
-            case S.BEGIN_WHITESPACE:
-              beginWhiteSpace(parser, c);
-              continue;
-            case S.TEXT:
-              if (parser.sawRoot && !parser.closedRoot) {
-                var starti = i - 1;
-                while (c && c !== "<" && c !== "&") {
-                  c = charAt(chunk, i++);
-                  if (c && parser.trackPosition) {
-                    parser.position++;
-                    if (c === "\n") {
-                      parser.line++;
-                      parser.column = 0;
-                    } else {
-                      parser.column++;
-                    }
-                  }
-                }
-                parser.textNode += chunk.substring(starti, i - 1);
-              }
-              if (c === "<" && !(parser.sawRoot && parser.closedRoot && !parser.strict)) {
-                parser.state = S.OPEN_WAKA;
-                parser.startTagPosition = parser.position;
-              } else {
-                if (!isWhitespace(c) && (!parser.sawRoot || parser.closedRoot)) {
-                  strictFail(parser, "Text data outside of root node.");
-                }
-                if (c === "&") {
-                  parser.state = S.TEXT_ENTITY;
-                } else {
-                  parser.textNode += c;
-                }
-              }
-              continue;
-            case S.SCRIPT:
-              if (c === "<") {
-                parser.state = S.SCRIPT_ENDING;
-              } else {
-                parser.script += c;
-              }
-              continue;
-            case S.SCRIPT_ENDING:
-              if (c === "/") {
-                parser.state = S.CLOSE_TAG;
-              } else {
-                parser.script += "<" + c;
-                parser.state = S.SCRIPT;
-              }
-              continue;
-            case S.OPEN_WAKA:
-              if (c === "!") {
-                parser.state = S.SGML_DECL;
-                parser.sgmlDecl = "";
-              } else if (isWhitespace(c)) ;
-              else if (isMatch(nameStart, c)) {
-                parser.state = S.OPEN_TAG;
-                parser.tagName = c;
-              } else if (c === "/") {
-                parser.state = S.CLOSE_TAG;
-                parser.tagName = "";
-              } else if (c === "?") {
-                parser.state = S.PROC_INST;
-                parser.procInstName = parser.procInstBody = "";
-              } else {
-                strictFail(parser, "Unencoded <");
-                if (parser.startTagPosition + 1 < parser.position) {
-                  var pad = parser.position - parser.startTagPosition;
-                  c = new Array(pad).join(" ") + c;
-                }
-                parser.textNode += "<" + c;
-                parser.state = S.TEXT;
-              }
-              continue;
-            case S.SGML_DECL:
-              if (parser.sgmlDecl + c === "--") {
-                parser.state = S.COMMENT;
-                parser.comment = "";
-                parser.sgmlDecl = "";
-                continue;
-              }
-              if (parser.doctype && parser.doctype !== true && parser.sgmlDecl) {
-                parser.state = S.DOCTYPE_DTD;
-                parser.doctype += "<!" + parser.sgmlDecl + c;
-                parser.sgmlDecl = "";
-              } else if ((parser.sgmlDecl + c).toUpperCase() === CDATA) {
-                emitNode(parser, "onopencdata");
-                parser.state = S.CDATA;
-                parser.sgmlDecl = "";
-                parser.cdata = "";
-              } else if ((parser.sgmlDecl + c).toUpperCase() === DOCTYPE) {
-                parser.state = S.DOCTYPE;
-                if (parser.doctype || parser.sawRoot) {
-                  strictFail(
-                    parser,
-                    "Inappropriately located doctype declaration"
-                  );
-                }
-                parser.doctype = "";
-                parser.sgmlDecl = "";
-              } else if (c === ">") {
-                emitNode(parser, "onsgmldeclaration", parser.sgmlDecl);
-                parser.sgmlDecl = "";
-                parser.state = S.TEXT;
-              } else if (isQuote(c)) {
-                parser.state = S.SGML_DECL_QUOTED;
-                parser.sgmlDecl += c;
-              } else {
-                parser.sgmlDecl += c;
-              }
-              continue;
-            case S.SGML_DECL_QUOTED:
-              if (c === parser.q) {
-                parser.state = S.SGML_DECL;
-                parser.q = "";
-              }
-              parser.sgmlDecl += c;
-              continue;
-            case S.DOCTYPE:
-              if (c === ">") {
-                parser.state = S.TEXT;
-                emitNode(parser, "ondoctype", parser.doctype);
-                parser.doctype = true;
-              } else {
-                parser.doctype += c;
-                if (c === "[") {
-                  parser.state = S.DOCTYPE_DTD;
-                } else if (isQuote(c)) {
-                  parser.state = S.DOCTYPE_QUOTED;
-                  parser.q = c;
-                }
-              }
-              continue;
-            case S.DOCTYPE_QUOTED:
-              parser.doctype += c;
-              if (c === parser.q) {
-                parser.q = "";
-                parser.state = S.DOCTYPE;
-              }
-              continue;
-            case S.DOCTYPE_DTD:
-              if (c === "]") {
-                parser.doctype += c;
-                parser.state = S.DOCTYPE;
-              } else if (c === "<") {
-                parser.state = S.OPEN_WAKA;
-                parser.startTagPosition = parser.position;
-              } else if (isQuote(c)) {
-                parser.doctype += c;
-                parser.state = S.DOCTYPE_DTD_QUOTED;
-                parser.q = c;
-              } else {
-                parser.doctype += c;
-              }
-              continue;
-            case S.DOCTYPE_DTD_QUOTED:
-              parser.doctype += c;
-              if (c === parser.q) {
-                parser.state = S.DOCTYPE_DTD;
-                parser.q = "";
-              }
-              continue;
-            case S.COMMENT:
-              if (c === "-") {
-                parser.state = S.COMMENT_ENDING;
-              } else {
-                parser.comment += c;
-              }
-              continue;
-            case S.COMMENT_ENDING:
-              if (c === "-") {
-                parser.state = S.COMMENT_ENDED;
-                parser.comment = textopts(parser.opt, parser.comment);
-                if (parser.comment) {
-                  emitNode(parser, "oncomment", parser.comment);
-                }
-                parser.comment = "";
-              } else {
-                parser.comment += "-" + c;
-                parser.state = S.COMMENT;
-              }
-              continue;
-            case S.COMMENT_ENDED:
-              if (c !== ">") {
-                strictFail(parser, "Malformed comment");
-                parser.comment += "--" + c;
-                parser.state = S.COMMENT;
-              } else if (parser.doctype && parser.doctype !== true) {
-                parser.state = S.DOCTYPE_DTD;
-              } else {
-                parser.state = S.TEXT;
-              }
-              continue;
-            case S.CDATA:
-              if (c === "]") {
-                parser.state = S.CDATA_ENDING;
-              } else {
-                parser.cdata += c;
-              }
-              continue;
-            case S.CDATA_ENDING:
-              if (c === "]") {
-                parser.state = S.CDATA_ENDING_2;
-              } else {
-                parser.cdata += "]" + c;
-                parser.state = S.CDATA;
-              }
-              continue;
-            case S.CDATA_ENDING_2:
-              if (c === ">") {
-                if (parser.cdata) {
-                  emitNode(parser, "oncdata", parser.cdata);
-                }
-                emitNode(parser, "onclosecdata");
-                parser.cdata = "";
-                parser.state = S.TEXT;
-              } else if (c === "]") {
-                parser.cdata += "]";
-              } else {
-                parser.cdata += "]]" + c;
-                parser.state = S.CDATA;
-              }
-              continue;
-            case S.PROC_INST:
-              if (c === "?") {
-                parser.state = S.PROC_INST_ENDING;
-              } else if (isWhitespace(c)) {
-                parser.state = S.PROC_INST_BODY;
-              } else {
-                parser.procInstName += c;
-              }
-              continue;
-            case S.PROC_INST_BODY:
-              if (!parser.procInstBody && isWhitespace(c)) {
-                continue;
-              } else if (c === "?") {
-                parser.state = S.PROC_INST_ENDING;
-              } else {
-                parser.procInstBody += c;
-              }
-              continue;
-            case S.PROC_INST_ENDING:
-              if (c === ">") {
-                emitNode(parser, "onprocessinginstruction", {
-                  name: parser.procInstName,
-                  body: parser.procInstBody
-                });
-                parser.procInstName = parser.procInstBody = "";
-                parser.state = S.TEXT;
-              } else {
-                parser.procInstBody += "?" + c;
-                parser.state = S.PROC_INST_BODY;
-              }
-              continue;
-            case S.OPEN_TAG:
-              if (isMatch(nameBody, c)) {
-                parser.tagName += c;
-              } else {
-                newTag(parser);
-                if (c === ">") {
-                  openTag(parser);
-                } else if (c === "/") {
-                  parser.state = S.OPEN_TAG_SLASH;
-                } else {
-                  if (!isWhitespace(c)) {
-                    strictFail(parser, "Invalid character in tag name");
-                  }
-                  parser.state = S.ATTRIB;
-                }
-              }
-              continue;
-            case S.OPEN_TAG_SLASH:
-              if (c === ">") {
-                openTag(parser, true);
-                closeTag(parser);
-              } else {
-                strictFail(parser, "Forward-slash in opening tag not followed by >");
-                parser.state = S.ATTRIB;
-              }
-              continue;
-            case S.ATTRIB:
-              if (isWhitespace(c)) {
-                continue;
-              } else if (c === ">") {
-                openTag(parser);
-              } else if (c === "/") {
-                parser.state = S.OPEN_TAG_SLASH;
-              } else if (isMatch(nameStart, c)) {
-                parser.attribName = c;
-                parser.attribValue = "";
-                parser.state = S.ATTRIB_NAME;
-              } else {
-                strictFail(parser, "Invalid attribute name");
-              }
-              continue;
-            case S.ATTRIB_NAME:
-              if (c === "=") {
-                parser.state = S.ATTRIB_VALUE;
-              } else if (c === ">") {
-                strictFail(parser, "Attribute without value");
-                parser.attribValue = parser.attribName;
-                attrib(parser);
-                openTag(parser);
-              } else if (isWhitespace(c)) {
-                parser.state = S.ATTRIB_NAME_SAW_WHITE;
-              } else if (isMatch(nameBody, c)) {
-                parser.attribName += c;
-              } else {
-                strictFail(parser, "Invalid attribute name");
-              }
-              continue;
-            case S.ATTRIB_NAME_SAW_WHITE:
-              if (c === "=") {
-                parser.state = S.ATTRIB_VALUE;
-              } else if (isWhitespace(c)) {
-                continue;
-              } else {
-                strictFail(parser, "Attribute without value");
-                parser.tag.attributes[parser.attribName] = "";
-                parser.attribValue = "";
-                emitNode(parser, "onattribute", {
-                  name: parser.attribName,
-                  value: ""
-                });
-                parser.attribName = "";
-                if (c === ">") {
-                  openTag(parser);
-                } else if (isMatch(nameStart, c)) {
-                  parser.attribName = c;
-                  parser.state = S.ATTRIB_NAME;
-                } else {
-                  strictFail(parser, "Invalid attribute name");
-                  parser.state = S.ATTRIB;
-                }
-              }
-              continue;
-            case S.ATTRIB_VALUE:
-              if (isWhitespace(c)) {
-                continue;
-              } else if (isQuote(c)) {
-                parser.q = c;
-                parser.state = S.ATTRIB_VALUE_QUOTED;
-              } else {
-                if (!parser.opt.unquotedAttributeValues) {
-                  error(parser, "Unquoted attribute value");
-                }
-                parser.state = S.ATTRIB_VALUE_UNQUOTED;
-                parser.attribValue = c;
-              }
-              continue;
-            case S.ATTRIB_VALUE_QUOTED:
-              if (c !== parser.q) {
-                if (c === "&") {
-                  parser.state = S.ATTRIB_VALUE_ENTITY_Q;
-                } else {
-                  parser.attribValue += c;
-                }
-                continue;
-              }
-              attrib(parser);
-              parser.q = "";
-              parser.state = S.ATTRIB_VALUE_CLOSED;
-              continue;
-            case S.ATTRIB_VALUE_CLOSED:
-              if (isWhitespace(c)) {
-                parser.state = S.ATTRIB;
-              } else if (c === ">") {
-                openTag(parser);
-              } else if (c === "/") {
-                parser.state = S.OPEN_TAG_SLASH;
-              } else if (isMatch(nameStart, c)) {
-                strictFail(parser, "No whitespace between attributes");
-                parser.attribName = c;
-                parser.attribValue = "";
-                parser.state = S.ATTRIB_NAME;
-              } else {
-                strictFail(parser, "Invalid attribute name");
-              }
-              continue;
-            case S.ATTRIB_VALUE_UNQUOTED:
-              if (!isAttribEnd(c)) {
-                if (c === "&") {
-                  parser.state = S.ATTRIB_VALUE_ENTITY_U;
-                } else {
-                  parser.attribValue += c;
-                }
-                continue;
-              }
-              attrib(parser);
-              if (c === ">") {
-                openTag(parser);
-              } else {
-                parser.state = S.ATTRIB;
-              }
-              continue;
-            case S.CLOSE_TAG:
-              if (!parser.tagName) {
-                if (isWhitespace(c)) {
-                  continue;
-                } else if (notMatch(nameStart, c)) {
-                  if (parser.script) {
-                    parser.script += "</" + c;
-                    parser.state = S.SCRIPT;
-                  } else {
-                    strictFail(parser, "Invalid tagname in closing tag.");
-                  }
-                } else {
-                  parser.tagName = c;
-                }
-              } else if (c === ">") {
-                closeTag(parser);
-              } else if (isMatch(nameBody, c)) {
-                parser.tagName += c;
-              } else if (parser.script) {
-                parser.script += "</" + parser.tagName;
-                parser.tagName = "";
-                parser.state = S.SCRIPT;
-              } else {
-                if (!isWhitespace(c)) {
-                  strictFail(parser, "Invalid tagname in closing tag");
-                }
-                parser.state = S.CLOSE_TAG_SAW_WHITE;
-              }
-              continue;
-            case S.CLOSE_TAG_SAW_WHITE:
-              if (isWhitespace(c)) {
-                continue;
-              }
-              if (c === ">") {
-                closeTag(parser);
-              } else {
-                strictFail(parser, "Invalid characters in closing tag");
-              }
-              continue;
-            case S.TEXT_ENTITY:
-            case S.ATTRIB_VALUE_ENTITY_Q:
-            case S.ATTRIB_VALUE_ENTITY_U:
-              var returnState;
-              var buffer2;
-              switch (parser.state) {
-                case S.TEXT_ENTITY:
-                  returnState = S.TEXT;
-                  buffer2 = "textNode";
-                  break;
-                case S.ATTRIB_VALUE_ENTITY_Q:
-                  returnState = S.ATTRIB_VALUE_QUOTED;
-                  buffer2 = "attribValue";
-                  break;
-                case S.ATTRIB_VALUE_ENTITY_U:
-                  returnState = S.ATTRIB_VALUE_UNQUOTED;
-                  buffer2 = "attribValue";
-                  break;
-              }
-              if (c === ";") {
-                var parsedEntity = parseEntity(parser);
-                if (parser.opt.unparsedEntities && !Object.values(sax2.XML_ENTITIES).includes(parsedEntity)) {
-                  parser.entity = "";
-                  parser.state = returnState;
-                  parser.write(parsedEntity);
-                } else {
-                  parser[buffer2] += parsedEntity;
-                  parser.entity = "";
-                  parser.state = returnState;
-                }
-              } else if (isMatch(parser.entity.length ? entityBody : entityStart, c)) {
-                parser.entity += c;
-              } else {
-                strictFail(parser, "Invalid character in entity name");
-                parser[buffer2] += "&" + parser.entity + c;
-                parser.entity = "";
-                parser.state = returnState;
-              }
-              continue;
-            default: {
-              throw new Error(parser, "Unknown state: " + parser.state);
-            }
-          }
-        }
-        if (parser.position >= parser.bufferCheckPosition) {
-          checkBufferLength(parser);
-        }
-        return parser;
-      }
-      if (!String.fromCodePoint) {
-        (function() {
-          var stringFromCharCode = String.fromCharCode;
-          var floor = Math.floor;
-          var fromCodePoint = function() {
-            var MAX_SIZE = 16384;
-            var codeUnits = [];
-            var highSurrogate;
-            var lowSurrogate;
-            var index = -1;
-            var length = arguments.length;
-            if (!length) {
-              return "";
-            }
-            var result = "";
-            while (++index < length) {
-              var codePoint = Number(arguments[index]);
-              if (!isFinite(codePoint) || // `NaN`, `+Infinity`, or `-Infinity`
-              codePoint < 0 || // not a valid Unicode code point
-              codePoint > 1114111 || // not a valid Unicode code point
-              floor(codePoint) !== codePoint) {
-                throw RangeError("Invalid code point: " + codePoint);
-              }
-              if (codePoint <= 65535) {
-                codeUnits.push(codePoint);
-              } else {
-                codePoint -= 65536;
-                highSurrogate = (codePoint >> 10) + 55296;
-                lowSurrogate = codePoint % 1024 + 56320;
-                codeUnits.push(highSurrogate, lowSurrogate);
-              }
-              if (index + 1 === length || codeUnits.length > MAX_SIZE) {
-                result += stringFromCharCode.apply(null, codeUnits);
-                codeUnits.length = 0;
-              }
-            }
-            return result;
-          };
-          if (Object.defineProperty) {
-            Object.defineProperty(String, "fromCodePoint", {
-              value: fromCodePoint,
-              configurable: true,
-              writable: true
-            });
-          } else {
-            String.fromCodePoint = fromCodePoint;
-          }
-        })();
-      }
-    })(exports);
-  })(sax);
-  return sax;
-}
-var arrayHelper;
-var hasRequiredArrayHelper;
-function requireArrayHelper() {
-  if (hasRequiredArrayHelper) return arrayHelper;
-  hasRequiredArrayHelper = 1;
-  arrayHelper = {
-    isArray: function(value) {
-      if (Array.isArray) {
-        return Array.isArray(value);
-      }
-      return Object.prototype.toString.call(value) === "[object Array]";
-    }
-  };
-  return arrayHelper;
-}
-var optionsHelper;
-var hasRequiredOptionsHelper;
-function requireOptionsHelper() {
-  if (hasRequiredOptionsHelper) return optionsHelper;
-  hasRequiredOptionsHelper = 1;
-  var isArray = requireArrayHelper().isArray;
-  optionsHelper = {
-    copyOptions: function(options) {
-      var key, copy = {};
-      for (key in options) {
-        if (options.hasOwnProperty(key)) {
-          copy[key] = options[key];
-        }
-      }
-      return copy;
-    },
-    ensureFlagExists: function(item, options) {
-      if (!(item in options) || typeof options[item] !== "boolean") {
-        options[item] = false;
-      }
-    },
-    ensureSpacesExists: function(options) {
-      if (!("spaces" in options) || typeof options.spaces !== "number" && typeof options.spaces !== "string") {
-        options.spaces = 0;
-      }
-    },
-    ensureAlwaysArrayExists: function(options) {
-      if (!("alwaysArray" in options) || typeof options.alwaysArray !== "boolean" && !isArray(options.alwaysArray)) {
-        options.alwaysArray = false;
-      }
-    },
-    ensureKeyExists: function(key, options) {
-      if (!(key + "Key" in options) || typeof options[key + "Key"] !== "string") {
-        options[key + "Key"] = options.compact ? "_" + key : key;
-      }
-    },
-    checkFnExists: function(key, options) {
-      return key + "Fn" in options;
-    }
-  };
-  return optionsHelper;
-}
-var xml2js;
-var hasRequiredXml2js;
-function requireXml2js() {
-  if (hasRequiredXml2js) return xml2js;
-  hasRequiredXml2js = 1;
-  var sax2 = requireSax();
-  var helper = requireOptionsHelper();
-  var isArray = requireArrayHelper().isArray;
-  var options;
-  var currentElement;
-  function validateOptions(userOptions) {
-    options = helper.copyOptions(userOptions);
-    helper.ensureFlagExists("ignoreDeclaration", options);
-    helper.ensureFlagExists("ignoreInstruction", options);
-    helper.ensureFlagExists("ignoreAttributes", options);
-    helper.ensureFlagExists("ignoreText", options);
-    helper.ensureFlagExists("ignoreComment", options);
-    helper.ensureFlagExists("ignoreCdata", options);
-    helper.ensureFlagExists("ignoreDoctype", options);
-    helper.ensureFlagExists("compact", options);
-    helper.ensureFlagExists("alwaysChildren", options);
-    helper.ensureFlagExists("addParent", options);
-    helper.ensureFlagExists("trim", options);
-    helper.ensureFlagExists("nativeType", options);
-    helper.ensureFlagExists("nativeTypeAttributes", options);
-    helper.ensureFlagExists("sanitize", options);
-    helper.ensureFlagExists("instructionHasAttributes", options);
-    helper.ensureFlagExists("captureSpacesBetweenElements", options);
-    helper.ensureAlwaysArrayExists(options);
-    helper.ensureKeyExists("declaration", options);
-    helper.ensureKeyExists("instruction", options);
-    helper.ensureKeyExists("attributes", options);
-    helper.ensureKeyExists("text", options);
-    helper.ensureKeyExists("comment", options);
-    helper.ensureKeyExists("cdata", options);
-    helper.ensureKeyExists("doctype", options);
-    helper.ensureKeyExists("type", options);
-    helper.ensureKeyExists("name", options);
-    helper.ensureKeyExists("elements", options);
-    helper.ensureKeyExists("parent", options);
-    helper.checkFnExists("doctype", options);
-    helper.checkFnExists("instruction", options);
-    helper.checkFnExists("cdata", options);
-    helper.checkFnExists("comment", options);
-    helper.checkFnExists("text", options);
-    helper.checkFnExists("instructionName", options);
-    helper.checkFnExists("elementName", options);
-    helper.checkFnExists("attributeName", options);
-    helper.checkFnExists("attributeValue", options);
-    helper.checkFnExists("attributes", options);
-    return options;
-  }
-  function nativeType(value) {
-    var nValue = Number(value);
-    if (!isNaN(nValue)) {
-      return nValue;
-    }
-    var bValue = value.toLowerCase();
-    if (bValue === "true") {
-      return true;
-    } else if (bValue === "false") {
-      return false;
-    }
-    return value;
-  }
-  function addField(type, value) {
-    var key;
-    if (options.compact) {
-      if (!currentElement[options[type + "Key"]] && (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + "Key"]) !== -1 : options.alwaysArray)) {
-        currentElement[options[type + "Key"]] = [];
-      }
-      if (currentElement[options[type + "Key"]] && !isArray(currentElement[options[type + "Key"]])) {
-        currentElement[options[type + "Key"]] = [currentElement[options[type + "Key"]]];
-      }
-      if (type + "Fn" in options && typeof value === "string") {
-        value = options[type + "Fn"](value, currentElement);
-      }
-      if (type === "instruction" && ("instructionFn" in options || "instructionNameFn" in options)) {
-        for (key in value) {
-          if (value.hasOwnProperty(key)) {
-            if ("instructionFn" in options) {
-              value[key] = options.instructionFn(value[key], key, currentElement);
-            } else {
-              var temp = value[key];
-              delete value[key];
-              value[options.instructionNameFn(key, temp, currentElement)] = temp;
-            }
-          }
-        }
-      }
-      if (isArray(currentElement[options[type + "Key"]])) {
-        currentElement[options[type + "Key"]].push(value);
-      } else {
-        currentElement[options[type + "Key"]] = value;
-      }
-    } else {
-      if (!currentElement[options.elementsKey]) {
-        currentElement[options.elementsKey] = [];
-      }
-      var element = {};
-      element[options.typeKey] = type;
-      if (type === "instruction") {
-        for (key in value) {
-          if (value.hasOwnProperty(key)) {
-            break;
-          }
-        }
-        element[options.nameKey] = "instructionNameFn" in options ? options.instructionNameFn(key, value, currentElement) : key;
-        if (options.instructionHasAttributes) {
-          element[options.attributesKey] = value[key][options.attributesKey];
-          if ("instructionFn" in options) {
-            element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement);
-          }
-        } else {
-          if ("instructionFn" in options) {
-            value[key] = options.instructionFn(value[key], key, currentElement);
-          }
-          element[options.instructionKey] = value[key];
-        }
-      } else {
-        if (type + "Fn" in options) {
-          value = options[type + "Fn"](value, currentElement);
-        }
-        element[options[type + "Key"]] = value;
-      }
-      if (options.addParent) {
-        element[options.parentKey] = currentElement;
-      }
-      currentElement[options.elementsKey].push(element);
-    }
-  }
-  function manipulateAttributes(attributes) {
-    if ("attributesFn" in options && attributes) {
-      attributes = options.attributesFn(attributes, currentElement);
-    }
-    if ((options.trim || "attributeValueFn" in options || "attributeNameFn" in options || options.nativeTypeAttributes) && attributes) {
-      var key;
-      for (key in attributes) {
-        if (attributes.hasOwnProperty(key)) {
-          if (options.trim) attributes[key] = attributes[key].trim();
-          if (options.nativeTypeAttributes) {
-            attributes[key] = nativeType(attributes[key]);
-          }
-          if ("attributeValueFn" in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement);
-          if ("attributeNameFn" in options) {
-            var temp = attributes[key];
-            delete attributes[key];
-            attributes[options.attributeNameFn(key, attributes[key], currentElement)] = temp;
-          }
-        }
-      }
-    }
-    return attributes;
-  }
-  function onInstruction(instruction) {
-    var attributes = {};
-    if (instruction.body && (instruction.name.toLowerCase() === "xml" || options.instructionHasAttributes)) {
-      var attrsRegExp = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;
-      var match;
-      while ((match = attrsRegExp.exec(instruction.body)) !== null) {
-        attributes[match[1]] = match[2] || match[3] || match[4];
-      }
-      attributes = manipulateAttributes(attributes);
-    }
-    if (instruction.name.toLowerCase() === "xml") {
-      if (options.ignoreDeclaration) {
-        return;
-      }
-      currentElement[options.declarationKey] = {};
-      if (Object.keys(attributes).length) {
-        currentElement[options.declarationKey][options.attributesKey] = attributes;
-      }
-      if (options.addParent) {
-        currentElement[options.declarationKey][options.parentKey] = currentElement;
-      }
-    } else {
-      if (options.ignoreInstruction) {
-        return;
-      }
-      if (options.trim) {
-        instruction.body = instruction.body.trim();
-      }
-      var value = {};
-      if (options.instructionHasAttributes && Object.keys(attributes).length) {
-        value[instruction.name] = {};
-        value[instruction.name][options.attributesKey] = attributes;
-      } else {
-        value[instruction.name] = instruction.body;
-      }
-      addField("instruction", value);
-    }
-  }
-  function onStartElement(name, attributes) {
-    var element;
-    if (typeof name === "object") {
-      attributes = name.attributes;
-      name = name.name;
-    }
-    attributes = manipulateAttributes(attributes);
-    if ("elementNameFn" in options) {
-      name = options.elementNameFn(name, currentElement);
-    }
-    if (options.compact) {
-      element = {};
-      if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
-        element[options.attributesKey] = {};
-        var key;
-        for (key in attributes) {
-          if (attributes.hasOwnProperty(key)) {
-            element[options.attributesKey][key] = attributes[key];
-          }
-        }
-      }
-      if (!(name in currentElement) && (isArray(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)) {
-        currentElement[name] = [];
-      }
-      if (currentElement[name] && !isArray(currentElement[name])) {
-        currentElement[name] = [currentElement[name]];
-      }
-      if (isArray(currentElement[name])) {
-        currentElement[name].push(element);
-      } else {
-        currentElement[name] = element;
-      }
-    } else {
-      if (!currentElement[options.elementsKey]) {
-        currentElement[options.elementsKey] = [];
-      }
-      element = {};
-      element[options.typeKey] = "element";
-      element[options.nameKey] = name;
-      if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
-        element[options.attributesKey] = attributes;
-      }
-      if (options.alwaysChildren) {
-        element[options.elementsKey] = [];
-      }
-      currentElement[options.elementsKey].push(element);
-    }
-    element[options.parentKey] = currentElement;
-    currentElement = element;
-  }
-  function onText(text) {
-    if (options.ignoreText) {
-      return;
-    }
-    if (!text.trim() && !options.captureSpacesBetweenElements) {
-      return;
-    }
-    if (options.trim) {
-      text = text.trim();
-    }
-    if (options.nativeType) {
-      text = nativeType(text);
-    }
-    if (options.sanitize) {
-      text = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    }
-    addField("text", text);
-  }
-  function onComment(comment) {
-    if (options.ignoreComment) {
-      return;
-    }
-    if (options.trim) {
-      comment = comment.trim();
-    }
-    addField("comment", comment);
-  }
-  function onEndElement(name) {
-    var parentElement = currentElement[options.parentKey];
-    if (!options.addParent) {
-      delete currentElement[options.parentKey];
-    }
-    currentElement = parentElement;
-  }
-  function onCdata(cdata) {
-    if (options.ignoreCdata) {
-      return;
-    }
-    if (options.trim) {
-      cdata = cdata.trim();
-    }
-    addField("cdata", cdata);
-  }
-  function onDoctype(doctype) {
-    if (options.ignoreDoctype) {
-      return;
-    }
-    doctype = doctype.replace(/^ /, "");
-    if (options.trim) {
-      doctype = doctype.trim();
-    }
-    addField("doctype", doctype);
-  }
-  function onError(error) {
-    error.note = error;
-  }
-  xml2js = function(xml, userOptions) {
-    var parser = sax2.parser(true, {});
-    var result = {};
-    currentElement = result;
-    options = validateOptions(userOptions);
-    {
-      parser.opt = { strictEntities: true };
-      parser.onopentag = onStartElement;
-      parser.ontext = onText;
-      parser.oncomment = onComment;
-      parser.onclosetag = onEndElement;
-      parser.onerror = onError;
-      parser.oncdata = onCdata;
-      parser.ondoctype = onDoctype;
-      parser.onprocessinginstruction = onInstruction;
-    }
-    {
-      parser.write(xml).close();
-    }
-    if (result[options.elementsKey]) {
-      var temp = result[options.elementsKey];
-      delete result[options.elementsKey];
-      result[options.elementsKey] = temp;
-      delete result.text;
-    }
-    return result;
-  };
-  return xml2js;
-}
-var xml2json;
-var hasRequiredXml2json;
-function requireXml2json() {
-  if (hasRequiredXml2json) return xml2json;
-  hasRequiredXml2json = 1;
-  var helper = requireOptionsHelper();
-  var xml2js2 = requireXml2js();
-  function validateOptions(userOptions) {
-    var options = helper.copyOptions(userOptions);
-    helper.ensureSpacesExists(options);
-    return options;
-  }
-  xml2json = function(xml, userOptions) {
-    var options, js, json, parentKey;
-    options = validateOptions(userOptions);
-    js = xml2js2(xml, options);
-    parentKey = "compact" in options && options.compact ? "_parent" : "parent";
-    if ("addParent" in options && options.addParent) {
-      json = JSON.stringify(js, function(k, v) {
-        return k === parentKey ? "_" : v;
-      }, options.spaces);
-    } else {
-      json = JSON.stringify(js, null, options.spaces);
-    }
-    return json.replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
-  };
-  return xml2json;
-}
-var js2xml;
-var hasRequiredJs2xml;
-function requireJs2xml() {
-  if (hasRequiredJs2xml) return js2xml;
-  hasRequiredJs2xml = 1;
-  var helper = requireOptionsHelper();
-  var isArray = requireArrayHelper().isArray;
-  var currentElement, currentElementName;
-  function validateOptions(userOptions) {
-    var options = helper.copyOptions(userOptions);
-    helper.ensureFlagExists("ignoreDeclaration", options);
-    helper.ensureFlagExists("ignoreInstruction", options);
-    helper.ensureFlagExists("ignoreAttributes", options);
-    helper.ensureFlagExists("ignoreText", options);
-    helper.ensureFlagExists("ignoreComment", options);
-    helper.ensureFlagExists("ignoreCdata", options);
-    helper.ensureFlagExists("ignoreDoctype", options);
-    helper.ensureFlagExists("compact", options);
-    helper.ensureFlagExists("indentText", options);
-    helper.ensureFlagExists("indentCdata", options);
-    helper.ensureFlagExists("indentAttributes", options);
-    helper.ensureFlagExists("indentInstruction", options);
-    helper.ensureFlagExists("fullTagEmptyElement", options);
-    helper.ensureFlagExists("noQuotesForNativeAttributes", options);
-    helper.ensureSpacesExists(options);
-    if (typeof options.spaces === "number") {
-      options.spaces = Array(options.spaces + 1).join(" ");
-    }
-    helper.ensureKeyExists("declaration", options);
-    helper.ensureKeyExists("instruction", options);
-    helper.ensureKeyExists("attributes", options);
-    helper.ensureKeyExists("text", options);
-    helper.ensureKeyExists("comment", options);
-    helper.ensureKeyExists("cdata", options);
-    helper.ensureKeyExists("doctype", options);
-    helper.ensureKeyExists("type", options);
-    helper.ensureKeyExists("name", options);
-    helper.ensureKeyExists("elements", options);
-    helper.checkFnExists("doctype", options);
-    helper.checkFnExists("instruction", options);
-    helper.checkFnExists("cdata", options);
-    helper.checkFnExists("comment", options);
-    helper.checkFnExists("text", options);
-    helper.checkFnExists("instructionName", options);
-    helper.checkFnExists("elementName", options);
-    helper.checkFnExists("attributeName", options);
-    helper.checkFnExists("attributeValue", options);
-    helper.checkFnExists("attributes", options);
-    helper.checkFnExists("fullTagEmptyElement", options);
-    return options;
-  }
-  function writeIndentation(options, depth, firstLine) {
-    return (!firstLine && options.spaces ? "\n" : "") + Array(depth + 1).join(options.spaces);
-  }
-  function writeAttributes(attributes, options, depth) {
-    if (options.ignoreAttributes) {
-      return "";
-    }
-    if ("attributesFn" in options) {
-      attributes = options.attributesFn(attributes, currentElementName, currentElement);
-    }
-    var key, attr, attrName, quote, result = [];
-    for (key in attributes) {
-      if (attributes.hasOwnProperty(key) && attributes[key] !== null && attributes[key] !== void 0) {
-        quote = options.noQuotesForNativeAttributes && typeof attributes[key] !== "string" ? "" : '"';
-        attr = "" + attributes[key];
-        attr = attr.replace(/"/g, "&quot;");
-        attrName = "attributeNameFn" in options ? options.attributeNameFn(key, attr, currentElementName, currentElement) : key;
-        result.push(options.spaces && options.indentAttributes ? writeIndentation(options, depth + 1, false) : " ");
-        result.push(attrName + "=" + quote + ("attributeValueFn" in options ? options.attributeValueFn(attr, key, currentElementName, currentElement) : attr) + quote);
-      }
-    }
-    if (attributes && Object.keys(attributes).length && options.spaces && options.indentAttributes) {
-      result.push(writeIndentation(options, depth, false));
-    }
-    return result.join("");
-  }
-  function writeDeclaration(declaration, options, depth) {
-    currentElement = declaration;
-    currentElementName = "xml";
-    return options.ignoreDeclaration ? "" : "<?xml" + writeAttributes(declaration[options.attributesKey], options, depth) + "?>";
-  }
-  function writeInstruction(instruction, options, depth) {
-    if (options.ignoreInstruction) {
-      return "";
-    }
-    var key;
-    for (key in instruction) {
-      if (instruction.hasOwnProperty(key)) {
-        break;
-      }
-    }
-    var instructionName = "instructionNameFn" in options ? options.instructionNameFn(key, instruction[key], currentElementName, currentElement) : key;
-    if (typeof instruction[key] === "object") {
-      currentElement = instruction;
-      currentElementName = instructionName;
-      return "<?" + instructionName + writeAttributes(instruction[key][options.attributesKey], options, depth) + "?>";
-    } else {
-      var instructionValue = instruction[key] ? instruction[key] : "";
-      if ("instructionFn" in options) instructionValue = options.instructionFn(instructionValue, key, currentElementName, currentElement);
-      return "<?" + instructionName + (instructionValue ? " " + instructionValue : "") + "?>";
-    }
-  }
-  function writeComment(comment, options) {
-    return options.ignoreComment ? "" : "<!--" + ("commentFn" in options ? options.commentFn(comment, currentElementName, currentElement) : comment) + "-->";
-  }
-  function writeCdata(cdata, options) {
-    return options.ignoreCdata ? "" : "<![CDATA[" + ("cdataFn" in options ? options.cdataFn(cdata, currentElementName, currentElement) : cdata.replace("]]>", "]]]]><![CDATA[>")) + "]]>";
-  }
-  function writeDoctype(doctype, options) {
-    return options.ignoreDoctype ? "" : "<!DOCTYPE " + ("doctypeFn" in options ? options.doctypeFn(doctype, currentElementName, currentElement) : doctype) + ">";
-  }
-  function writeText(text, options) {
-    if (options.ignoreText) return "";
-    text = "" + text;
-    text = text.replace(/&amp;/g, "&");
-    text = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
-    return "textFn" in options ? options.textFn(text, currentElementName, currentElement) : text;
-  }
-  function hasContent(element, options) {
-    var i;
-    if (element.elements && element.elements.length) {
-      for (i = 0; i < element.elements.length; ++i) {
-        switch (element.elements[i][options.typeKey]) {
-          case "text":
-            if (options.indentText) {
-              return true;
-            }
-            break;
-          // skip to next key
-          case "cdata":
-            if (options.indentCdata) {
-              return true;
-            }
-            break;
-          // skip to next key
-          case "instruction":
-            if (options.indentInstruction) {
-              return true;
-            }
-            break;
-          // skip to next key
-          case "doctype":
-          case "comment":
-          case "element":
-            return true;
-          default:
-            return true;
-        }
-      }
-    }
-    return false;
-  }
-  function writeElement(element, options, depth) {
-    currentElement = element;
-    currentElementName = element.name;
-    var xml = [], elementName = "elementNameFn" in options ? options.elementNameFn(element.name, element) : element.name;
-    xml.push("<" + elementName);
-    if (element[options.attributesKey]) {
-      xml.push(writeAttributes(element[options.attributesKey], options, depth));
-    }
-    var withClosingTag = element[options.elementsKey] && element[options.elementsKey].length || element[options.attributesKey] && element[options.attributesKey]["xml:space"] === "preserve";
-    if (!withClosingTag) {
-      if ("fullTagEmptyElementFn" in options) {
-        withClosingTag = options.fullTagEmptyElementFn(element.name, element);
-      } else {
-        withClosingTag = options.fullTagEmptyElement;
-      }
-    }
-    if (withClosingTag) {
-      xml.push(">");
-      if (element[options.elementsKey] && element[options.elementsKey].length) {
-        xml.push(writeElements(element[options.elementsKey], options, depth + 1));
-        currentElement = element;
-        currentElementName = element.name;
-      }
-      xml.push(options.spaces && hasContent(element, options) ? "\n" + Array(depth + 1).join(options.spaces) : "");
-      xml.push("</" + elementName + ">");
-    } else {
-      xml.push("/>");
-    }
-    return xml.join("");
-  }
-  function writeElements(elements, options, depth, firstLine) {
-    return elements.reduce(function(xml, element) {
-      var indent = writeIndentation(options, depth, firstLine && !xml);
-      switch (element.type) {
-        case "element":
-          return xml + indent + writeElement(element, options, depth);
-        case "comment":
-          return xml + indent + writeComment(element[options.commentKey], options);
-        case "doctype":
-          return xml + indent + writeDoctype(element[options.doctypeKey], options);
-        case "cdata":
-          return xml + (options.indentCdata ? indent : "") + writeCdata(element[options.cdataKey], options);
-        case "text":
-          return xml + (options.indentText ? indent : "") + writeText(element[options.textKey], options);
-        case "instruction":
-          var instruction = {};
-          instruction[element[options.nameKey]] = element[options.attributesKey] ? element : element[options.instructionKey];
-          return xml + (options.indentInstruction ? indent : "") + writeInstruction(instruction, options, depth);
-      }
-    }, "");
-  }
-  function hasContentCompact(element, options, anyContent) {
-    var key;
-    for (key in element) {
-      if (element.hasOwnProperty(key)) {
-        switch (key) {
-          case options.parentKey:
-          case options.attributesKey:
-            break;
-          // skip to next key
-          case options.textKey:
-            if (options.indentText || anyContent) {
-              return true;
-            }
-            break;
-          // skip to next key
-          case options.cdataKey:
-            if (options.indentCdata || anyContent) {
-              return true;
-            }
-            break;
-          // skip to next key
-          case options.instructionKey:
-            if (options.indentInstruction || anyContent) {
-              return true;
-            }
-            break;
-          // skip to next key
-          case options.doctypeKey:
-          case options.commentKey:
-            return true;
-          default:
-            return true;
-        }
-      }
-    }
-    return false;
-  }
-  function writeElementCompact(element, name, options, depth, indent) {
-    currentElement = element;
-    currentElementName = name;
-    var elementName = "elementNameFn" in options ? options.elementNameFn(name, element) : name;
-    if (typeof element === "undefined" || element === null || element === "") {
-      return "fullTagEmptyElementFn" in options && options.fullTagEmptyElementFn(name, element) || options.fullTagEmptyElement ? "<" + elementName + "></" + elementName + ">" : "<" + elementName + "/>";
-    }
-    var xml = [];
-    if (name) {
-      xml.push("<" + elementName);
-      if (typeof element !== "object") {
-        xml.push(">" + writeText(element, options) + "</" + elementName + ">");
-        return xml.join("");
-      }
-      if (element[options.attributesKey]) {
-        xml.push(writeAttributes(element[options.attributesKey], options, depth));
-      }
-      var withClosingTag = hasContentCompact(element, options, true) || element[options.attributesKey] && element[options.attributesKey]["xml:space"] === "preserve";
-      if (!withClosingTag) {
-        if ("fullTagEmptyElementFn" in options) {
-          withClosingTag = options.fullTagEmptyElementFn(name, element);
-        } else {
-          withClosingTag = options.fullTagEmptyElement;
-        }
-      }
-      if (withClosingTag) {
-        xml.push(">");
-      } else {
-        xml.push("/>");
-        return xml.join("");
-      }
-    }
-    xml.push(writeElementsCompact(element, options, depth + 1, false));
-    currentElement = element;
-    currentElementName = name;
-    if (name) {
-      xml.push((indent ? writeIndentation(options, depth, false) : "") + "</" + elementName + ">");
-    }
-    return xml.join("");
-  }
-  function writeElementsCompact(element, options, depth, firstLine) {
-    var i, key, nodes, xml = [];
-    for (key in element) {
-      if (element.hasOwnProperty(key)) {
-        nodes = isArray(element[key]) ? element[key] : [element[key]];
-        for (i = 0; i < nodes.length; ++i) {
-          switch (key) {
-            case options.declarationKey:
-              xml.push(writeDeclaration(nodes[i], options, depth));
-              break;
-            case options.instructionKey:
-              xml.push((options.indentInstruction ? writeIndentation(options, depth, firstLine) : "") + writeInstruction(nodes[i], options, depth));
-              break;
-            case options.attributesKey:
-            case options.parentKey:
-              break;
-            // skip
-            case options.textKey:
-              xml.push((options.indentText ? writeIndentation(options, depth, firstLine) : "") + writeText(nodes[i], options));
-              break;
-            case options.cdataKey:
-              xml.push((options.indentCdata ? writeIndentation(options, depth, firstLine) : "") + writeCdata(nodes[i], options));
-              break;
-            case options.doctypeKey:
-              xml.push(writeIndentation(options, depth, firstLine) + writeDoctype(nodes[i], options));
-              break;
-            case options.commentKey:
-              xml.push(writeIndentation(options, depth, firstLine) + writeComment(nodes[i], options));
-              break;
-            default:
-              xml.push(writeIndentation(options, depth, firstLine) + writeElementCompact(nodes[i], key, options, depth, hasContentCompact(nodes[i], options)));
-          }
-          firstLine = firstLine && !xml.length;
-        }
-      }
-    }
-    return xml.join("");
-  }
-  js2xml = function(js, options) {
-    options = validateOptions(options);
-    var xml = [];
-    currentElement = js;
-    currentElementName = "_root_";
-    if (options.compact) {
-      xml.push(writeElementsCompact(js, options, 0, true));
-    } else {
-      if (js[options.declarationKey]) {
-        xml.push(writeDeclaration(js[options.declarationKey], options, 0));
-      }
-      if (js[options.elementsKey] && js[options.elementsKey].length) {
-        xml.push(writeElements(js[options.elementsKey], options, 0, !xml.length));
-      }
-    }
-    return xml.join("");
-  };
-  return js2xml;
-}
-var json2xml;
-var hasRequiredJson2xml;
-function requireJson2xml() {
-  if (hasRequiredJson2xml) return json2xml;
-  hasRequiredJson2xml = 1;
-  var js2xml2 = requireJs2xml();
-  json2xml = function(json, options) {
-    if (json instanceof Buffer) {
-      json = json.toString();
-    }
-    var js = null;
-    if (typeof json === "string") {
-      try {
-        js = JSON.parse(json);
-      } catch (e) {
-        throw new Error("The JSON structure is invalid");
-      }
-    } else {
-      js = json;
-    }
-    return js2xml2(js, options);
-  };
-  return json2xml;
-}
-var lib;
-var hasRequiredLib;
-function requireLib() {
-  if (hasRequiredLib) return lib;
-  hasRequiredLib = 1;
-  var xml2js2 = requireXml2js();
-  var xml2json2 = requireXml2json();
-  var js2xml2 = requireJs2xml();
-  var json2xml2 = requireJson2xml();
-  lib = {
-    xml2js: xml2js2,
-    xml2json: xml2json2,
-    js2xml: js2xml2,
-    json2xml: json2xml2
-  };
-  return lib;
-}
-requireLib();
-requireBuffer();
-class TiledProperties {
-  constructor(data) {
-    this.properties = {};
-    this.properties = data?.properties ?? {};
-  }
-  getProperty(name, defaultValue) {
-    const val = this.properties[name];
-    if (val === void 0) {
-      return defaultValue;
-    }
-    return val;
-  }
-  hasProperty(name) {
-    return !!this.properties[name];
-  }
-  setProperty(name, value) {
-    this.properties[name] = value;
-  }
-  getType() {
-    return this.class || this["type"];
-  }
-}
-const FLIPPED_HORIZONTALLY_FLAG = 2147483648;
-const FLIPPED_VERTICALLY_FLAG = 1073741824;
-const FLIPPED_DIAGONALLY_FLAG = 536870912;
-const ROTATED_HEXAGONAL_120_FLAG = 268435456;
-class TileGid extends TiledProperties {
-  constructor(obj) {
-    super(obj);
-    this.obj = obj;
-    this._gid = obj?.gid;
-  }
-  static getRealGid(gid) {
-    return gid & 268435455;
-  }
-  get horizontalFlip() {
-    return !!(this._gid & FLIPPED_HORIZONTALLY_FLAG);
-  }
-  get verticalFlip() {
-    return !!(this._gid & FLIPPED_VERTICALLY_FLAG);
-  }
-  get diagonalFlip() {
-    return !!(this._gid & FLIPPED_DIAGONALLY_FLAG);
-  }
-  get rotatedHex120() {
-    return !!(this._gid & ROTATED_HEXAGONAL_120_FLAG);
-  }
-  get gid() {
-    return TileGid.getRealGid(this._gid);
-  }
-  set gid(val) {
-    this._gid = val;
-  }
-}
-class Tile extends TileGid {
-  constructor(tile) {
-    super(tile);
-    this.tile = tile;
-    const preservedProperties = this.properties;
-    Reflect.deleteProperty(tile, "gid");
-    Object.assign(this, tile);
-    if (preservedProperties && Object.keys(preservedProperties).length > 0) {
-      this.properties = { ...preservedProperties, ...this.properties };
-    }
-  }
-}
-class TiledObjectClass extends TileGid {
-  constructor(object) {
-    super(object);
-    this.layerName = "";
-    Object.assign(this, object);
-    if (object?.gid) {
-      this.y -= this.height;
-    }
-  }
-}
-class Layer extends TiledProperties {
-  constructor(layer, tilesets, parent) {
-    super(layer);
-    this.tilesets = tilesets;
-    this.parent = parent;
-    this.cacheTiles = false;
-    this.tiles = [];
-    Object.assign(this, layer);
-    this.mapObjects();
-    this.mergePropertiesWithParent();
-    this.cacheTiles = this.getProperty("cache-tiles", false);
-    if (this.cacheTiles) this.propertiesTiles();
-  }
-  get size() {
-    return this.data.length;
-  }
-  createTile(gid, tileIndex, layerIndex) {
-    if (gid == 0) {
-      return;
-    }
-    const realGid = TileGid.getRealGid(gid);
-    const tileset = Layer.findTileSet(realGid, this.tilesets);
-    if (!tileset) {
-      return void 0;
-    }
-    const tile = tileset.getTile(realGid - tileset.firstgid);
-    if (tile) {
-      return new Tile({
-        ...tile.tile,
-        gid,
-        index: tileIndex,
-        layerIndex
-      });
-    }
-    return new Tile({
-      gid,
-      index: tileIndex,
-      layerIndex
-    });
-  }
-  mergePropertiesWithParent() {
-    const parent = this.getLayerParent();
-    if (!this.properties) this.properties = {};
-    if (!parent) return;
-    for (let key in parent.properties) {
-      const val = parent.properties[key];
-      const valChild = this.properties[key];
-      if (valChild === void 0) {
-        this.properties[key] = val;
-      } else {
-        if (key == "z") {
-          this.properties[key] += val;
-        } else {
-          continue;
-        }
-      }
-    }
-    this.opacity = Math.round((parent.opacity ?? 1) * (this.opacity ?? 1) * 100) / 100;
-    this.offsetx = (parent.offsetx ?? 0) + (this.offsetx ?? 0);
-    this.offsety = (parent.offsety ?? 0) + (this.offsety ?? 0);
-    this.locked = parent.locked ?? false;
-  }
-  propertiesTiles() {
-    if (!this.data) return;
-    const data = this.data;
-    for (let i = 0; i < data.length; i++) {
-      const id = data[i];
-      this.tiles.push(this.createTile(id, i));
-    }
-  }
-  mapObjects() {
-    if (this.objects) {
-      this.objects = this.objects.map((object) => {
-        const obj = new TiledObjectClass(object);
-        obj.layerName = this.name;
-        return obj;
-      });
-    }
-  }
-  getTileByIndex(tileIndex) {
-    if (this.cacheTiles) {
-      return this.tiles[tileIndex];
-    }
-    return this.createTile(this.data[tileIndex], tileIndex);
-  }
-  static findTileSet(gid, tileSets) {
-    let tileset;
-    for (let i = tileSets.length - 1; i >= 0; i--) {
-      tileset = tileSets[i];
-      if (tileset.firstgid && tileset.firstgid <= gid) {
-        break;
-      }
-    }
-    return tileset;
-  }
-  getLayerParent() {
-    return this.parent;
-  }
-  tilesForEach(cb) {
-    for (let i = 0; i < this.data.length; i++) {
-      if (this.cacheTiles) {
-        cb(this.tiles[i], i);
-        continue;
-      }
-      cb(this.createTile(this.data[i], i), i);
-    }
-  }
-  setData(tileIndex, gid) {
-    this.data[tileIndex] = gid;
-  }
-}
-class Tileset extends TiledProperties {
-  constructor(tileset) {
-    super(tileset);
-    this.tileset = tileset;
-    this.cacheTileId = /* @__PURE__ */ new Map();
-    Object.assign(this, tileset);
-    this.margin = this.margin ?? 0;
-    this.spacing = this.spacing ?? 0;
-    const tilesArray = tileset.tiles || tileset.tile || [];
-    for (let tile of tilesArray) {
-      this.addTile(tile);
-    }
-    Reflect.deleteProperty(this, "tiles");
-    Reflect.deleteProperty(this, "tile");
-  }
-  addTile(tileObj) {
-    const tile = new Tile(tileObj);
-    this.cacheTileId.set(tile.id, tile);
-    return tile;
-  }
-  getTile(id) {
-    return this.cacheTileId.get(+id);
-  }
-}
-let bufferTilesets = {};
-class MapClass extends TiledProperties {
-  constructor(map) {
-    super(map ?? {});
-    this.tilesets = [];
-    this.layers = [];
-    this.tmpLayers = [];
-    this.tilesIndex = {};
-    this.allocateMemory = 0;
-    this.lowMemory = false;
-    if (map) this.load(map);
-  }
-  load(map) {
-    Object.assign(this, map);
-    if (this.hasProperty("low-memory")) {
-      this.lowMemory = this.getProperty("low-memory", false);
-    }
-    this.tmpLayers = [];
-    this.mapTilesets();
-    this.mapLayers(this.layers);
-    this.layers = [...this.tmpLayers];
-    Reflect.deleteProperty(this, "tmpLayers");
-    this.setTilesIndex();
-    this.data = map;
-  }
-  /** 
-   * @title Width of the map in pixels
-   * @prop {number} [widthPx]
-   * @readonly
-   * @memberof Map
-   * @memberof RpgSceneMap
-   * */
-  get widthPx() {
-    return this.width * this.tilewidth;
-  }
-  /** 
-  * @title Height of the map in pixels
-  * @prop {number} [heightPx]
-  * @readonly
-  * @memberof Map
-  * @memberof RpgSceneMap
-  * */
-  get heightPx() {
-    return this.height * this.tileheight;
-  }
-  /** 
-   * @title The depth of the map in pixels (this is the height of a tile ;))
-   * @prop {number} map.zTileHeight
-   * @readonly
-   * @memberof Map
-   * @memberof RpgSceneMap
-   * */
-  get zTileHeight() {
-    return this.tileheight;
-  }
-  /**
-       * Find a layer by name. Returns `undefined` is the layer is not found
-  
-       * @title Get Layer by name
-       * @method map.getLayerByName(name)
-       * @param {string} name layer name
-       * @returns {LayerInfo | undefined}
-       * @example
-       *  ```ts
-       *  const tiles = map.getLayerByName(0, 0)
-       *  ```
-       * @memberof Map
-       * @memberof RpgSceneMap
-       */
-  getLayerByName(name) {
-    return this.layers.find((layer) => layer.name == name);
-  }
-  /**
-  * Get the tile index on the tileset
-  * 
-  * @title Get index of tile
-  * @method map.getTileIndex(x,y)
-  * @param {number} x Position X
-  * @param {number} x Position Y
-  * @returns {number}
-  * @memberof Map
-  * @memberof RpgSceneMap
-  */
-  getTileIndex(x, y, [z] = [0]) {
-    return this.width * Math.floor((y - z) / this.tileheight) + Math.floor(x / this.tilewidth);
-  }
-  getTilePosition(index) {
-    return {
-      y: Math.floor(index / this.width) * this.tileheight,
-      x: index % this.width * this.tilewidth
-    };
-  }
-  /**
-       * Find the point of origin (top left) of a tile. Of course, its position depends on the size of the tile
-  
-       * @title Get origin position of tile
-       * @method map.getTileOriginPosition(x,y)
-       * @param {number} x Position X
-       * @param {number} x Position Y
-       * @returns { {x: number, y: number }}
-       * @example
-       *  ```ts
-       *  // If the size of a tile is 32x32px
-       *  const position = map.getTileOriginPosition(35, 12)
-       *  console.log(position) // { x: 32, y: 0 }
-       *  ```
-       * @memberof Map
-       * @memberof RpgSceneMap
-       */
-  getTileOriginPosition(x, y) {
-    return {
-      x: Math.floor(x / this.tilewidth) * this.tilewidth,
-      y: Math.floor(y / this.tileheight) * this.tileheight
-    };
-  }
-  /**
-      * Recover tiles according to a position
-  
-      * @title Get tile by position
-      * @method map.getTileByPosition(x,y)
-      * @param {number} x Position X
-      * @param {number} x Position Y
-      * @returns {TileInfo}
-      * @example
-      *  ```ts
-      *  const tiles = map.getTileByPosition(0, 0)
-      *  ```
-      * @memberof Map
-      * @memberof RpgSceneMap
-      */
-  getTileByPosition(x, y, z = [0, 0], options = {}) {
-    const tileIndex = this.getTileIndex(x, y, [z[0]]);
-    return this.getTileByIndex(tileIndex, z, options);
-  }
-  /**
-       * Retrieves tiles according to its index
-  
-       * @title Get tile by index
-       * @method map.getTileByIndex(tileIndex)
-       * @param {number} tileIndex tile index
-       * @returns {TileInfo}
-       * @example
-       *  ```ts
-       *  const index = map.getTileIndex(0, 0)
-       *  const tiles = map.getTileByIndex(index)
-       *  ```
-       * @memberof Map
-       * @memberof RpgSceneMap
-       */
-  getTileByIndex(tileIndex, zPlayer = [0, 0], options = {
-    populateTiles: true
-  }) {
-    const zA = Math.floor(zPlayer[0] / this.zTileHeight);
-    Math.floor(zPlayer[1] / this.zTileHeight);
-    const level = this.tilesIndex[zA];
-    const obj = {
-      tiles: [],
-      hasCollision: false,
-      isOverlay: false,
-      objectGroups: [],
-      tileIndex
-    };
-    if (!level) {
-      return obj;
-    }
-    const [layer] = this.layers;
-    const getTileByPointer = (pointer = 0) => {
-      const pos = tileIndex * this.realAllocateMemory + pointer;
-      const gid = level[pos];
-      if (gid === 0) {
-        return obj;
-      }
-      const tile2 = layer.createTile(gid, tileIndex, level[pos + 1]);
-      if (tile2) obj.tiles.push(tile2);
-    };
-    if (options.populateTiles) {
-      for (let i = 0; i < this.realAllocateMemory; i += 2) {
-        getTileByPointer(i);
-      }
-    } else {
-      getTileByPointer();
-    }
-    const [tile] = obj.tiles;
-    if (tile) {
-      obj.hasCollision = tile.getProperty("collision", false);
-      obj.objectGroups = tile.objects ?? [];
-    }
-    return obj;
-  }
-  getAllObjects() {
-    return this.layers.reduce((prev, current) => {
-      if (!current.objects) return prev;
-      return prev.concat(...current.objects);
-    }, []);
-  }
-  getData() {
-    return {
-      ...this.data,
-      layers: this.layers
-    };
-  }
-  setTile(x, y, layerFilter, tileInfo) {
-    if (this.lowMemory) {
-      throw "Impossible to change a tile with the lowMemory option";
-    }
-    const tileIndex = this.getTileIndex(x, y);
-    let fnFilter;
-    let tilesEdited = {};
-    if (typeof layerFilter == "string") {
-      fnFilter = (layer) => layer.name == layerFilter;
-    } else {
-      fnFilter = layerFilter;
-    }
-    for (let i = 0; i < this.layers.length; i++) {
-      const layer = this.layers[i];
-      if (!fnFilter(layer)) continue;
-      let tile;
-      const oldTile = this.getTileByIndex(tileIndex);
-      if (tileInfo.gid) {
-        tile = layer.createTile(tileInfo.gid, tileIndex);
-      }
-      if (!tile) continue;
-      for (let key in tileInfo) {
-        if (key == "gid") continue;
-        tile[key] = tileInfo[key];
-      }
-      tilesEdited[layer.name] = {
-        gid: tile.gid,
-        properties: tile.properties
-      };
-      this.setTileIndex(layer, oldTile.tiles[0], tile, tileIndex, i);
-      layer.setData(tileIndex, tile.gid);
-    }
-    return {
-      x,
-      y,
-      tiles: tilesEdited
-    };
-  }
-  removeCacheTileset(name) {
-    delete bufferTilesets[name];
-  }
-  clearCacheTilesets() {
-    bufferTilesets = {};
-  }
-  mapTilesets() {
-    this.tilesets = this.tilesets.map((tileset) => {
-      if (bufferTilesets[tileset.name]) {
-        const instance = bufferTilesets[tileset.name];
-        instance.firstgid = tileset.firstgid;
-        return instance;
-      }
-      const _tileset = new Tileset(tileset);
-      bufferTilesets[_tileset.name] = _tileset;
-      return _tileset;
-    });
-  }
-  mapLayers(layers = [], parent) {
-    for (let layer of layers) {
-      const layerInstance = new Layer(layer, this.tilesets, parent);
-      this.tmpLayers.push(layerInstance);
-      if (layer.layers) {
-        this.mapLayers(layer.layers, layerInstance);
-      }
-    }
-    if (this.lowMemory) this.allocateMemory = 1;
-    if (!this.allocateMemory) this.allocateMemory = this.layers.length;
-  }
-  setTileIndex(layer, oldTile, newTile, tileIndex, layerIndex) {
-    const startPos = tileIndex * this.realAllocateMemory;
-    let pointer = startPos + this.realAllocateMemory - 2;
-    const zLayer = layer.getProperty("z", 0);
-    const zTile = oldTile.getProperty("z", 0);
-    let z = zLayer + zTile;
-    while (pointer >= startPos) {
-      const zlayer = this.tilesIndex[z];
-      if (zlayer[pointer] === oldTile.gid && zlayer[pointer + 1] === layerIndex) {
-        this.tilesIndex[z][pointer] = newTile.gid;
-      }
-      pointer -= 2;
-    }
-  }
-  /**
-   * We multiply by 2 because 2 entries are stored for a tile: its GID and the Layer Index
-   * 
-   * Example If I have 3 layers, The array will have the following form 
-   * 
-   * [
-   *  GID of Layer 3, 
-   *  Layer Index of Layer 3, 
-   *  GID of Layer 2, 
-   *  Layer Index of Layer 2, 
-   *  GID of Layer 1, 
-   *  Layer Index of Layer 1,
-   * ... others tiles
-   * ]
-   * 
-   * The size in memory of the map is therefore:
-   * 
-   * `(map width * map height * number of layers * 4) bytes`
-   * 
-   * > We multiply by 4, because an element takes 2 bytes and has 2 elements for a tile is 4 bytes in all
-   * 
-   * Example (a 100x100 map with 5 layers)
-   * 
-   * `100 * 100 * 5 * 4 = 200000 bytes = ~195 Kb`
-   * 
-   * If we define on lowMemory then the calculation is the following
-   * 
-   * `(map width * map height * 4) bytes`
-   * 
-   * Example
-   * 
-   * `100 * 100 * 4 = 40000 bytes = ~39 Kb`
-   */
-  get realAllocateMemory() {
-    return this.allocateMemory * 2;
-  }
-  /**
-   * We keep each tile in memory classified by z value. The values are ordered from the end to the beginning so that the first element of the array (when retrieved with getTileByIndex() is the tile on the highest layer. This way, the tile search is very fast for collisions 
-   * 
-   */
-  addTileIndex(layer, tile, tileIndex, layerIndex) {
-    if (!tile || tile && tile.gid == 0) {
-      return;
-    }
-    const zLayer = layer.getProperty("z", 0);
-    const zTile = tile.getProperty("z", 0);
-    let z = zLayer + zTile;
-    if (!this.tilesIndex[z]) {
-      const buffer2 = new ArrayBuffer(layer.size * this.realAllocateMemory * 2);
-      this.tilesIndex[z] = new Uint16Array(buffer2);
-    }
-    const startPos = tileIndex * this.realAllocateMemory;
-    let pointer = startPos + this.realAllocateMemory - 2;
-    while (this.tilesIndex[z][pointer] !== 0 && pointer > startPos) {
-      pointer -= 2;
-    }
-    this.tilesIndex[z][pointer] = tile.gid;
-    this.tilesIndex[z][pointer + 1] = layerIndex;
-    this.tilesIndex[z][startPos] = tile.gid;
-    this.tilesIndex[z][startPos + 1] = layerIndex;
-  }
-  setTilesIndex() {
-    for (let i = 0; i < this.layers.length; i++) {
-      const layer = this.layers[i];
-      if (layer.type != TiledLayerType.Tile) {
-        continue;
-      }
-      layer.tilesForEach((tile, index) => {
-        this.addTileIndex(layer, tile, index, i);
-      });
-    }
-  }
-}
-export {
-  Layer,
-  MapClass,
-  Tile,
-  TiledLayerType,
-  TiledObjectClass,
-  TiledProperties,
-  Tileset
-};
+import { MapClass } from "./index2.js";
+//#region src/physics.ts
+var TILED_HITBOX_ID_PREFIX = "__tiled_collision__:";
+function prepareTiledPhysicsData(mapData, map) {
+	if (!mapData?.parsedMap) return;
+	const tiledMap = new MapClass(mapData.parsedMap);
+	map.tiled = tiledMap;
+	const tiledHitboxes = collectBlockedTileHitboxes(tiledMap);
+	mapData.hitboxes = mergeTiledHitboxes(mapData.hitboxes, tiledHitboxes);
+	mapData.width = tiledMap.widthPx;
+	mapData.height = tiledMap.heightPx;
+}
+function applyTiledPointEvents(mapData) {
+	const objects = mapData?.parsedMap?.objects;
+	if (!Array.isArray(objects) || !Array.isArray(mapData?.events)) return;
+	for (const obj of objects) {
+		if (!obj?.point) continue;
+		mapData.events = mapData.events.map((eventEntry) => {
+			if (eventEntry?.name === obj.name) return {
+				event: eventEntry,
+				x: obj.x,
+				y: obj.y
+			};
+			return eventEntry;
+		}).filter((eventEntry) => eventEntry !== null);
+	}
+}
+function collectBlockedTileHitboxes(tiledMap) {
+	const hitboxes = [];
+	const mapWidth = tiledMap.width;
+	const mapHeight = tiledMap.height;
+	const tileWidth = tiledMap.tilewidth;
+	const tileHeight = tiledMap.tileheight;
+	for (let y = 0; y < mapHeight; y++) for (let x = 0; x < mapWidth; x++) if (tiledMap.getTileByPosition(x * tileWidth, y * tileHeight, [0, 0], { populateTiles: true }).hasCollision) hitboxes.push({
+		id: createTiledHitboxId(x, y),
+		x: x * tileWidth,
+		y: y * tileHeight,
+		width: tileWidth,
+		height: tileHeight
+	});
+	return hitboxes;
+}
+function mergeTiledHitboxes(existingHitboxes, tiledHitboxes) {
+	return [...Array.isArray(existingHitboxes) ? existingHitboxes.filter((hitbox) => !isGeneratedTiledHitbox(hitbox)) : [], ...tiledHitboxes];
+}
+function isGeneratedTiledHitbox(hitbox) {
+	return typeof hitbox?.id === "string" && hitbox.id.startsWith(TILED_HITBOX_ID_PREFIX);
+}
+function createTiledHitboxId(x, y) {
+	return `${TILED_HITBOX_ID_PREFIX}${x},${y}`;
+}
+//#endregion
+export { applyTiledPointEvents, prepareTiledPhysicsData };