@genome-spy/app 0.37.4 → 0.38.0

package/dist/index-DD9IXliq.js

@@ -0,0 +1,4050 @@
+import { b as Q } from "./index-2VmK8MLN.js";
+import { _ as Yn, L as Kn } from "./index-5BtgVTyz.js";
+import { L as nr } from "./__vite-browser-external-ENoMJThg.js";
+import { R as ir } from "./remoteFile-1ad_qGwi.js";
+import "./index-UyB03NDZ.js";
+const ft = BigInt(32);
+function rr(e, n, t) {
+  const i = +!!t, r = +!t;
+  return BigInt(e.getInt32(n, t) * r + e.getInt32(n + 4, t) * i) << ft | BigInt(e.getUint32(n, t) * i + e.getUint32(n + 4, t) * r);
+}
+function ar(e, n, t) {
+  const i = e.getUint32(n, t), r = e.getUint32(n + 4, t), a = +!!t, o = +!t;
+  return BigInt(i * o + r * a) << ft | BigInt(i * a + r * o);
+}
+function or(e, n, t, i) {
+  const r = Number(t >> ft), a = Number(t & BigInt(4294967295));
+  i ? (e.setInt32(n + 4, r, i), e.setUint32(n, a, i)) : (e.setInt32(n, r, i), e.setUint32(n + 4, a, i));
+}
+function sr(e, n, t, i) {
+  const r = Number(t >> ft), a = Number(t & BigInt(4294967295));
+  i ? (e.setUint32(n + 4, r, i), e.setUint32(n, a, i)) : (e.setUint32(n, r, i), e.setUint32(n + 4, a, i));
+}
+"getBigInt64" in DataView || (DataView.prototype.getBigInt64 = function(e, n) {
+  return rr(this, e, n);
+});
+"getBigUint64" in DataView || (DataView.prototype.getBigUint64 = function(e, n) {
+  return ar(this, e, n);
+});
+"setBigInt64" in DataView || (DataView.prototype.setBigInt64 = function(e, n, t) {
+  or(this, e, n, t);
+});
+"setBigUint64" in DataView || (DataView.prototype.setBigUint64 = function(e, n, t) {
+  sr(this, e, n, t);
+});
+class lr {
+  constructor(n, t) {
+    this.code = "", this.scopes = [["vars"]], this.bitFields = [], this.tmpVariableCount = 0, this.references = /* @__PURE__ */ new Map(), this.imports = [], this.reverseImports = /* @__PURE__ */ new Map(), this.useContextVariables = !1, this.importPath = n, this.useContextVariables = t;
+  }
+  generateVariable(n) {
+    const t = [...this.scopes[this.scopes.length - 1]];
+    return n && t.push(n), t.join(".");
+  }
+  generateOption(n) {
+    switch (typeof n) {
+      case "number":
+        return n.toString();
+      case "string":
+        return this.generateVariable(n);
+      case "function":
+        return `${this.addImport(n)}.call(${this.generateVariable()}, vars)`;
+    }
+  }
+  generateError(n) {
+    this.pushCode(`throw new Error(${n});`);
+  }
+  generateTmpVariable() {
+    return "$tmp" + this.tmpVariableCount++;
+  }
+  pushCode(n) {
+    this.code += n + `
+`;
+  }
+  pushPath(n) {
+    n && this.scopes[this.scopes.length - 1].push(n);
+  }
+  popPath(n) {
+    n && this.scopes[this.scopes.length - 1].pop();
+  }
+  pushScope(n) {
+    this.scopes.push([n]);
+  }
+  popScope() {
+    this.scopes.pop();
+  }
+  addImport(n) {
+    if (!this.importPath)
+      return `(${n})`;
+    let t = this.reverseImports.get(n);
+    return t || (t = this.imports.push(n) - 1, this.reverseImports.set(n, t)), `${this.importPath}[${t}]`;
+  }
+  addReference(n) {
+    this.references.has(n) || this.references.set(n, { resolved: !1, requested: !1 });
+  }
+  markResolved(n) {
+    const t = this.references.get(n);
+    t && (t.resolved = !0);
+  }
+  markRequested(n) {
+    n.forEach((t) => {
+      const i = this.references.get(t);
+      i && (i.requested = !0);
+    });
+  }
+  getUnresolvedReferences() {
+    return Array.from(this.references).filter(([n, t]) => !t.resolved && !t.requested).map(([n, t]) => n);
+  }
+}
+const x = /* @__PURE__ */ new Map(), oe = "___parser_", M = {
+  uint8: 1,
+  uint16le: 2,
+  uint16be: 2,
+  uint32le: 4,
+  uint32be: 4,
+  int8: 1,
+  int16le: 2,
+  int16be: 2,
+  int32le: 4,
+  int32be: 4,
+  int64be: 8,
+  int64le: 8,
+  uint64be: 8,
+  uint64le: 8,
+  floatle: 4,
+  floatbe: 4,
+  doublele: 8,
+  doublebe: 8
+}, Ye = {
+  uint8: "Uint8",
+  uint16le: "Uint16",
+  uint16be: "Uint16",
+  uint32le: "Uint32",
+  uint32be: "Uint32",
+  int8: "Int8",
+  int16le: "Int16",
+  int16be: "Int16",
+  int32le: "Int32",
+  int32be: "Int32",
+  int64be: "BigInt64",
+  int64le: "BigInt64",
+  uint64be: "BigUint64",
+  uint64le: "BigUint64",
+  floatle: "Float32",
+  floatbe: "Float32",
+  doublele: "Float64",
+  doublebe: "Float64"
+}, Ke = {
+  uint8: !1,
+  uint16le: !0,
+  uint16be: !1,
+  uint32le: !0,
+  uint32be: !1,
+  int8: !1,
+  int16le: !0,
+  int16be: !1,
+  int32le: !0,
+  int32be: !1,
+  int64be: !1,
+  int64le: !0,
+  uint64be: !1,
+  uint64le: !0,
+  floatle: !0,
+  floatbe: !1,
+  doublele: !0,
+  doublebe: !1
+};
+class N {
+  constructor() {
+    this.varName = "", this.type = "", this.options = {}, this.endian = "be", this.useContextVariables = !1;
+  }
+  static start() {
+    return new N();
+  }
+  primitiveGenerateN(n, t) {
+    const i = Ye[n], r = Ke[n];
+    t.pushCode(`${t.generateVariable(this.varName)} = dataView.get${i}(offset, ${r});`), t.pushCode(`offset += ${M[n]};`);
+  }
+  primitiveN(n, t, i) {
+    return this.setNextParser(n, t, i);
+  }
+  useThisEndian(n) {
+    return n + this.endian.toLowerCase();
+  }
+  uint8(n, t = {}) {
+    return this.primitiveN("uint8", n, t);
+  }
+  uint16(n, t = {}) {
+    return this.primitiveN(this.useThisEndian("uint16"), n, t);
+  }
+  uint16le(n, t = {}) {
+    return this.primitiveN("uint16le", n, t);
+  }
+  uint16be(n, t = {}) {
+    return this.primitiveN("uint16be", n, t);
+  }
+  uint32(n, t = {}) {
+    return this.primitiveN(this.useThisEndian("uint32"), n, t);
+  }
+  uint32le(n, t = {}) {
+    return this.primitiveN("uint32le", n, t);
+  }
+  uint32be(n, t = {}) {
+    return this.primitiveN("uint32be", n, t);
+  }
+  int8(n, t = {}) {
+    return this.primitiveN("int8", n, t);
+  }
+  int16(n, t = {}) {
+    return this.primitiveN(this.useThisEndian("int16"), n, t);
+  }
+  int16le(n, t = {}) {
+    return this.primitiveN("int16le", n, t);
+  }
+  int16be(n, t = {}) {
+    return this.primitiveN("int16be", n, t);
+  }
+  int32(n, t = {}) {
+    return this.primitiveN(this.useThisEndian("int32"), n, t);
+  }
+  int32le(n, t = {}) {
+    return this.primitiveN("int32le", n, t);
+  }
+  int32be(n, t = {}) {
+    return this.primitiveN("int32be", n, t);
+  }
+  bigIntVersionCheck() {
+    if (!DataView.prototype.getBigInt64)
+      throw new Error("BigInt64 is unsupported on this runtime");
+  }
+  int64(n, t = {}) {
+    return this.bigIntVersionCheck(), this.primitiveN(this.useThisEndian("int64"), n, t);
+  }
+  int64be(n, t = {}) {
+    return this.bigIntVersionCheck(), this.primitiveN("int64be", n, t);
+  }
+  int64le(n, t = {}) {
+    return this.bigIntVersionCheck(), this.primitiveN("int64le", n, t);
+  }
+  uint64(n, t = {}) {
+    return this.bigIntVersionCheck(), this.primitiveN(this.useThisEndian("uint64"), n, t);
+  }
+  uint64be(n, t = {}) {
+    return this.bigIntVersionCheck(), this.primitiveN("uint64be", n, t);
+  }
+  uint64le(n, t = {}) {
+    return this.bigIntVersionCheck(), this.primitiveN("uint64le", n, t);
+  }
+  floatle(n, t = {}) {
+    return this.primitiveN("floatle", n, t);
+  }
+  floatbe(n, t = {}) {
+    return this.primitiveN("floatbe", n, t);
+  }
+  doublele(n, t = {}) {
+    return this.primitiveN("doublele", n, t);
+  }
+  doublebe(n, t = {}) {
+    return this.primitiveN("doublebe", n, t);
+  }
+  bitN(n, t, i) {
+    return i.length = n, this.setNextParser("bit", t, i);
+  }
+  bit1(n, t = {}) {
+    return this.bitN(1, n, t);
+  }
+  bit2(n, t = {}) {
+    return this.bitN(2, n, t);
+  }
+  bit3(n, t = {}) {
+    return this.bitN(3, n, t);
+  }
+  bit4(n, t = {}) {
+    return this.bitN(4, n, t);
+  }
+  bit5(n, t = {}) {
+    return this.bitN(5, n, t);
+  }
+  bit6(n, t = {}) {
+    return this.bitN(6, n, t);
+  }
+  bit7(n, t = {}) {
+    return this.bitN(7, n, t);
+  }
+  bit8(n, t = {}) {
+    return this.bitN(8, n, t);
+  }
+  bit9(n, t = {}) {
+    return this.bitN(9, n, t);
+  }
+  bit10(n, t = {}) {
+    return this.bitN(10, n, t);
+  }
+  bit11(n, t = {}) {
+    return this.bitN(11, n, t);
+  }
+  bit12(n, t = {}) {
+    return this.bitN(12, n, t);
+  }
+  bit13(n, t = {}) {
+    return this.bitN(13, n, t);
+  }
+  bit14(n, t = {}) {
+    return this.bitN(14, n, t);
+  }
+  bit15(n, t = {}) {
+    return this.bitN(15, n, t);
+  }
+  bit16(n, t = {}) {
+    return this.bitN(16, n, t);
+  }
+  bit17(n, t = {}) {
+    return this.bitN(17, n, t);
+  }
+  bit18(n, t = {}) {
+    return this.bitN(18, n, t);
+  }
+  bit19(n, t = {}) {
+    return this.bitN(19, n, t);
+  }
+  bit20(n, t = {}) {
+    return this.bitN(20, n, t);
+  }
+  bit21(n, t = {}) {
+    return this.bitN(21, n, t);
+  }
+  bit22(n, t = {}) {
+    return this.bitN(22, n, t);
+  }
+  bit23(n, t = {}) {
+    return this.bitN(23, n, t);
+  }
+  bit24(n, t = {}) {
+    return this.bitN(24, n, t);
+  }
+  bit25(n, t = {}) {
+    return this.bitN(25, n, t);
+  }
+  bit26(n, t = {}) {
+    return this.bitN(26, n, t);
+  }
+  bit27(n, t = {}) {
+    return this.bitN(27, n, t);
+  }
+  bit28(n, t = {}) {
+    return this.bitN(28, n, t);
+  }
+  bit29(n, t = {}) {
+    return this.bitN(29, n, t);
+  }
+  bit30(n, t = {}) {
+    return this.bitN(30, n, t);
+  }
+  bit31(n, t = {}) {
+    return this.bitN(31, n, t);
+  }
+  bit32(n, t = {}) {
+    return this.bitN(32, n, t);
+  }
+  namely(n) {
+    return x.set(n, this), this.alias = n, this;
+  }
+  skip(n, t = {}) {
+    return this.seek(n, t);
+  }
+  seek(n, t = {}) {
+    if (t.assert)
+      throw new Error("assert option on seek is not allowed.");
+    return this.setNextParser("seek", "", { length: n });
+  }
+  string(n, t) {
+    if (!t.zeroTerminated && !t.length && !t.greedy)
+      throw new Error("One of length, zeroTerminated, or greedy must be defined for string.");
+    if ((t.zeroTerminated || t.length) && t.greedy)
+      throw new Error("greedy is mutually exclusive with length and zeroTerminated for string.");
+    if (t.stripNull && !(t.length || t.greedy))
+      throw new Error("length or greedy must be defined if stripNull is enabled.");
+    return t.encoding = t.encoding || "utf8", this.setNextParser("string", n, t);
+  }
+  buffer(n, t) {
+    if (!t.length && !t.readUntil)
+      throw new Error("length or readUntil must be defined for buffer.");
+    return this.setNextParser("buffer", n, t);
+  }
+  wrapped(n, t) {
+    if (typeof t != "object" && typeof n == "object" && (t = n, n = ""), !t || !t.wrapper || !t.type)
+      throw new Error("Both wrapper and type must be defined for wrapped.");
+    if (!t.length && !t.readUntil)
+      throw new Error("length or readUntil must be defined for wrapped.");
+    return this.setNextParser("wrapper", n, t);
+  }
+  array(n, t) {
+    if (!t.readUntil && !t.length && !t.lengthInBytes)
+      throw new Error("One of readUntil, length and lengthInBytes must be defined for array.");
+    if (!t.type)
+      throw new Error("type is required for array.");
+    if (typeof t.type == "string" && !x.has(t.type) && !(t.type in M))
+      throw new Error(`Array element type "${t.type}" is unkown.`);
+    return this.setNextParser("array", n, t);
+  }
+  choice(n, t) {
+    if (typeof t != "object" && typeof n == "object" && (t = n, n = ""), !t)
+      throw new Error("tag and choices are are required for choice.");
+    if (!t.tag)
+      throw new Error("tag is requird for choice.");
+    if (!t.choices)
+      throw new Error("choices is required for choice.");
+    for (const i in t.choices) {
+      const r = parseInt(i, 10), a = t.choices[r];
+      if (isNaN(r))
+        throw new Error(`Choice key "${i}" is not a number.`);
+      if (typeof a == "string" && !x.has(a) && !(a in M))
+        throw new Error(`Choice type "${a}" is unkown.`);
+    }
+    return this.setNextParser("choice", n, t);
+  }
+  nest(n, t) {
+    if (typeof t != "object" && typeof n == "object" && (t = n, n = ""), !t || !t.type)
+      throw new Error("type is required for nest.");
+    if (!(t.type instanceof N) && !x.has(t.type))
+      throw new Error("type must be a known parser name or a Parser object.");
+    if (!(t.type instanceof N) && !n)
+      throw new Error("type must be a Parser object if the variable name is omitted.");
+    return this.setNextParser("nest", n, t);
+  }
+  pointer(n, t) {
+    if (!t.offset)
+      throw new Error("offset is required for pointer.");
+    if (!t.type)
+      throw new Error("type is required for pointer.");
+    if (typeof t.type == "string" && !(t.type in M) && !x.has(t.type))
+      throw new Error(`Pointer type "${t.type}" is unkown.`);
+    return this.setNextParser("pointer", n, t);
+  }
+  saveOffset(n, t = {}) {
+    return this.setNextParser("saveOffset", n, t);
+  }
+  endianness(n) {
+    switch (n.toLowerCase()) {
+      case "little":
+        this.endian = "le";
+        break;
+      case "big":
+        this.endian = "be";
+        break;
+      default:
+        throw new Error('endianness must be one of "little" or "big"');
+    }
+    return this;
+  }
+  endianess(n) {
+    return this.endianness(n);
+  }
+  useContextVars(n = !0) {
+    return this.useContextVariables = n, this;
+  }
+  create(n) {
+    if (!(n instanceof Function))
+      throw new Error("Constructor must be a Function object.");
+    return this.constructorFn = n, this;
+  }
+  getContext(n) {
+    const t = new lr(n, this.useContextVariables);
+    return t.pushCode("var dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"), this.alias ? (this.addAliasedCode(t), t.pushCode(`return ${oe + this.alias}(0).result;`)) : this.addRawCode(t), t;
+  }
+  getCode() {
+    const n = "imports";
+    return this.getContext(n).code;
+  }
+  addRawCode(n) {
+    n.pushCode("var offset = 0;"), n.pushCode(`var vars = ${this.constructorFn ? "new constructorFn()" : "{}"};`), n.pushCode("vars.$parent = null;"), n.pushCode("vars.$root = vars;"), this.generate(n), this.resolveReferences(n), n.pushCode("delete vars.$parent;"), n.pushCode("delete vars.$root;"), n.pushCode("return vars;");
+  }
+  addAliasedCode(n) {
+    return n.pushCode(`function ${oe + this.alias}(offset, context) {`), n.pushCode(`var vars = ${this.constructorFn ? "new constructorFn()" : "{}"};`), n.pushCode("var ctx = Object.assign({$parent: null, $root: vars}, context || {});"), n.pushCode("vars = Object.assign(vars, ctx);"), this.generate(n), n.markResolved(this.alias), this.resolveReferences(n), n.pushCode("Object.keys(ctx).forEach(function (item) { delete vars[item]; });"), n.pushCode("return { offset: offset, result: vars };"), n.pushCode("}"), n;
+  }
+  resolveReferences(n) {
+    const t = n.getUnresolvedReferences();
+    n.markRequested(t), t.forEach((i) => {
+      var r;
+      (r = x.get(i)) === null || r === void 0 || r.addAliasedCode(n);
+    });
+  }
+  compile() {
+    const n = "imports", t = this.getContext(n);
+    this.compiled = new Function(n, "TextDecoder", `return function (buffer, constructorFn) { ${t.code} };`)(t.imports, TextDecoder);
+  }
+  sizeOf() {
+    let n = NaN;
+    if (Object.keys(M).indexOf(this.type) >= 0)
+      n = M[this.type];
+    else if (this.type === "string" && typeof this.options.length == "number")
+      n = this.options.length;
+    else if (this.type === "buffer" && typeof this.options.length == "number")
+      n = this.options.length;
+    else if (this.type === "array" && typeof this.options.length == "number") {
+      let t = NaN;
+      typeof this.options.type == "string" ? t = M[this.options.type] : this.options.type instanceof N && (t = this.options.type.sizeOf()), n = this.options.length * t;
+    } else
+      this.type === "seek" ? n = this.options.length : this.type === "nest" ? n = this.options.type.sizeOf() : this.type || (n = 0);
+    return this.next && (n += this.next.sizeOf()), n;
+  }
+  // Follow the parser chain till the root and start parsing from there
+  parse(n) {
+    return this.compiled || this.compile(), this.compiled(n, this.constructorFn);
+  }
+  setNextParser(n, t, i) {
+    const r = new N();
+    return r.type = n, r.varName = t, r.options = i, r.endian = this.endian, this.head ? this.head.next = r : this.next = r, this.head = r, this;
+  }
+  // Call code generator for this parser
+  generate(n) {
+    if (this.type) {
+      switch (this.type) {
+        case "uint8":
+        case "uint16le":
+        case "uint16be":
+        case "uint32le":
+        case "uint32be":
+        case "int8":
+        case "int16le":
+        case "int16be":
+        case "int32le":
+        case "int32be":
+        case "int64be":
+        case "int64le":
+        case "uint64be":
+        case "uint64le":
+        case "floatle":
+        case "floatbe":
+        case "doublele":
+        case "doublebe":
+          this.primitiveGenerateN(this.type, n);
+          break;
+        case "bit":
+          this.generateBit(n);
+          break;
+        case "string":
+          this.generateString(n);
+          break;
+        case "buffer":
+          this.generateBuffer(n);
+          break;
+        case "seek":
+          this.generateSeek(n);
+          break;
+        case "nest":
+          this.generateNest(n);
+          break;
+        case "array":
+          this.generateArray(n);
+          break;
+        case "choice":
+          this.generateChoice(n);
+          break;
+        case "pointer":
+          this.generatePointer(n);
+          break;
+        case "saveOffset":
+          this.generateSaveOffset(n);
+          break;
+        case "wrapper":
+          this.generateWrapper(n);
+          break;
+      }
+      this.type !== "bit" && this.generateAssert(n);
+    }
+    const t = n.generateVariable(this.varName);
+    return this.options.formatter && this.type !== "bit" && this.generateFormatter(n, t, this.options.formatter), this.generateNext(n);
+  }
+  generateAssert(n) {
+    if (!this.options.assert)
+      return;
+    const t = n.generateVariable(this.varName);
+    switch (typeof this.options.assert) {
+      case "function":
+        {
+          const i = n.addImport(this.options.assert);
+          n.pushCode(`if (!${i}.call(vars, ${t})) {`);
+        }
+        break;
+      case "number":
+        n.pushCode(`if (${this.options.assert} !== ${t}) {`);
+        break;
+      case "string":
+        n.pushCode(`if (${JSON.stringify(this.options.assert)} !== ${t}) {`);
+        break;
+      default:
+        throw new Error("assert option must be a string, number or a function.");
+    }
+    n.generateError(`"Assertion error: ${t} is " + ${JSON.stringify(this.options.assert.toString())}`), n.pushCode("}");
+  }
+  // Recursively call code generators and append results
+  generateNext(n) {
+    return this.next && (n = this.next.generate(n)), n;
+  }
+  generateBit(n) {
+    const t = JSON.parse(JSON.stringify(this));
+    if (t.options = this.options, t.generateAssert = this.generateAssert.bind(this), t.generateFormatter = this.generateFormatter.bind(this), t.varName = n.generateVariable(t.varName), n.bitFields.push(t), !this.next || this.next && ["bit", "nest"].indexOf(this.next.type) < 0) {
+      const i = n.generateTmpVariable();
+      n.pushCode(`var ${i} = 0;`);
+      const r = (f = 0) => {
+        let d = 0;
+        for (let c = f; c < n.bitFields.length; c++) {
+          const h = n.bitFields[c].options.length;
+          if (d + h > 32)
+            break;
+          d += h;
+        }
+        return d;
+      }, a = (f) => (f <= 8 ? (n.pushCode(`${i} = dataView.getUint8(offset);`), f = 8) : f <= 16 ? (n.pushCode(`${i} = dataView.getUint16(offset);`), f = 16) : f <= 24 ? (n.pushCode(`${i} = (dataView.getUint16(offset) << 8) | dataView.getUint8(offset + 2);`), f = 24) : (n.pushCode(`${i} = dataView.getUint32(offset);`), f = 32), n.pushCode(`offset += ${f / 8};`), f);
+      let o = 0;
+      const l = this.endian === "be";
+      let u = 0, s = 0;
+      n.bitFields.forEach((f, d) => {
+        let c = f.options.length;
+        if (c > s) {
+          if (s) {
+            const g = -1 >>> 32 - s;
+            n.pushCode(`${f.varName} = (${i} & 0x${g.toString(16)}) << ${c - s};`), c -= s;
+          }
+          o = 0, s = u = a(r(d) - s);
+        }
+        const h = l ? u - o - c : o, _ = -1 >>> 32 - c;
+        n.pushCode(`${f.varName} ${c < f.options.length ? "|=" : "="} ${i} >> ${h} & 0x${_.toString(16)};`), f.options.length === 32 && n.pushCode(`${f.varName} >>>= 0`), f.options.assert && f.generateAssert(n), f.options.formatter && f.generateFormatter(n, f.varName, f.options.formatter), o += c, s -= c;
+      }), n.bitFields = [];
+    }
+  }
+  generateSeek(n) {
+    const t = n.generateOption(this.options.length);
+    n.pushCode(`offset += ${t};`);
+  }
+  generateString(n) {
+    const t = n.generateVariable(this.varName), i = n.generateTmpVariable(), r = this.options.encoding, a = r.toLowerCase() === "hex", o = 'b => b.toString(16).padStart(2, "0")';
+    if (this.options.length && this.options.zeroTerminated) {
+      const l = this.options.length;
+      n.pushCode(`var ${i} = offset;`), n.pushCode(`while(dataView.getUint8(offset++) !== 0 && offset - ${i} < ${l});`);
+      const u = `offset - ${i} < ${l} ? offset - 1 : offset`;
+      n.pushCode(a ? `${t} = Array.from(buffer.subarray(${i}, ${u}), ${o}).join('');` : `${t} = new TextDecoder('${r}').decode(buffer.subarray(${i}, ${u}));`);
+    } else if (this.options.length) {
+      const l = n.generateOption(this.options.length);
+      n.pushCode(a ? `${t} = Array.from(buffer.subarray(offset, offset + ${l}), ${o}).join('');` : `${t} = new TextDecoder('${r}').decode(buffer.subarray(offset, offset + ${l}));`), n.pushCode(`offset += ${l};`);
+    } else
+      this.options.zeroTerminated ? (n.pushCode(`var ${i} = offset;`), n.pushCode("while(dataView.getUint8(offset++) !== 0);"), n.pushCode(a ? `${t} = Array.from(buffer.subarray(${i}, offset - 1), ${o}).join('');` : `${t} = new TextDecoder('${r}').decode(buffer.subarray(${i}, offset - 1));`)) : this.options.greedy && (n.pushCode(`var ${i} = offset;`), n.pushCode("while(buffer.length > offset++);"), n.pushCode(a ? `${t} = Array.from(buffer.subarray(${i}, offset), ${o}).join('');` : `${t} = new TextDecoder('${r}').decode(buffer.subarray(${i}, offset));`));
+    this.options.stripNull && n.pushCode(`${t} = ${t}.replace(/\\x00+$/g, '')`);
+  }
+  generateBuffer(n) {
+    const t = n.generateVariable(this.varName);
+    if (typeof this.options.readUntil == "function") {
+      const i = this.options.readUntil, r = n.generateTmpVariable(), a = n.generateTmpVariable();
+      n.pushCode(`var ${r} = offset;`), n.pushCode(`var ${a} = 0;`), n.pushCode("while (offset < buffer.length) {"), n.pushCode(`${a} = dataView.getUint8(offset);`);
+      const o = n.addImport(i);
+      n.pushCode(`if (${o}.call(${n.generateVariable()}, ${a}, buffer.subarray(offset))) break;`), n.pushCode("offset += 1;"), n.pushCode("}"), n.pushCode(`${t} = buffer.subarray(${r}, offset);`);
+    } else if (this.options.readUntil === "eof")
+      n.pushCode(`${t} = buffer.subarray(offset);`);
+    else {
+      const i = n.generateOption(this.options.length);
+      n.pushCode(`${t} = buffer.subarray(offset, offset + ${i});`), n.pushCode(`offset += ${i};`);
+    }
+    this.options.clone && n.pushCode(`${t} = buffer.constructor.from(${t});`);
+  }
+  generateArray(n) {
+    const t = n.generateOption(this.options.length), i = n.generateOption(this.options.lengthInBytes), r = this.options.type, a = n.generateTmpVariable(), o = n.generateVariable(this.varName), l = n.generateTmpVariable(), u = this.options.key, s = typeof u == "string";
+    if (s ? n.pushCode(`${o} = {};`) : n.pushCode(`${o} = [];`), typeof this.options.readUntil == "function" ? n.pushCode("do {") : this.options.readUntil === "eof" ? n.pushCode(`for (var ${a} = 0; offset < buffer.length; ${a}++) {`) : i !== void 0 ? n.pushCode(`for (var ${a} = offset + ${i}; offset < ${a}; ) {`) : n.pushCode(`for (var ${a} = ${t}; ${a} > 0; ${a}--) {`), typeof r == "string")
+      if (x.get(r)) {
+        const f = n.generateTmpVariable();
+        if (n.pushCode(`var ${f} = ${oe + r}(offset, {`), n.useContextVariables) {
+          const d = n.generateVariable();
+          n.pushCode(`$parent: ${d},`), n.pushCode(`$root: ${d}.$root,`), !this.options.readUntil && i === void 0 && n.pushCode(`$index: ${t} - ${a},`);
+        }
+        n.pushCode("});"), n.pushCode(`var ${l} = ${f}.result; offset = ${f}.offset;`), r !== this.alias && n.addReference(r);
+      } else {
+        const f = Ye[r], d = Ke[r];
+        n.pushCode(`var ${l} = dataView.get${f}(offset, ${d});`), n.pushCode(`offset += ${M[r]};`);
+      }
+    else if (r instanceof N) {
+      n.pushCode(`var ${l} = {};`);
+      const f = n.generateVariable();
+      n.pushScope(l), n.useContextVariables && (n.pushCode(`${l}.$parent = ${f};`), n.pushCode(`${l}.$root = ${f}.$root;`), !this.options.readUntil && i === void 0 && n.pushCode(`${l}.$index = ${t} - ${a};`)), r.generate(n), n.useContextVariables && (n.pushCode(`delete ${l}.$parent;`), n.pushCode(`delete ${l}.$root;`), n.pushCode(`delete ${l}.$index;`)), n.popScope();
+    }
+    if (s ? n.pushCode(`${o}[${l}.${u}] = ${l};`) : n.pushCode(`${o}.push(${l});`), n.pushCode("}"), typeof this.options.readUntil == "function") {
+      const f = this.options.readUntil, d = n.addImport(f);
+      n.pushCode(`while (!${d}.call(${n.generateVariable()}, ${l}, buffer.subarray(offset)));`);
+    }
+  }
+  generateChoiceCase(n, t, i) {
+    if (typeof i == "string") {
+      const r = n.generateVariable(this.varName);
+      if (x.has(i)) {
+        const a = n.generateTmpVariable();
+        n.pushCode(`var ${a} = ${oe + i}(offset, {`), n.useContextVariables && (n.pushCode(`$parent: ${r}.$parent,`), n.pushCode(`$root: ${r}.$root,`)), n.pushCode("});"), n.pushCode(`${r} = ${a}.result; offset = ${a}.offset;`), i !== this.alias && n.addReference(i);
+      } else {
+        const a = Ye[i], o = Ke[i];
+        n.pushCode(`${r} = dataView.get${a}(offset, ${o});`), n.pushCode(`offset += ${M[i]}`);
+      }
+    } else
+      i instanceof N && (n.pushPath(t), i.generate(n), n.popPath(t));
+  }
+  generateChoice(n) {
+    const t = n.generateOption(this.options.tag), i = n.generateVariable(this.varName);
+    if (this.varName && (n.pushCode(`${i} = {};`), n.useContextVariables)) {
+      const r = n.generateVariable();
+      n.pushCode(`${i}.$parent = ${r};`), n.pushCode(`${i}.$root = ${r}.$root;`);
+    }
+    n.pushCode(`switch(${t}) {`);
+    for (const r in this.options.choices) {
+      const a = parseInt(r, 10), o = this.options.choices[a];
+      n.pushCode(`case ${a}:`), this.generateChoiceCase(n, this.varName, o), n.pushCode("break;");
+    }
+    n.pushCode("default:"), this.options.defaultChoice ? this.generateChoiceCase(n, this.varName, this.options.defaultChoice) : n.generateError(`"Met undefined tag value " + ${t} + " at choice"`), n.pushCode("}"), this.varName && n.useContextVariables && (n.pushCode(`delete ${i}.$parent;`), n.pushCode(`delete ${i}.$root;`));
+  }
+  generateNest(n) {
+    const t = n.generateVariable(this.varName);
+    if (this.options.type instanceof N) {
+      if (this.varName && (n.pushCode(`${t} = {};`), n.useContextVariables)) {
+        const i = n.generateVariable();
+        n.pushCode(`${t}.$parent = ${i};`), n.pushCode(`${t}.$root = ${i}.$root;`);
+      }
+      n.pushPath(this.varName), this.options.type.generate(n), n.popPath(this.varName), this.varName && n.useContextVariables && n.useContextVariables && (n.pushCode(`delete ${t}.$parent;`), n.pushCode(`delete ${t}.$root;`));
+    } else if (x.has(this.options.type)) {
+      const i = n.generateTmpVariable();
+      if (n.pushCode(`var ${i} = ${oe + this.options.type}(offset, {`), n.useContextVariables) {
+        const r = n.generateVariable();
+        n.pushCode(`$parent: ${r},`), n.pushCode(`$root: ${r}.$root,`);
+      }
+      n.pushCode("});"), n.pushCode(`${t} = ${i}.result; offset = ${i}.offset;`), this.options.type !== this.alias && n.addReference(this.options.type);
+    }
+  }
+  generateWrapper(n) {
+    const t = n.generateVariable(this.varName), i = n.generateTmpVariable();
+    if (typeof this.options.readUntil == "function") {
+      const u = this.options.readUntil, s = n.generateTmpVariable(), f = n.generateTmpVariable();
+      n.pushCode(`var ${s} = offset;`), n.pushCode(`var ${f} = 0;`), n.pushCode("while (offset < buffer.length) {"), n.pushCode(`${f} = dataView.getUint8(offset);`);
+      const d = n.addImport(u);
+      n.pushCode(`if (${d}.call(${n.generateVariable()}, ${f}, buffer.subarray(offset))) break;`), n.pushCode("offset += 1;"), n.pushCode("}"), n.pushCode(`${i} = buffer.subarray(${s}, offset);`);
+    } else if (this.options.readUntil === "eof")
+      n.pushCode(`${i} = buffer.subarray(offset);`);
+    else {
+      const u = n.generateOption(this.options.length);
+      n.pushCode(`${i} = buffer.subarray(offset, offset + ${u});`), n.pushCode(`offset += ${u};`);
+    }
+    this.options.clone && n.pushCode(`${i} = buffer.constructor.from(${i});`);
+    const r = n.generateTmpVariable(), a = n.generateTmpVariable(), o = n.generateTmpVariable(), l = n.addImport(this.options.wrapper);
+    if (n.pushCode(`${i} = ${l}.call(this, ${i}).subarray(0);`), n.pushCode(`var ${r} = buffer;`), n.pushCode(`var ${a} = offset;`), n.pushCode(`var ${o} = dataView;`), n.pushCode(`buffer = ${i};`), n.pushCode("offset = 0;"), n.pushCode("dataView = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);"), this.options.type instanceof N)
+      this.varName && n.pushCode(`${t} = {};`), n.pushPath(this.varName), this.options.type.generate(n), n.popPath(this.varName);
+    else if (x.has(this.options.type)) {
+      const u = n.generateTmpVariable();
+      n.pushCode(`var ${u} = ${oe + this.options.type}(0);`), n.pushCode(`${t} = ${u}.result;`), this.options.type !== this.alias && n.addReference(this.options.type);
+    }
+    n.pushCode(`buffer = ${r};`), n.pushCode(`dataView = ${o};`), n.pushCode(`offset = ${a};`);
+  }
+  generateFormatter(n, t, i) {
+    if (typeof i == "function") {
+      const r = n.addImport(i);
+      n.pushCode(`${t} = ${r}.call(${n.generateVariable()}, ${t});`);
+    }
+  }
+  generatePointer(n) {
+    const t = this.options.type, i = n.generateOption(this.options.offset), r = n.generateTmpVariable(), a = n.generateVariable(this.varName);
+    if (n.pushCode(`var ${r} = offset;`), n.pushCode(`offset = ${i};`), this.options.type instanceof N) {
+      if (n.pushCode(`${a} = {};`), n.useContextVariables) {
+        const o = n.generateVariable();
+        n.pushCode(`${a}.$parent = ${o};`), n.pushCode(`${a}.$root = ${o}.$root;`);
+      }
+      n.pushPath(this.varName), this.options.type.generate(n), n.popPath(this.varName), n.useContextVariables && (n.pushCode(`delete ${a}.$parent;`), n.pushCode(`delete ${a}.$root;`));
+    } else if (x.has(this.options.type)) {
+      const o = n.generateTmpVariable();
+      if (n.pushCode(`var ${o} = ${oe + this.options.type}(offset, {`), n.useContextVariables) {
+        const l = n.generateVariable();
+        n.pushCode(`$parent: ${l},`), n.pushCode(`$root: ${l}.$root,`);
+      }
+      n.pushCode("});"), n.pushCode(`${a} = ${o}.result; offset = ${o}.offset;`), this.options.type !== this.alias && n.addReference(this.options.type);
+    } else if (Object.keys(M).indexOf(this.options.type) >= 0) {
+      const o = Ye[t], l = Ke[t];
+      n.pushCode(`${a} = dataView.get${o}(offset, ${l});`), n.pushCode(`offset += ${M[t]};`);
+    }
+    n.pushCode(`offset = ${r};`);
+  }
+  generateSaveOffset(n) {
+    const t = n.generateVariable(this.varName);
+    n.pushCode(`${t} = offset`);
+  }
+}
+class q {
+  constructor(n, t) {
+    this.ranges = arguments.length === 2 ? [{ min: n, max: t }] : 0 in n ? Object.assign({}, n) : [n];
+  }
+  min() {
+    return this.ranges[0].min;
+  }
+  max() {
+    return this.ranges[this.ranges.length - 1].max;
+  }
+  contains(n) {
+    for (let t = 0; t < this.ranges.length; t += 1) {
+      const i = this.ranges[t];
+      if (i.min <= n && i.max >= n)
+        return !0;
+    }
+    return !1;
+  }
+  isContiguous() {
+    return this.ranges.length > 1;
+  }
+  getRanges() {
+    return this.ranges.map((n) => new q(n.min, n.max));
+  }
+  toString() {
+    return this.ranges.map((n) => `[${n.min}-${n.max}]`).join(",");
+  }
+  union(n) {
+    const t = this.getRanges().concat(n.getRanges()).sort(this.rangeOrder), i = [];
+    let r = t[0];
+    for (let a = 1; a < t.length; a += 1) {
+      const o = t[a];
+      o.min() > r.max() + 1 ? (i.push(r), r = o) : o.max() > r.max() && (r = new q(r.min(), o.max()));
+    }
+    return i.push(r), i.length === 1 ? i[0] : new q(i);
+  }
+  intersection(n) {
+    let t = this, i = n;
+    const r = this.ranges(), a = i.ranges(), o = r.length, l = a.length;
+    let u = 0, s = 0;
+    const f = [];
+    for (; u < o && s < l; ) {
+      t = r[u], i = a[s];
+      const d = Math.max(t.min(), i.min()), c = Math.min(t.max(), i.max());
+      c >= d && f.push(new q(d, c)), t.max() > i.max() ? s += 1 : u += 1;
+    }
+    if (f.length === 0)
+      throw new Error("found range of length 0");
+    return f.length === 1 ? f[0] : new q(f);
+  }
+  coverage() {
+    let n = 0;
+    const t = this.ranges();
+    for (const i of t)
+      n += i.max() - i.min() + 1;
+    return n;
+  }
+  rangeOrder(n, t) {
+    let i = n, r = t;
+    return arguments.length < 2 && (r = i, i = this), i.min() < r.min() ? -1 : i.min() > r.min() ? 1 : i.max() < r.max() ? -1 : r.max() > i.max() ? 1 : 0;
+  }
+}
+/*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
+const fr = 4, en = 0, tn = 1, ur = 2;
+function ye(e) {
+  let n = e.length;
+  for (; --n >= 0; )
+    e[n] = 0;
+}
+const hr = 0, Wn = 1, cr = 2, dr = 3, pr = 258, xt = 29, Ze = 256, Oe = Ze + 1 + xt, _e = 30, Mt = 19, Xn = 2 * Oe + 1, se = 15, dt = 16, _r = 7, Ht = 256, qn = 16, Jn = 17, Qn = 18, Ot = (
+  /* extra bits for each length code */
+  new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0])
+), nt = (
+  /* extra bits for each distance code */
+  new Uint8Array([0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13])
+), br = (
+  /* extra bits for each bit length code */
+  new Uint8Array([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 3, 7])
+), ei = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), gr = 512, W = new Array((Oe + 2) * 2);
+ye(W);
+const Te = new Array(_e * 2);
+ye(Te);
+const ze = new Array(gr);
+ye(ze);
+const Re = new Array(pr - dr + 1);
+ye(Re);
+const jt = new Array(xt);
+ye(jt);
+const it = new Array(_e);
+ye(it);
+function pt(e, n, t, i, r) {
+  this.static_tree = e, this.extra_bits = n, this.extra_base = t, this.elems = i, this.max_length = r, this.has_stree = e && e.length;
+}
+let ti, ni, ii;
+function _t(e, n) {
+  this.dyn_tree = e, this.max_code = 0, this.stat_desc = n;
+}
+const ri = (e) => e < 256 ? ze[e] : ze[256 + (e >>> 7)], Be = (e, n) => {
+  e.pending_buf[e.pending++] = n & 255, e.pending_buf[e.pending++] = n >>> 8 & 255;
+}, D = (e, n, t) => {
+  e.bi_valid > dt - t ? (e.bi_buf |= n << e.bi_valid & 65535, Be(e, e.bi_buf), e.bi_buf = n >> dt - e.bi_valid, e.bi_valid += t - dt) : (e.bi_buf |= n << e.bi_valid & 65535, e.bi_valid += t);
+}, j = (e, n, t) => {
+  D(
+    e,
+    t[n * 2],
+    t[n * 2 + 1]
+    /*.Len*/
+  );
+}, ai = (e, n) => {
+  let t = 0;
+  do
+    t |= e & 1, e >>>= 1, t <<= 1;
+  while (--n > 0);
+  return t >>> 1;
+}, wr = (e) => {
+  e.bi_valid === 16 ? (Be(e, e.bi_buf), e.bi_buf = 0, e.bi_valid = 0) : e.bi_valid >= 8 && (e.pending_buf[e.pending++] = e.bi_buf & 255, e.bi_buf >>= 8, e.bi_valid -= 8);
+}, mr = (e, n) => {
+  const t = n.dyn_tree, i = n.max_code, r = n.stat_desc.static_tree, a = n.stat_desc.has_stree, o = n.stat_desc.extra_bits, l = n.stat_desc.extra_base, u = n.stat_desc.max_length;
+  let s, f, d, c, h, _, g = 0;
+  for (c = 0; c <= se; c++)
+    e.bl_count[c] = 0;
+  for (t[e.heap[e.heap_max] * 2 + 1] = 0, s = e.heap_max + 1; s < Xn; s++)
+    f = e.heap[s], c = t[t[f * 2 + 1] * 2 + 1] + 1, c > u && (c = u, g++), t[f * 2 + 1] = c, !(f > i) && (e.bl_count[c]++, h = 0, f >= l && (h = o[f - l]), _ = t[f * 2], e.opt_len += _ * (c + h), a && (e.static_len += _ * (r[f * 2 + 1] + h)));
+  if (g !== 0) {
+    do {
+      for (c = u - 1; e.bl_count[c] === 0; )
+        c--;
+      e.bl_count[c]--, e.bl_count[c + 1] += 2, e.bl_count[u]--, g -= 2;
+    } while (g > 0);
+    for (c = u; c !== 0; c--)
+      for (f = e.bl_count[c]; f !== 0; )
+        d = e.heap[--s], !(d > i) && (t[d * 2 + 1] !== c && (e.opt_len += (c - t[d * 2 + 1]) * t[d * 2], t[d * 2 + 1] = c), f--);
+  }
+}, oi = (e, n, t) => {
+  const i = new Array(se + 1);
+  let r = 0, a, o;
+  for (a = 1; a <= se; a++)
+    r = r + t[a - 1] << 1, i[a] = r;
+  for (o = 0; o <= n; o++) {
+    let l = e[o * 2 + 1];
+    l !== 0 && (e[o * 2] = ai(i[l]++, l));
+  }
+}, yr = () => {
+  let e, n, t, i, r;
+  const a = new Array(se + 1);
+  for (t = 0, i = 0; i < xt - 1; i++)
+    for (jt[i] = t, e = 0; e < 1 << Ot[i]; e++)
+      Re[t++] = i;
+  for (Re[t - 1] = i, r = 0, i = 0; i < 16; i++)
+    for (it[i] = r, e = 0; e < 1 << nt[i]; e++)
+      ze[r++] = i;
+  for (r >>= 7; i < _e; i++)
+    for (it[i] = r << 7, e = 0; e < 1 << nt[i] - 7; e++)
+      ze[256 + r++] = i;
+  for (n = 0; n <= se; n++)
+    a[n] = 0;
+  for (e = 0; e <= 143; )
+    W[e * 2 + 1] = 8, e++, a[8]++;
+  for (; e <= 255; )
+    W[e * 2 + 1] = 9, e++, a[9]++;
+  for (; e <= 279; )
+    W[e * 2 + 1] = 7, e++, a[7]++;
+  for (; e <= 287; )
+    W[e * 2 + 1] = 8, e++, a[8]++;
+  for (oi(W, Oe + 1, a), e = 0; e < _e; e++)
+    Te[e * 2 + 1] = 5, Te[e * 2] = ai(e, 5);
+  ti = new pt(W, Ot, Ze + 1, Oe, se), ni = new pt(Te, nt, 0, _e, se), ii = new pt(new Array(0), br, 0, Mt, _r);
+}, si = (e) => {
+  let n;
+  for (n = 0; n < Oe; n++)
+    e.dyn_ltree[n * 2] = 0;
+  for (n = 0; n < _e; n++)
+    e.dyn_dtree[n * 2] = 0;
+  for (n = 0; n < Mt; n++)
+    e.bl_tree[n * 2] = 0;
+  e.dyn_ltree[Ht * 2] = 1, e.opt_len = e.static_len = 0, e.sym_next = e.matches = 0;
+}, li = (e) => {
+  e.bi_valid > 8 ? Be(e, e.bi_buf) : e.bi_valid > 0 && (e.pending_buf[e.pending++] = e.bi_buf), e.bi_buf = 0, e.bi_valid = 0;
+}, nn = (e, n, t, i) => {
+  const r = n * 2, a = t * 2;
+  return e[r] < e[a] || e[r] === e[a] && i[n] <= i[t];
+}, bt = (e, n, t) => {
+  const i = e.heap[t];
+  let r = t << 1;
+  for (; r <= e.heap_len && (r < e.heap_len && nn(n, e.heap[r + 1], e.heap[r], e.depth) && r++, !nn(n, i, e.heap[r], e.depth)); )
+    e.heap[t] = e.heap[r], t = r, r <<= 1;
+  e.heap[t] = i;
+}, rn = (e, n, t) => {
+  let i, r, a = 0, o, l;
+  if (e.sym_next !== 0)
+    do
+      i = e.pending_buf[e.sym_buf + a++] & 255, i += (e.pending_buf[e.sym_buf + a++] & 255) << 8, r = e.pending_buf[e.sym_buf + a++], i === 0 ? j(e, r, n) : (o = Re[r], j(e, o + Ze + 1, n), l = Ot[o], l !== 0 && (r -= jt[o], D(e, r, l)), i--, o = ri(i), j(e, o, t), l = nt[o], l !== 0 && (i -= it[o], D(e, i, l)));
+    while (a < e.sym_next);
+  j(e, Ht, n);
+}, zt = (e, n) => {
+  const t = n.dyn_tree, i = n.stat_desc.static_tree, r = n.stat_desc.has_stree, a = n.stat_desc.elems;
+  let o, l, u = -1, s;
+  for (e.heap_len = 0, e.heap_max = Xn, o = 0; o < a; o++)
+    t[o * 2] !== 0 ? (e.heap[++e.heap_len] = u = o, e.depth[o] = 0) : t[o * 2 + 1] = 0;
+  for (; e.heap_len < 2; )
+    s = e.heap[++e.heap_len] = u < 2 ? ++u : 0, t[s * 2] = 1, e.depth[s] = 0, e.opt_len--, r && (e.static_len -= i[s * 2 + 1]);
+  for (n.max_code = u, o = e.heap_len >> 1; o >= 1; o--)
+    bt(e, t, o);
+  s = a;
+  do
+    o = e.heap[
+      1
+      /*SMALLEST*/
+    ], e.heap[
+      1
+      /*SMALLEST*/
+    ] = e.heap[e.heap_len--], bt(
+      e,
+      t,
+      1
+      /*SMALLEST*/
+    ), l = e.heap[
+      1
+      /*SMALLEST*/
+    ], e.heap[--e.heap_max] = o, e.heap[--e.heap_max] = l, t[s * 2] = t[o * 2] + t[l * 2], e.depth[s] = (e.depth[o] >= e.depth[l] ? e.depth[o] : e.depth[l]) + 1, t[o * 2 + 1] = t[l * 2 + 1] = s, e.heap[
+      1
+      /*SMALLEST*/
+    ] = s++, bt(
+      e,
+      t,
+      1
+      /*SMALLEST*/
+    );
+  while (e.heap_len >= 2);
+  e.heap[--e.heap_max] = e.heap[
+    1
+    /*SMALLEST*/
+  ], mr(e, n), oi(t, u, e.bl_count);
+}, an = (e, n, t) => {
+  let i, r = -1, a, o = n[0 * 2 + 1], l = 0, u = 7, s = 4;
+  for (o === 0 && (u = 138, s = 3), n[(t + 1) * 2 + 1] = 65535, i = 0; i <= t; i++)
+    a = o, o = n[(i + 1) * 2 + 1], !(++l < u && a === o) && (l < s ? e.bl_tree[a * 2] += l : a !== 0 ? (a !== r && e.bl_tree[a * 2]++, e.bl_tree[qn * 2]++) : l <= 10 ? e.bl_tree[Jn * 2]++ : e.bl_tree[Qn * 2]++, l = 0, r = a, o === 0 ? (u = 138, s = 3) : a === o ? (u = 6, s = 3) : (u = 7, s = 4));
+}, on = (e, n, t) => {
+  let i, r = -1, a, o = n[0 * 2 + 1], l = 0, u = 7, s = 4;
+  for (o === 0 && (u = 138, s = 3), i = 0; i <= t; i++)
+    if (a = o, o = n[(i + 1) * 2 + 1], !(++l < u && a === o)) {
+      if (l < s)
+        do
+          j(e, a, e.bl_tree);
+        while (--l !== 0);
+      else
+        a !== 0 ? (a !== r && (j(e, a, e.bl_tree), l--), j(e, qn, e.bl_tree), D(e, l - 3, 2)) : l <= 10 ? (j(e, Jn, e.bl_tree), D(e, l - 3, 3)) : (j(e, Qn, e.bl_tree), D(e, l - 11, 7));
+      l = 0, r = a, o === 0 ? (u = 138, s = 3) : a === o ? (u = 6, s = 3) : (u = 7, s = 4);
+    }
+}, vr = (e) => {
+  let n;
+  for (an(e, e.dyn_ltree, e.l_desc.max_code), an(e, e.dyn_dtree, e.d_desc.max_code), zt(e, e.bl_desc), n = Mt - 1; n >= 3 && e.bl_tree[ei[n] * 2 + 1] === 0; n--)
+    ;
+  return e.opt_len += 3 * (n + 1) + 5 + 5 + 4, n;
+}, kr = (e, n, t, i) => {
+  let r;
+  for (D(e, n - 257, 5), D(e, t - 1, 5), D(e, i - 4, 4), r = 0; r < i; r++)
+    D(e, e.bl_tree[ei[r] * 2 + 1], 3);
+  on(e, e.dyn_ltree, n - 1), on(e, e.dyn_dtree, t - 1);
+}, $r = (e) => {
+  let n = 4093624447, t;
+  for (t = 0; t <= 31; t++, n >>>= 1)
+    if (n & 1 && e.dyn_ltree[t * 2] !== 0)
+      return en;
+  if (e.dyn_ltree[9 * 2] !== 0 || e.dyn_ltree[10 * 2] !== 0 || e.dyn_ltree[13 * 2] !== 0)
+    return tn;
+  for (t = 32; t < Ze; t++)
+    if (e.dyn_ltree[t * 2] !== 0)
+      return tn;
+  return en;
+};
+let sn = !1;
+const Er = (e) => {
+  sn || (yr(), sn = !0), e.l_desc = new _t(e.dyn_ltree, ti), e.d_desc = new _t(e.dyn_dtree, ni), e.bl_desc = new _t(e.bl_tree, ii), e.bi_buf = 0, e.bi_valid = 0, si(e);
+}, fi = (e, n, t, i) => {
+  D(e, (hr << 1) + (i ? 1 : 0), 3), li(e), Be(e, t), Be(e, ~t), t && e.pending_buf.set(e.window.subarray(n, n + t), e.pending), e.pending += t;
+}, Cr = (e) => {
+  D(e, Wn << 1, 3), j(e, Ht, W), wr(e);
+}, Sr = (e, n, t, i) => {
+  let r, a, o = 0;
+  e.level > 0 ? (e.strm.data_type === ur && (e.strm.data_type = $r(e)), zt(e, e.l_desc), zt(e, e.d_desc), o = vr(e), r = e.opt_len + 3 + 7 >>> 3, a = e.static_len + 3 + 7 >>> 3, a <= r && (r = a)) : r = a = t + 5, t + 4 <= r && n !== -1 ? fi(e, n, t, i) : e.strategy === fr || a === r ? (D(e, (Wn << 1) + (i ? 1 : 0), 3), rn(e, W, Te)) : (D(e, (cr << 1) + (i ? 1 : 0), 3), kr(e, e.l_desc.max_code + 1, e.d_desc.max_code + 1, o + 1), rn(e, e.dyn_ltree, e.dyn_dtree)), si(e), i && li(e);
+}, Nr = (e, n, t) => (e.pending_buf[e.sym_buf + e.sym_next++] = n, e.pending_buf[e.sym_buf + e.sym_next++] = n >> 8, e.pending_buf[e.sym_buf + e.sym_next++] = t, n === 0 ? e.dyn_ltree[t * 2]++ : (e.matches++, n--, e.dyn_ltree[(Re[t] + Ze + 1) * 2]++, e.dyn_dtree[ri(n) * 2]++), e.sym_next === e.sym_end);
+var Tr = Er, Ir = fi, Ar = Sr, Or = Nr, zr = Cr, Rr = {
+  _tr_init: Tr,
+  _tr_stored_block: Ir,
+  _tr_flush_block: Ar,
+  _tr_tally: Or,
+  _tr_align: zr
+};
+const Br = (e, n, t, i) => {
+  let r = e & 65535 | 0, a = e >>> 16 & 65535 | 0, o = 0;
+  for (; t !== 0; ) {
+    o = t > 2e3 ? 2e3 : t, t -= o;
+    do
+      r = r + n[i++] | 0, a = a + r | 0;
+    while (--o);
+    r %= 65521, a %= 65521;
+  }
+  return r | a << 16 | 0;
+};
+var Ue = Br;
+const Ur = () => {
+  let e, n = [];
+  for (var t = 0; t < 256; t++) {
+    e = t;
+    for (var i = 0; i < 8; i++)
+      e = e & 1 ? 3988292384 ^ e >>> 1 : e >>> 1;
+    n[t] = e;
+  }
+  return n;
+}, Dr = new Uint32Array(Ur()), Vr = (e, n, t, i) => {
+  const r = Dr, a = i + t;
+  e ^= -1;
+  for (let o = i; o < a; o++)
+    e = e >>> 8 ^ r[(e ^ n[o]) & 255];
+  return e ^ -1;
+};
+var R = Vr, ge = {
+  2: "need dictionary",
+  /* Z_NEED_DICT       2  */
+  1: "stream end",
+  /* Z_STREAM_END      1  */
+  0: "",
+  /* Z_OK              0  */
+  "-1": "file error",
+  /* Z_ERRNO         (-1) */
+  "-2": "stream error",
+  /* Z_STREAM_ERROR  (-2) */
+  "-3": "data error",
+  /* Z_DATA_ERROR    (-3) */
+  "-4": "insufficient memory",
+  /* Z_MEM_ERROR     (-4) */
+  "-5": "buffer error",
+  /* Z_BUF_ERROR     (-5) */
+  "-6": "incompatible version"
+  /* Z_VERSION_ERROR (-6) */
+}, xe = {
+  /* Allowed flush values; see deflate() and inflate() below for details */
+  Z_NO_FLUSH: 0,
+  Z_PARTIAL_FLUSH: 1,
+  Z_SYNC_FLUSH: 2,
+  Z_FULL_FLUSH: 3,
+  Z_FINISH: 4,
+  Z_BLOCK: 5,
+  Z_TREES: 6,
+  /* Return codes for the compression/decompression functions. Negative values
+  * are errors, positive values are used for special but normal events.
+  */
+  Z_OK: 0,
+  Z_STREAM_END: 1,
+  Z_NEED_DICT: 2,
+  Z_ERRNO: -1,
+  Z_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  //Z_VERSION_ERROR: -6,
+  /* compression levels */
+  Z_NO_COMPRESSION: 0,
+  Z_BEST_SPEED: 1,
+  Z_BEST_COMPRESSION: 9,
+  Z_DEFAULT_COMPRESSION: -1,
+  Z_FILTERED: 1,
+  Z_HUFFMAN_ONLY: 2,
+  Z_RLE: 3,
+  Z_FIXED: 4,
+  Z_DEFAULT_STRATEGY: 0,
+  /* Possible values of the data_type field (though see inflate()) */
+  Z_BINARY: 0,
+  Z_TEXT: 1,
+  //Z_ASCII:                1, // = Z_TEXT (deprecated)
+  Z_UNKNOWN: 2,
+  /* The deflate compression method */
+  Z_DEFLATED: 8
+  //Z_NULL:                 null // Use -1 or null inline, depending on var type
+};
+const { _tr_init: Lr, _tr_stored_block: Rt, _tr_flush_block: Fr, _tr_tally: te, _tr_align: Pr } = Rr, {
+  Z_NO_FLUSH: ne,
+  Z_PARTIAL_FLUSH: Zr,
+  Z_FULL_FLUSH: xr,
+  Z_FINISH: F,
+  Z_BLOCK: ln,
+  Z_OK: B,
+  Z_STREAM_END: fn,
+  Z_STREAM_ERROR: G,
+  Z_DATA_ERROR: Mr,
+  Z_BUF_ERROR: gt,
+  Z_DEFAULT_COMPRESSION: Hr,
+  Z_FILTERED: jr,
+  Z_HUFFMAN_ONLY: We,
+  Z_RLE: Gr,
+  Z_FIXED: Yr,
+  Z_DEFAULT_STRATEGY: Kr,
+  Z_UNKNOWN: Wr,
+  Z_DEFLATED: ut
+} = xe, Xr = 9, qr = 15, Jr = 8, Qr = 29, ea = 256, Bt = ea + 1 + Qr, ta = 30, na = 19, ia = 2 * Bt + 1, ra = 15, I = 3, ee = 258, Y = ee + I + 1, aa = 32, we = 42, Gt = 57, Ut = 69, Dt = 73, Vt = 91, Lt = 103, le = 113, Se = 666, U = 1, ve = 2, ue = 3, ke = 4, oa = 3, fe = (e, n) => (e.msg = ge[n], n), un = (e) => e * 2 - (e > 4 ? 9 : 0), J = (e) => {
+  let n = e.length;
+  for (; --n >= 0; )
+    e[n] = 0;
+}, sa = (e) => {
+  let n, t, i, r = e.w_size;
+  n = e.hash_size, i = n;
+  do
+    t = e.head[--i], e.head[i] = t >= r ? t - r : 0;
+  while (--n);
+  n = r, i = n;
+  do
+    t = e.prev[--i], e.prev[i] = t >= r ? t - r : 0;
+  while (--n);
+};
+let la = (e, n, t) => (n << e.hash_shift ^ t) & e.hash_mask, ie = la;
+const V = (e) => {
+  const n = e.state;
+  let t = n.pending;
+  t > e.avail_out && (t = e.avail_out), t !== 0 && (e.output.set(n.pending_buf.subarray(n.pending_out, n.pending_out + t), e.next_out), e.next_out += t, n.pending_out += t, e.total_out += t, e.avail_out -= t, n.pending -= t, n.pending === 0 && (n.pending_out = 0));
+}, L = (e, n) => {
+  Fr(e, e.block_start >= 0 ? e.block_start : -1, e.strstart - e.block_start, n), e.block_start = e.strstart, V(e.strm);
+}, A = (e, n) => {
+  e.pending_buf[e.pending++] = n;
+}, Ce = (e, n) => {
+  e.pending_buf[e.pending++] = n >>> 8 & 255, e.pending_buf[e.pending++] = n & 255;
+}, Ft = (e, n, t, i) => {
+  let r = e.avail_in;
+  return r > i && (r = i), r === 0 ? 0 : (e.avail_in -= r, n.set(e.input.subarray(e.next_in, e.next_in + r), t), e.state.wrap === 1 ? e.adler = Ue(e.adler, n, r, t) : e.state.wrap === 2 && (e.adler = R(e.adler, n, r, t)), e.next_in += r, e.total_in += r, r);
+}, ui = (e, n) => {
+  let t = e.max_chain_length, i = e.strstart, r, a, o = e.prev_length, l = e.nice_match;
+  const u = e.strstart > e.w_size - Y ? e.strstart - (e.w_size - Y) : 0, s = e.window, f = e.w_mask, d = e.prev, c = e.strstart + ee;
+  let h = s[i + o - 1], _ = s[i + o];
+  e.prev_length >= e.good_match && (t >>= 2), l > e.lookahead && (l = e.lookahead);
+  do
+    if (r = n, !(s[r + o] !== _ || s[r + o - 1] !== h || s[r] !== s[i] || s[++r] !== s[i + 1])) {
+      i += 2, r++;
+      do
+        ;
+      while (s[++i] === s[++r] && s[++i] === s[++r] && s[++i] === s[++r] && s[++i] === s[++r] && s[++i] === s[++r] && s[++i] === s[++r] && s[++i] === s[++r] && s[++i] === s[++r] && i < c);
+      if (a = ee - (c - i), i = c - ee, a > o) {
+        if (e.match_start = n, o = a, a >= l)
+          break;
+        h = s[i + o - 1], _ = s[i + o];
+      }
+    }
+  while ((n = d[n & f]) > u && --t !== 0);
+  return o <= e.lookahead ? o : e.lookahead;
+}, me = (e) => {
+  const n = e.w_size;
+  let t, i, r;
+  do {
+    if (i = e.window_size - e.lookahead - e.strstart, e.strstart >= n + (n - Y) && (e.window.set(e.window.subarray(n, n + n - i), 0), e.match_start -= n, e.strstart -= n, e.block_start -= n, e.insert > e.strstart && (e.insert = e.strstart), sa(e), i += n), e.strm.avail_in === 0)
+      break;
+    if (t = Ft(e.strm, e.window, e.strstart + e.lookahead, i), e.lookahead += t, e.lookahead + e.insert >= I)
+      for (r = e.strstart - e.insert, e.ins_h = e.window[r], e.ins_h = ie(e, e.ins_h, e.window[r + 1]); e.insert && (e.ins_h = ie(e, e.ins_h, e.window[r + I - 1]), e.prev[r & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = r, r++, e.insert--, !(e.lookahead + e.insert < I)); )
+        ;
+  } while (e.lookahead < Y && e.strm.avail_in !== 0);
+}, hi = (e, n) => {
+  let t = e.pending_buf_size - 5 > e.w_size ? e.w_size : e.pending_buf_size - 5, i, r, a, o = 0, l = e.strm.avail_in;
+  do {
+    if (i = 65535, a = e.bi_valid + 42 >> 3, e.strm.avail_out < a || (a = e.strm.avail_out - a, r = e.strstart - e.block_start, i > r + e.strm.avail_in && (i = r + e.strm.avail_in), i > a && (i = a), i < t && (i === 0 && n !== F || n === ne || i !== r + e.strm.avail_in)))
+      break;
+    o = n === F && i === r + e.strm.avail_in ? 1 : 0, Rt(e, 0, 0, o), e.pending_buf[e.pending - 4] = i, e.pending_buf[e.pending - 3] = i >> 8, e.pending_buf[e.pending - 2] = ~i, e.pending_buf[e.pending - 1] = ~i >> 8, V(e.strm), r && (r > i && (r = i), e.strm.output.set(e.window.subarray(e.block_start, e.block_start + r), e.strm.next_out), e.strm.next_out += r, e.strm.avail_out -= r, e.strm.total_out += r, e.block_start += r, i -= r), i && (Ft(e.strm, e.strm.output, e.strm.next_out, i), e.strm.next_out += i, e.strm.avail_out -= i, e.strm.total_out += i);
+  } while (o === 0);
+  return l -= e.strm.avail_in, l && (l >= e.w_size ? (e.matches = 2, e.window.set(e.strm.input.subarray(e.strm.next_in - e.w_size, e.strm.next_in), 0), e.strstart = e.w_size, e.insert = e.strstart) : (e.window_size - e.strstart <= l && (e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, e.insert > e.strstart && (e.insert = e.strstart)), e.window.set(e.strm.input.subarray(e.strm.next_in - l, e.strm.next_in), e.strstart), e.strstart += l, e.insert += l > e.w_size - e.insert ? e.w_size - e.insert : l), e.block_start = e.strstart), e.high_water < e.strstart && (e.high_water = e.strstart), o ? ke : n !== ne && n !== F && e.strm.avail_in === 0 && e.strstart === e.block_start ? ve : (a = e.window_size - e.strstart, e.strm.avail_in > a && e.block_start >= e.w_size && (e.block_start -= e.w_size, e.strstart -= e.w_size, e.window.set(e.window.subarray(e.w_size, e.w_size + e.strstart), 0), e.matches < 2 && e.matches++, a += e.w_size, e.insert > e.strstart && (e.insert = e.strstart)), a > e.strm.avail_in && (a = e.strm.avail_in), a && (Ft(e.strm, e.window, e.strstart, a), e.strstart += a, e.insert += a > e.w_size - e.insert ? e.w_size - e.insert : a), e.high_water < e.strstart && (e.high_water = e.strstart), a = e.bi_valid + 42 >> 3, a = e.pending_buf_size - a > 65535 ? 65535 : e.pending_buf_size - a, t = a > e.w_size ? e.w_size : a, r = e.strstart - e.block_start, (r >= t || (r || n === F) && n !== ne && e.strm.avail_in === 0 && r <= a) && (i = r > a ? a : r, o = n === F && e.strm.avail_in === 0 && i === r ? 1 : 0, Rt(e, e.block_start, i, o), e.block_start += i, V(e.strm)), o ? ue : U);
+}, wt = (e, n) => {
+  let t, i;
+  for (; ; ) {
+    if (e.lookahead < Y) {
+      if (me(e), e.lookahead < Y && n === ne)
+        return U;
+      if (e.lookahead === 0)
+        break;
+    }
+    if (t = 0, e.lookahead >= I && (e.ins_h = ie(e, e.ins_h, e.window[e.strstart + I - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), t !== 0 && e.strstart - t <= e.w_size - Y && (e.match_length = ui(e, t)), e.match_length >= I)
+      if (i = te(e, e.strstart - e.match_start, e.match_length - I), e.lookahead -= e.match_length, e.match_length <= e.max_lazy_match && e.lookahead >= I) {
+        e.match_length--;
+        do
+          e.strstart++, e.ins_h = ie(e, e.ins_h, e.window[e.strstart + I - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart;
+        while (--e.match_length !== 0);
+        e.strstart++;
+      } else
+        e.strstart += e.match_length, e.match_length = 0, e.ins_h = e.window[e.strstart], e.ins_h = ie(e, e.ins_h, e.window[e.strstart + 1]);
+    else
+      i = te(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++;
+    if (i && (L(e, !1), e.strm.avail_out === 0))
+      return U;
+  }
+  return e.insert = e.strstart < I - 1 ? e.strstart : I - 1, n === F ? (L(e, !0), e.strm.avail_out === 0 ? ue : ke) : e.sym_next && (L(e, !1), e.strm.avail_out === 0) ? U : ve;
+}, de = (e, n) => {
+  let t, i, r;
+  for (; ; ) {
+    if (e.lookahead < Y) {
+      if (me(e), e.lookahead < Y && n === ne)
+        return U;
+      if (e.lookahead === 0)
+        break;
+    }
+    if (t = 0, e.lookahead >= I && (e.ins_h = ie(e, e.ins_h, e.window[e.strstart + I - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart), e.prev_length = e.match_length, e.prev_match = e.match_start, e.match_length = I - 1, t !== 0 && e.prev_length < e.max_lazy_match && e.strstart - t <= e.w_size - Y && (e.match_length = ui(e, t), e.match_length <= 5 && (e.strategy === jr || e.match_length === I && e.strstart - e.match_start > 4096) && (e.match_length = I - 1)), e.prev_length >= I && e.match_length <= e.prev_length) {
+      r = e.strstart + e.lookahead - I, i = te(e, e.strstart - 1 - e.prev_match, e.prev_length - I), e.lookahead -= e.prev_length - 1, e.prev_length -= 2;
+      do
+        ++e.strstart <= r && (e.ins_h = ie(e, e.ins_h, e.window[e.strstart + I - 1]), t = e.prev[e.strstart & e.w_mask] = e.head[e.ins_h], e.head[e.ins_h] = e.strstart);
+      while (--e.prev_length !== 0);
+      if (e.match_available = 0, e.match_length = I - 1, e.strstart++, i && (L(e, !1), e.strm.avail_out === 0))
+        return U;
+    } else if (e.match_available) {
+      if (i = te(e, 0, e.window[e.strstart - 1]), i && L(e, !1), e.strstart++, e.lookahead--, e.strm.avail_out === 0)
+        return U;
+    } else
+      e.match_available = 1, e.strstart++, e.lookahead--;
+  }
+  return e.match_available && (i = te(e, 0, e.window[e.strstart - 1]), e.match_available = 0), e.insert = e.strstart < I - 1 ? e.strstart : I - 1, n === F ? (L(e, !0), e.strm.avail_out === 0 ? ue : ke) : e.sym_next && (L(e, !1), e.strm.avail_out === 0) ? U : ve;
+}, fa = (e, n) => {
+  let t, i, r, a;
+  const o = e.window;
+  for (; ; ) {
+    if (e.lookahead <= ee) {
+      if (me(e), e.lookahead <= ee && n === ne)
+        return U;
+      if (e.lookahead === 0)
+        break;
+    }
+    if (e.match_length = 0, e.lookahead >= I && e.strstart > 0 && (r = e.strstart - 1, i = o[r], i === o[++r] && i === o[++r] && i === o[++r])) {
+      a = e.strstart + ee;
+      do
+        ;
+      while (i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && i === o[++r] && r < a);
+      e.match_length = ee - (a - r), e.match_length > e.lookahead && (e.match_length = e.lookahead);
+    }
+    if (e.match_length >= I ? (t = te(e, 1, e.match_length - I), e.lookahead -= e.match_length, e.strstart += e.match_length, e.match_length = 0) : (t = te(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++), t && (L(e, !1), e.strm.avail_out === 0))
+      return U;
+  }
+  return e.insert = 0, n === F ? (L(e, !0), e.strm.avail_out === 0 ? ue : ke) : e.sym_next && (L(e, !1), e.strm.avail_out === 0) ? U : ve;
+}, ua = (e, n) => {
+  let t;
+  for (; ; ) {
+    if (e.lookahead === 0 && (me(e), e.lookahead === 0)) {
+      if (n === ne)
+        return U;
+      break;
+    }
+    if (e.match_length = 0, t = te(e, 0, e.window[e.strstart]), e.lookahead--, e.strstart++, t && (L(e, !1), e.strm.avail_out === 0))
+      return U;
+  }
+  return e.insert = 0, n === F ? (L(e, !0), e.strm.avail_out === 0 ? ue : ke) : e.sym_next && (L(e, !1), e.strm.avail_out === 0) ? U : ve;
+};
+function H(e, n, t, i, r) {
+  this.good_length = e, this.max_lazy = n, this.nice_length = t, this.max_chain = i, this.func = r;
+}
+const Ne = [
+  /*      good lazy nice chain */
+  new H(0, 0, 0, 0, hi),
+  /* 0 store only */
+  new H(4, 4, 8, 4, wt),
+  /* 1 max speed, no lazy matches */
+  new H(4, 5, 16, 8, wt),
+  /* 2 */
+  new H(4, 6, 32, 32, wt),
+  /* 3 */
+  new H(4, 4, 16, 16, de),
+  /* 4 lazy matches */
+  new H(8, 16, 32, 32, de),
+  /* 5 */
+  new H(8, 16, 128, 128, de),
+  /* 6 */
+  new H(8, 32, 128, 256, de),
+  /* 7 */
+  new H(32, 128, 258, 1024, de),
+  /* 8 */
+  new H(32, 258, 258, 4096, de)
+  /* 9 max compression */
+], ha = (e) => {
+  e.window_size = 2 * e.w_size, J(e.head), e.max_lazy_match = Ne[e.level].max_lazy, e.good_match = Ne[e.level].good_length, e.nice_match = Ne[e.level].nice_length, e.max_chain_length = Ne[e.level].max_chain, e.strstart = 0, e.block_start = 0, e.lookahead = 0, e.insert = 0, e.match_length = e.prev_length = I - 1, e.match_available = 0, e.ins_h = 0;
+};
+function ca() {
+  this.strm = null, this.status = 0, this.pending_buf = null, this.pending_buf_size = 0, this.pending_out = 0, this.pending = 0, this.wrap = 0, this.gzhead = null, this.gzindex = 0, this.method = ut, this.last_flush = -1, this.w_size = 0, this.w_bits = 0, this.w_mask = 0, this.window = null, this.window_size = 0, this.prev = null, this.head = null, this.ins_h = 0, this.hash_size = 0, this.hash_bits = 0, this.hash_mask = 0, this.hash_shift = 0, this.block_start = 0, this.match_length = 0, this.prev_match = 0, this.match_available = 0, this.strstart = 0, this.match_start = 0, this.lookahead = 0, this.prev_length = 0, this.max_chain_length = 0, this.max_lazy_match = 0, this.level = 0, this.strategy = 0, this.good_match = 0, this.nice_match = 0, this.dyn_ltree = new Uint16Array(ia * 2), this.dyn_dtree = new Uint16Array((2 * ta + 1) * 2), this.bl_tree = new Uint16Array((2 * na + 1) * 2), J(this.dyn_ltree), J(this.dyn_dtree), J(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new Uint16Array(ra + 1), this.heap = new Uint16Array(2 * Bt + 1), J(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new Uint16Array(2 * Bt + 1), J(this.depth), this.sym_buf = 0, this.lit_bufsize = 0, this.sym_next = 0, this.sym_end = 0, this.opt_len = 0, this.static_len = 0, this.matches = 0, this.insert = 0, this.bi_buf = 0, this.bi_valid = 0;
+}
+const Me = (e) => {
+  if (!e)
+    return 1;
+  const n = e.state;
+  return !n || n.strm !== e || n.status !== we && //#ifdef GZIP
+  n.status !== Gt && //#endif
+  n.status !== Ut && n.status !== Dt && n.status !== Vt && n.status !== Lt && n.status !== le && n.status !== Se ? 1 : 0;
+}, ci = (e) => {
+  if (Me(e))
+    return fe(e, G);
+  e.total_in = e.total_out = 0, e.data_type = Wr;
+  const n = e.state;
+  return n.pending = 0, n.pending_out = 0, n.wrap < 0 && (n.wrap = -n.wrap), n.status = //#ifdef GZIP
+  n.wrap === 2 ? Gt : (
+    //#endif
+    n.wrap ? we : le
+  ), e.adler = n.wrap === 2 ? 0 : 1, n.last_flush = -2, Lr(n), B;
+}, di = (e) => {
+  const n = ci(e);
+  return n === B && ha(e.state), n;
+}, da = (e, n) => Me(e) || e.state.wrap !== 2 ? G : (e.state.gzhead = n, B), pi = (e, n, t, i, r, a) => {
+  if (!e)
+    return G;
+  let o = 1;
+  if (n === Hr && (n = 6), i < 0 ? (o = 0, i = -i) : i > 15 && (o = 2, i -= 16), r < 1 || r > Xr || t !== ut || i < 8 || i > 15 || n < 0 || n > 9 || a < 0 || a > Yr || i === 8 && o !== 1)
+    return fe(e, G);
+  i === 8 && (i = 9);
+  const l = new ca();
+  return e.state = l, l.strm = e, l.status = we, l.wrap = o, l.gzhead = null, l.w_bits = i, l.w_size = 1 << l.w_bits, l.w_mask = l.w_size - 1, l.hash_bits = r + 7, l.hash_size = 1 << l.hash_bits, l.hash_mask = l.hash_size - 1, l.hash_shift = ~~((l.hash_bits + I - 1) / I), l.window = new Uint8Array(l.w_size * 2), l.head = new Uint16Array(l.hash_size), l.prev = new Uint16Array(l.w_size), l.lit_bufsize = 1 << r + 6, l.pending_buf_size = l.lit_bufsize * 4, l.pending_buf = new Uint8Array(l.pending_buf_size), l.sym_buf = l.lit_bufsize, l.sym_end = (l.lit_bufsize - 1) * 3, l.level = n, l.strategy = a, l.method = t, di(e);
+}, pa = (e, n) => pi(e, n, ut, qr, Jr, Kr), _a = (e, n) => {
+  if (Me(e) || n > ln || n < 0)
+    return e ? fe(e, G) : G;
+  const t = e.state;
+  if (!e.output || e.avail_in !== 0 && !e.input || t.status === Se && n !== F)
+    return fe(e, e.avail_out === 0 ? gt : G);
+  const i = t.last_flush;
+  if (t.last_flush = n, t.pending !== 0) {
+    if (V(e), e.avail_out === 0)
+      return t.last_flush = -1, B;
+  } else if (e.avail_in === 0 && un(n) <= un(i) && n !== F)
+    return fe(e, gt);
+  if (t.status === Se && e.avail_in !== 0)
+    return fe(e, gt);
+  if (t.status === we && t.wrap === 0 && (t.status = le), t.status === we) {
+    let r = ut + (t.w_bits - 8 << 4) << 8, a = -1;
+    if (t.strategy >= We || t.level < 2 ? a = 0 : t.level < 6 ? a = 1 : t.level === 6 ? a = 2 : a = 3, r |= a << 6, t.strstart !== 0 && (r |= aa), r += 31 - r % 31, Ce(t, r), t.strstart !== 0 && (Ce(t, e.adler >>> 16), Ce(t, e.adler & 65535)), e.adler = 1, t.status = le, V(e), t.pending !== 0)
+      return t.last_flush = -1, B;
+  }
+  if (t.status === Gt) {
+    if (e.adler = 0, A(t, 31), A(t, 139), A(t, 8), t.gzhead)
+      A(
+        t,
+        (t.gzhead.text ? 1 : 0) + (t.gzhead.hcrc ? 2 : 0) + (t.gzhead.extra ? 4 : 0) + (t.gzhead.name ? 8 : 0) + (t.gzhead.comment ? 16 : 0)
+      ), A(t, t.gzhead.time & 255), A(t, t.gzhead.time >> 8 & 255), A(t, t.gzhead.time >> 16 & 255), A(t, t.gzhead.time >> 24 & 255), A(t, t.level === 9 ? 2 : t.strategy >= We || t.level < 2 ? 4 : 0), A(t, t.gzhead.os & 255), t.gzhead.extra && t.gzhead.extra.length && (A(t, t.gzhead.extra.length & 255), A(t, t.gzhead.extra.length >> 8 & 255)), t.gzhead.hcrc && (e.adler = R(e.adler, t.pending_buf, t.pending, 0)), t.gzindex = 0, t.status = Ut;
+    else if (A(t, 0), A(t, 0), A(t, 0), A(t, 0), A(t, 0), A(t, t.level === 9 ? 2 : t.strategy >= We || t.level < 2 ? 4 : 0), A(t, oa), t.status = le, V(e), t.pending !== 0)
+      return t.last_flush = -1, B;
+  }
+  if (t.status === Ut) {
+    if (t.gzhead.extra) {
+      let r = t.pending, a = (t.gzhead.extra.length & 65535) - t.gzindex;
+      for (; t.pending + a > t.pending_buf_size; ) {
+        let l = t.pending_buf_size - t.pending;
+        if (t.pending_buf.set(t.gzhead.extra.subarray(t.gzindex, t.gzindex + l), t.pending), t.pending = t.pending_buf_size, t.gzhead.hcrc && t.pending > r && (e.adler = R(e.adler, t.pending_buf, t.pending - r, r)), t.gzindex += l, V(e), t.pending !== 0)
+          return t.last_flush = -1, B;
+        r = 0, a -= l;
+      }
+      let o = new Uint8Array(t.gzhead.extra);
+      t.pending_buf.set(o.subarray(t.gzindex, t.gzindex + a), t.pending), t.pending += a, t.gzhead.hcrc && t.pending > r && (e.adler = R(e.adler, t.pending_buf, t.pending - r, r)), t.gzindex = 0;
+    }
+    t.status = Dt;
+  }
+  if (t.status === Dt) {
+    if (t.gzhead.name) {
+      let r = t.pending, a;
+      do {
+        if (t.pending === t.pending_buf_size) {
+          if (t.gzhead.hcrc && t.pending > r && (e.adler = R(e.adler, t.pending_buf, t.pending - r, r)), V(e), t.pending !== 0)
+            return t.last_flush = -1, B;
+          r = 0;
+        }
+        t.gzindex < t.gzhead.name.length ? a = t.gzhead.name.charCodeAt(t.gzindex++) & 255 : a = 0, A(t, a);
+      } while (a !== 0);
+      t.gzhead.hcrc && t.pending > r && (e.adler = R(e.adler, t.pending_buf, t.pending - r, r)), t.gzindex = 0;
+    }
+    t.status = Vt;
+  }
+  if (t.status === Vt) {
+    if (t.gzhead.comment) {
+      let r = t.pending, a;
+      do {
+        if (t.pending === t.pending_buf_size) {
+          if (t.gzhead.hcrc && t.pending > r && (e.adler = R(e.adler, t.pending_buf, t.pending - r, r)), V(e), t.pending !== 0)
+            return t.last_flush = -1, B;
+          r = 0;
+        }
+        t.gzindex < t.gzhead.comment.length ? a = t.gzhead.comment.charCodeAt(t.gzindex++) & 255 : a = 0, A(t, a);
+      } while (a !== 0);
+      t.gzhead.hcrc && t.pending > r && (e.adler = R(e.adler, t.pending_buf, t.pending - r, r));
+    }
+    t.status = Lt;
+  }
+  if (t.status === Lt) {
+    if (t.gzhead.hcrc) {
+      if (t.pending + 2 > t.pending_buf_size && (V(e), t.pending !== 0))
+        return t.last_flush = -1, B;
+      A(t, e.adler & 255), A(t, e.adler >> 8 & 255), e.adler = 0;
+    }
+    if (t.status = le, V(e), t.pending !== 0)
+      return t.last_flush = -1, B;
+  }
+  if (e.avail_in !== 0 || t.lookahead !== 0 || n !== ne && t.status !== Se) {
+    let r = t.level === 0 ? hi(t, n) : t.strategy === We ? ua(t, n) : t.strategy === Gr ? fa(t, n) : Ne[t.level].func(t, n);
+    if ((r === ue || r === ke) && (t.status = Se), r === U || r === ue)
+      return e.avail_out === 0 && (t.last_flush = -1), B;
+    if (r === ve && (n === Zr ? Pr(t) : n !== ln && (Rt(t, 0, 0, !1), n === xr && (J(t.head), t.lookahead === 0 && (t.strstart = 0, t.block_start = 0, t.insert = 0))), V(e), e.avail_out === 0))
+      return t.last_flush = -1, B;
+  }
+  return n !== F ? B : t.wrap <= 0 ? fn : (t.wrap === 2 ? (A(t, e.adler & 255), A(t, e.adler >> 8 & 255), A(t, e.adler >> 16 & 255), A(t, e.adler >> 24 & 255), A(t, e.total_in & 255), A(t, e.total_in >> 8 & 255), A(t, e.total_in >> 16 & 255), A(t, e.total_in >> 24 & 255)) : (Ce(t, e.adler >>> 16), Ce(t, e.adler & 65535)), V(e), t.wrap > 0 && (t.wrap = -t.wrap), t.pending !== 0 ? B : fn);
+}, ba = (e) => {
+  if (Me(e))
+    return G;
+  const n = e.state.status;
+  return e.state = null, n === le ? fe(e, Mr) : B;
+}, ga = (e, n) => {
+  let t = n.length;
+  if (Me(e))
+    return G;
+  const i = e.state, r = i.wrap;
+  if (r === 2 || r === 1 && i.status !== we || i.lookahead)
+    return G;
+  if (r === 1 && (e.adler = Ue(e.adler, n, t, 0)), i.wrap = 0, t >= i.w_size) {
+    r === 0 && (J(i.head), i.strstart = 0, i.block_start = 0, i.insert = 0);
+    let u = new Uint8Array(i.w_size);
+    u.set(n.subarray(t - i.w_size, t), 0), n = u, t = i.w_size;
+  }
+  const a = e.avail_in, o = e.next_in, l = e.input;
+  for (e.avail_in = t, e.next_in = 0, e.input = n, me(i); i.lookahead >= I; ) {
+    let u = i.strstart, s = i.lookahead - (I - 1);
+    do
+      i.ins_h = ie(i, i.ins_h, i.window[u + I - 1]), i.prev[u & i.w_mask] = i.head[i.ins_h], i.head[i.ins_h] = u, u++;
+    while (--s);
+    i.strstart = u, i.lookahead = I - 1, me(i);
+  }
+  return i.strstart += i.lookahead, i.block_start = i.strstart, i.insert = i.lookahead, i.lookahead = 0, i.match_length = i.prev_length = I - 1, i.match_available = 0, e.next_in = o, e.input = l, e.avail_in = a, i.wrap = r, B;
+};
+var wa = pa, ma = pi, ya = di, va = ci, ka = da, $a = _a, Ea = ba, Ca = ga, Sa = "pako deflate (from Nodeca project)", Ie = {
+  deflateInit: wa,
+  deflateInit2: ma,
+  deflateReset: ya,
+  deflateResetKeep: va,
+  deflateSetHeader: ka,
+  deflate: $a,
+  deflateEnd: Ea,
+  deflateSetDictionary: Ca,
+  deflateInfo: Sa
+};
+const Na = (e, n) => Object.prototype.hasOwnProperty.call(e, n);
+var Ta = function(e) {
+  const n = Array.prototype.slice.call(arguments, 1);
+  for (; n.length; ) {
+    const t = n.shift();
+    if (t) {
+      if (typeof t != "object")
+        throw new TypeError(t + "must be non-object");
+      for (const i in t)
+        Na(t, i) && (e[i] = t[i]);
+    }
+  }
+  return e;
+}, Ia = (e) => {
+  let n = 0;
+  for (let i = 0, r = e.length; i < r; i++)
+    n += e[i].length;
+  const t = new Uint8Array(n);
+  for (let i = 0, r = 0, a = e.length; i < a; i++) {
+    let o = e[i];
+    t.set(o, r), r += o.length;
+  }
+  return t;
+}, ht = {
+  assign: Ta,
+  flattenChunks: Ia
+};
+let _i = !0;
+try {
+  String.fromCharCode.apply(null, new Uint8Array(1));
+} catch {
+  _i = !1;
+}
+const De = new Uint8Array(256);
+for (let e = 0; e < 256; e++)
+  De[e] = e >= 252 ? 6 : e >= 248 ? 5 : e >= 240 ? 4 : e >= 224 ? 3 : e >= 192 ? 2 : 1;
+De[254] = De[254] = 1;
+var Aa = (e) => {
+  if (typeof TextEncoder == "function" && TextEncoder.prototype.encode)
+    return new TextEncoder().encode(e);
+  let n, t, i, r, a, o = e.length, l = 0;
+  for (r = 0; r < o; r++)
+    t = e.charCodeAt(r), (t & 64512) === 55296 && r + 1 < o && (i = e.charCodeAt(r + 1), (i & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (i - 56320), r++)), l += t < 128 ? 1 : t < 2048 ? 2 : t < 65536 ? 3 : 4;
+  for (n = new Uint8Array(l), a = 0, r = 0; a < l; r++)
+    t = e.charCodeAt(r), (t & 64512) === 55296 && r + 1 < o && (i = e.charCodeAt(r + 1), (i & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (i - 56320), r++)), t < 128 ? n[a++] = t : t < 2048 ? (n[a++] = 192 | t >>> 6, n[a++] = 128 | t & 63) : t < 65536 ? (n[a++] = 224 | t >>> 12, n[a++] = 128 | t >>> 6 & 63, n[a++] = 128 | t & 63) : (n[a++] = 240 | t >>> 18, n[a++] = 128 | t >>> 12 & 63, n[a++] = 128 | t >>> 6 & 63, n[a++] = 128 | t & 63);
+  return n;
+};
+const Oa = (e, n) => {
+  if (n < 65534 && e.subarray && _i)
+    return String.fromCharCode.apply(null, e.length === n ? e : e.subarray(0, n));
+  let t = "";
+  for (let i = 0; i < n; i++)
+    t += String.fromCharCode(e[i]);
+  return t;
+};
+var za = (e, n) => {
+  const t = n || e.length;
+  if (typeof TextDecoder == "function" && TextDecoder.prototype.decode)
+    return new TextDecoder().decode(e.subarray(0, n));
+  let i, r;
+  const a = new Array(t * 2);
+  for (r = 0, i = 0; i < t; ) {
+    let o = e[i++];
+    if (o < 128) {
+      a[r++] = o;
+      continue;
+    }
+    let l = De[o];
+    if (l > 4) {
+      a[r++] = 65533, i += l - 1;
+      continue;
+    }
+    for (o &= l === 2 ? 31 : l === 3 ? 15 : 7; l > 1 && i < t; )
+      o = o << 6 | e[i++] & 63, l--;
+    if (l > 1) {
+      a[r++] = 65533;
+      continue;
+    }
+    o < 65536 ? a[r++] = o : (o -= 65536, a[r++] = 55296 | o >> 10 & 1023, a[r++] = 56320 | o & 1023);
+  }
+  return Oa(a, r);
+}, Ra = (e, n) => {
+  n = n || e.length, n > e.length && (n = e.length);
+  let t = n - 1;
+  for (; t >= 0 && (e[t] & 192) === 128; )
+    t--;
+  return t < 0 || t === 0 ? n : t + De[e[t]] > n ? t : n;
+}, Ve = {
+  string2buf: Aa,
+  buf2string: za,
+  utf8border: Ra
+};
+function Ba() {
+  this.input = null, this.next_in = 0, this.avail_in = 0, this.total_in = 0, this.output = null, this.next_out = 0, this.avail_out = 0, this.total_out = 0, this.msg = "", this.state = null, this.data_type = 2, this.adler = 0;
+}
+var bi = Ba;
+const gi = Object.prototype.toString, {
+  Z_NO_FLUSH: Ua,
+  Z_SYNC_FLUSH: Da,
+  Z_FULL_FLUSH: Va,
+  Z_FINISH: La,
+  Z_OK: rt,
+  Z_STREAM_END: Fa,
+  Z_DEFAULT_COMPRESSION: Pa,
+  Z_DEFAULT_STRATEGY: Za,
+  Z_DEFLATED: xa
+} = xe;
+function Yt(e) {
+  this.options = ht.assign({
+    level: Pa,
+    method: xa,
+    chunkSize: 16384,
+    windowBits: 15,
+    memLevel: 8,
+    strategy: Za
+  }, e || {});
+  let n = this.options;
+  n.raw && n.windowBits > 0 ? n.windowBits = -n.windowBits : n.gzip && n.windowBits > 0 && n.windowBits < 16 && (n.windowBits += 16), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new bi(), this.strm.avail_out = 0;
+  let t = Ie.deflateInit2(
+    this.strm,
+    n.level,
+    n.method,
+    n.windowBits,
+    n.memLevel,
+    n.strategy
+  );
+  if (t !== rt)
+    throw new Error(ge[t]);
+  if (n.header && Ie.deflateSetHeader(this.strm, n.header), n.dictionary) {
+    let i;
+    if (typeof n.dictionary == "string" ? i = Ve.string2buf(n.dictionary) : gi.call(n.dictionary) === "[object ArrayBuffer]" ? i = new Uint8Array(n.dictionary) : i = n.dictionary, t = Ie.deflateSetDictionary(this.strm, i), t !== rt)
+      throw new Error(ge[t]);
+    this._dict_set = !0;
+  }
+}
+Yt.prototype.push = function(e, n) {
+  const t = this.strm, i = this.options.chunkSize;
+  let r, a;
+  if (this.ended)
+    return !1;
+  for (n === ~~n ? a = n : a = n === !0 ? La : Ua, typeof e == "string" ? t.input = Ve.string2buf(e) : gi.call(e) === "[object ArrayBuffer]" ? t.input = new Uint8Array(e) : t.input = e, t.next_in = 0, t.avail_in = t.input.length; ; ) {
+    if (t.avail_out === 0 && (t.output = new Uint8Array(i), t.next_out = 0, t.avail_out = i), (a === Da || a === Va) && t.avail_out <= 6) {
+      this.onData(t.output.subarray(0, t.next_out)), t.avail_out = 0;
+      continue;
+    }
+    if (r = Ie.deflate(t, a), r === Fa)
+      return t.next_out > 0 && this.onData(t.output.subarray(0, t.next_out)), r = Ie.deflateEnd(this.strm), this.onEnd(r), this.ended = !0, r === rt;
+    if (t.avail_out === 0) {
+      this.onData(t.output);
+      continue;
+    }
+    if (a > 0 && t.next_out > 0) {
+      this.onData(t.output.subarray(0, t.next_out)), t.avail_out = 0;
+      continue;
+    }
+    if (t.avail_in === 0)
+      break;
+  }
+  return !0;
+};
+Yt.prototype.onData = function(e) {
+  this.chunks.push(e);
+};
+Yt.prototype.onEnd = function(e) {
+  e === rt && (this.result = ht.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg;
+};
+const Xe = 16209, Ma = 16191;
+var Ha = function(n, t) {
+  let i, r, a, o, l, u, s, f, d, c, h, _, g, k, y, E, C, p, $, S, b, w, m, v;
+  const T = n.state;
+  i = n.next_in, m = n.input, r = i + (n.avail_in - 5), a = n.next_out, v = n.output, o = a - (t - n.avail_out), l = a + (n.avail_out - 257), u = T.dmax, s = T.wsize, f = T.whave, d = T.wnext, c = T.window, h = T.hold, _ = T.bits, g = T.lencode, k = T.distcode, y = (1 << T.lenbits) - 1, E = (1 << T.distbits) - 1;
+  e:
+    do {
+      _ < 15 && (h += m[i++] << _, _ += 8, h += m[i++] << _, _ += 8), C = g[h & y];
+      t:
+        for (; ; ) {
+          if (p = C >>> 24, h >>>= p, _ -= p, p = C >>> 16 & 255, p === 0)
+            v[a++] = C & 65535;
+          else if (p & 16) {
+            $ = C & 65535, p &= 15, p && (_ < p && (h += m[i++] << _, _ += 8), $ += h & (1 << p) - 1, h >>>= p, _ -= p), _ < 15 && (h += m[i++] << _, _ += 8, h += m[i++] << _, _ += 8), C = k[h & E];
+            n:
+              for (; ; ) {
+                if (p = C >>> 24, h >>>= p, _ -= p, p = C >>> 16 & 255, p & 16) {
+                  if (S = C & 65535, p &= 15, _ < p && (h += m[i++] << _, _ += 8, _ < p && (h += m[i++] << _, _ += 8)), S += h & (1 << p) - 1, S > u) {
+                    n.msg = "invalid distance too far back", T.mode = Xe;
+                    break e;
+                  }
+                  if (h >>>= p, _ -= p, p = a - o, S > p) {
+                    if (p = S - p, p > f && T.sane) {
+                      n.msg = "invalid distance too far back", T.mode = Xe;
+                      break e;
+                    }
+                    if (b = 0, w = c, d === 0) {
+                      if (b += s - p, p < $) {
+                        $ -= p;
+                        do
+                          v[a++] = c[b++];
+                        while (--p);
+                        b = a - S, w = v;
+                      }
+                    } else if (d < p) {
+                      if (b += s + d - p, p -= d, p < $) {
+                        $ -= p;
+                        do
+                          v[a++] = c[b++];
+                        while (--p);
+                        if (b = 0, d < $) {
+                          p = d, $ -= p;
+                          do
+                            v[a++] = c[b++];
+                          while (--p);
+                          b = a - S, w = v;
+                        }
+                      }
+                    } else if (b += d - p, p < $) {
+                      $ -= p;
+                      do
+                        v[a++] = c[b++];
+                      while (--p);
+                      b = a - S, w = v;
+                    }
+                    for (; $ > 2; )
+                      v[a++] = w[b++], v[a++] = w[b++], v[a++] = w[b++], $ -= 3;
+                    $ && (v[a++] = w[b++], $ > 1 && (v[a++] = w[b++]));
+                  } else {
+                    b = a - S;
+                    do
+                      v[a++] = v[b++], v[a++] = v[b++], v[a++] = v[b++], $ -= 3;
+                    while ($ > 2);
+                    $ && (v[a++] = v[b++], $ > 1 && (v[a++] = v[b++]));
+                  }
+                } else if (p & 64) {
+                  n.msg = "invalid distance code", T.mode = Xe;
+                  break e;
+                } else {
+                  C = k[(C & 65535) + (h & (1 << p) - 1)];
+                  continue n;
+                }
+                break;
+              }
+          } else if (p & 64)
+            if (p & 32) {
+              T.mode = Ma;
+              break e;
+            } else {
+              n.msg = "invalid literal/length code", T.mode = Xe;
+              break e;
+            }
+          else {
+            C = g[(C & 65535) + (h & (1 << p) - 1)];
+            continue t;
+          }
+          break;
+        }
+    } while (i < r && a < l);
+  $ = _ >> 3, i -= $, _ -= $ << 3, h &= (1 << _) - 1, n.next_in = i, n.next_out = a, n.avail_in = i < r ? 5 + (r - i) : 5 - (i - r), n.avail_out = a < l ? 257 + (l - a) : 257 - (a - l), T.hold = h, T.bits = _;
+};
+const pe = 15, hn = 852, cn = 592, dn = 0, mt = 1, pn = 2, ja = new Uint16Array([
+  /* Length codes 257..285 base */
+  3,
+  4,
+  5,
+  6,
+  7,
+  8,
+  9,
+  10,
+  11,
+  13,
+  15,
+  17,
+  19,
+  23,
+  27,
+  31,
+  35,
+  43,
+  51,
+  59,
+  67,
+  83,
+  99,
+  115,
+  131,
+  163,
+  195,
+  227,
+  258,
+  0,
+  0
+]), Ga = new Uint8Array([
+  /* Length codes 257..285 extra */
+  16,
+  16,
+  16,
+  16,
+  16,
+  16,
+  16,
+  16,
+  17,
+  17,
+  17,
+  17,
+  18,
+  18,
+  18,
+  18,
+  19,
+  19,
+  19,
+  19,
+  20,
+  20,
+  20,
+  20,
+  21,
+  21,
+  21,
+  21,
+  16,
+  72,
+  78
+]), Ya = new Uint16Array([
+  /* Distance codes 0..29 base */
+  1,
+  2,
+  3,
+  4,
+  5,
+  7,
+  9,
+  13,
+  17,
+  25,
+  33,
+  49,
+  65,
+  97,
+  129,
+  193,
+  257,
+  385,
+  513,
+  769,
+  1025,
+  1537,
+  2049,
+  3073,
+  4097,
+  6145,
+  8193,
+  12289,
+  16385,
+  24577,
+  0,
+  0
+]), Ka = new Uint8Array([
+  /* Distance codes 0..29 extra */
+  16,
+  16,
+  16,
+  16,
+  17,
+  17,
+  18,
+  18,
+  19,
+  19,
+  20,
+  20,
+  21,
+  21,
+  22,
+  22,
+  23,
+  23,
+  24,
+  24,
+  25,
+  25,
+  26,
+  26,
+  27,
+  27,
+  28,
+  28,
+  29,
+  29,
+  64,
+  64
+]), Wa = (e, n, t, i, r, a, o, l) => {
+  const u = l.bits;
+  let s = 0, f = 0, d = 0, c = 0, h = 0, _ = 0, g = 0, k = 0, y = 0, E = 0, C, p, $, S, b, w = null, m;
+  const v = new Uint16Array(pe + 1), T = new Uint16Array(pe + 1);
+  let ae = null, Qt, je, Ge;
+  for (s = 0; s <= pe; s++)
+    v[s] = 0;
+  for (f = 0; f < i; f++)
+    v[n[t + f]]++;
+  for (h = u, c = pe; c >= 1 && v[c] === 0; c--)
+    ;
+  if (h > c && (h = c), c === 0)
+    return r[a++] = 1 << 24 | 64 << 16 | 0, r[a++] = 1 << 24 | 64 << 16 | 0, l.bits = 1, 0;
+  for (d = 1; d < c && v[d] === 0; d++)
+    ;
+  for (h < d && (h = d), k = 1, s = 1; s <= pe; s++)
+    if (k <<= 1, k -= v[s], k < 0)
+      return -1;
+  if (k > 0 && (e === dn || c !== 1))
+    return -1;
+  for (T[1] = 0, s = 1; s < pe; s++)
+    T[s + 1] = T[s] + v[s];
+  for (f = 0; f < i; f++)
+    n[t + f] !== 0 && (o[T[n[t + f]]++] = f);
+  if (e === dn ? (w = ae = o, m = 20) : e === mt ? (w = ja, ae = Ga, m = 257) : (w = Ya, ae = Ka, m = 0), E = 0, f = 0, s = d, b = a, _ = h, g = 0, $ = -1, y = 1 << h, S = y - 1, e === mt && y > hn || e === pn && y > cn)
+    return 1;
+  for (; ; ) {
+    Qt = s - g, o[f] + 1 < m ? (je = 0, Ge = o[f]) : o[f] >= m ? (je = ae[o[f] - m], Ge = w[o[f] - m]) : (je = 32 + 64, Ge = 0), C = 1 << s - g, p = 1 << _, d = p;
+    do
+      p -= C, r[b + (E >> g) + p] = Qt << 24 | je << 16 | Ge | 0;
+    while (p !== 0);
+    for (C = 1 << s - 1; E & C; )
+      C >>= 1;
+    if (C !== 0 ? (E &= C - 1, E += C) : E = 0, f++, --v[s] === 0) {
+      if (s === c)
+        break;
+      s = n[t + o[f]];
+    }
+    if (s > h && (E & S) !== $) {
+      for (g === 0 && (g = h), b += d, _ = s - g, k = 1 << _; _ + g < c && (k -= v[_ + g], !(k <= 0)); )
+        _++, k <<= 1;
+      if (y += 1 << _, e === mt && y > hn || e === pn && y > cn)
+        return 1;
+      $ = E & S, r[$] = h << 24 | _ << 16 | b - a | 0;
+    }
+  }
+  return E !== 0 && (r[b + E] = s - g << 24 | 64 << 16 | 0), l.bits = h, 0;
+};
+var Ae = Wa;
+const Xa = 0, wi = 1, mi = 2, {
+  Z_FINISH: _n,
+  Z_BLOCK: qa,
+  Z_TREES: qe,
+  Z_OK: he,
+  Z_STREAM_END: Ja,
+  Z_NEED_DICT: Qa,
+  Z_STREAM_ERROR: P,
+  Z_DATA_ERROR: yi,
+  Z_MEM_ERROR: vi,
+  Z_BUF_ERROR: eo,
+  Z_DEFLATED: bn
+} = xe, ct = 16180, gn = 16181, wn = 16182, mn = 16183, yn = 16184, vn = 16185, kn = 16186, $n = 16187, En = 16188, Cn = 16189, at = 16190, K = 16191, yt = 16192, Sn = 16193, vt = 16194, Nn = 16195, Tn = 16196, In = 16197, An = 16198, Je = 16199, Qe = 16200, On = 16201, zn = 16202, Rn = 16203, Bn = 16204, Un = 16205, kt = 16206, Dn = 16207, Vn = 16208, O = 16209, ki = 16210, $i = 16211, to = 852, no = 592, io = 15, ro = io, Ln = (e) => (e >>> 24 & 255) + (e >>> 8 & 65280) + ((e & 65280) << 8) + ((e & 255) << 24);
+function ao() {
+  this.strm = null, this.mode = 0, this.last = !1, this.wrap = 0, this.havedict = !1, this.flags = 0, this.dmax = 0, this.check = 0, this.total = 0, this.head = null, this.wbits = 0, this.wsize = 0, this.whave = 0, this.wnext = 0, this.window = null, this.hold = 0, this.bits = 0, this.length = 0, this.offset = 0, this.extra = 0, this.lencode = null, this.distcode = null, this.lenbits = 0, this.distbits = 0, this.ncode = 0, this.nlen = 0, this.ndist = 0, this.have = 0, this.next = null, this.lens = new Uint16Array(320), this.work = new Uint16Array(288), this.lendyn = null, this.distdyn = null, this.sane = 0, this.back = 0, this.was = 0;
+}
+const ce = (e) => {
+  if (!e)
+    return 1;
+  const n = e.state;
+  return !n || n.strm !== e || n.mode < ct || n.mode > $i ? 1 : 0;
+}, Ei = (e) => {
+  if (ce(e))
+    return P;
+  const n = e.state;
+  return e.total_in = e.total_out = n.total = 0, e.msg = "", n.wrap && (e.adler = n.wrap & 1), n.mode = ct, n.last = 0, n.havedict = 0, n.flags = -1, n.dmax = 32768, n.head = null, n.hold = 0, n.bits = 0, n.lencode = n.lendyn = new Int32Array(to), n.distcode = n.distdyn = new Int32Array(no), n.sane = 1, n.back = -1, he;
+}, Ci = (e) => {
+  if (ce(e))
+    return P;
+  const n = e.state;
+  return n.wsize = 0, n.whave = 0, n.wnext = 0, Ei(e);
+}, Si = (e, n) => {
+  let t;
+  if (ce(e))
+    return P;
+  const i = e.state;
+  return n < 0 ? (t = 0, n = -n) : (t = (n >> 4) + 5, n < 48 && (n &= 15)), n && (n < 8 || n > 15) ? P : (i.window !== null && i.wbits !== n && (i.window = null), i.wrap = t, i.wbits = n, Ci(e));
+}, Ni = (e, n) => {
+  if (!e)
+    return P;
+  const t = new ao();
+  e.state = t, t.strm = e, t.window = null, t.mode = ct;
+  const i = Si(e, n);
+  return i !== he && (e.state = null), i;
+}, oo = (e) => Ni(e, ro);
+let Fn = !0, $t, Et;
+const so = (e) => {
+  if (Fn) {
+    $t = new Int32Array(512), Et = new Int32Array(32);
+    let n = 0;
+    for (; n < 144; )
+      e.lens[n++] = 8;
+    for (; n < 256; )
+      e.lens[n++] = 9;
+    for (; n < 280; )
+      e.lens[n++] = 7;
+    for (; n < 288; )
+      e.lens[n++] = 8;
+    for (Ae(wi, e.lens, 0, 288, $t, 0, e.work, { bits: 9 }), n = 0; n < 32; )
+      e.lens[n++] = 5;
+    Ae(mi, e.lens, 0, 32, Et, 0, e.work, { bits: 5 }), Fn = !1;
+  }
+  e.lencode = $t, e.lenbits = 9, e.distcode = Et, e.distbits = 5;
+}, Ti = (e, n, t, i) => {
+  let r;
+  const a = e.state;
+  return a.window === null && (a.wsize = 1 << a.wbits, a.wnext = 0, a.whave = 0, a.window = new Uint8Array(a.wsize)), i >= a.wsize ? (a.window.set(n.subarray(t - a.wsize, t), 0), a.wnext = 0, a.whave = a.wsize) : (r = a.wsize - a.wnext, r > i && (r = i), a.window.set(n.subarray(t - i, t - i + r), a.wnext), i -= r, i ? (a.window.set(n.subarray(t - i, t), 0), a.wnext = i, a.whave = a.wsize) : (a.wnext += r, a.wnext === a.wsize && (a.wnext = 0), a.whave < a.wsize && (a.whave += r))), 0;
+}, lo = (e, n) => {
+  let t, i, r, a, o, l, u, s, f, d, c, h, _, g, k = 0, y, E, C, p, $, S, b, w;
+  const m = new Uint8Array(4);
+  let v, T;
+  const ae = (
+    /* permutation of code lengths */
+    new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15])
+  );
+  if (ce(e) || !e.output || !e.input && e.avail_in !== 0)
+    return P;
+  t = e.state, t.mode === K && (t.mode = yt), o = e.next_out, r = e.output, u = e.avail_out, a = e.next_in, i = e.input, l = e.avail_in, s = t.hold, f = t.bits, d = l, c = u, w = he;
+  e:
+    for (; ; )
+      switch (t.mode) {
+        case ct:
+          if (t.wrap === 0) {
+            t.mode = yt;
+            break;
+          }
+          for (; f < 16; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          if (t.wrap & 2 && s === 35615) {
+            t.wbits === 0 && (t.wbits = 15), t.check = 0, m[0] = s & 255, m[1] = s >>> 8 & 255, t.check = R(t.check, m, 2, 0), s = 0, f = 0, t.mode = gn;
+            break;
+          }
+          if (t.head && (t.head.done = !1), !(t.wrap & 1) || /* check if zlib header allowed */
+          (((s & 255) << 8) + (s >> 8)) % 31) {
+            e.msg = "incorrect header check", t.mode = O;
+            break;
+          }
+          if ((s & 15) !== bn) {
+            e.msg = "unknown compression method", t.mode = O;
+            break;
+          }
+          if (s >>>= 4, f -= 4, b = (s & 15) + 8, t.wbits === 0 && (t.wbits = b), b > 15 || b > t.wbits) {
+            e.msg = "invalid window size", t.mode = O;
+            break;
+          }
+          t.dmax = 1 << t.wbits, t.flags = 0, e.adler = t.check = 1, t.mode = s & 512 ? Cn : K, s = 0, f = 0;
+          break;
+        case gn:
+          for (; f < 16; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          if (t.flags = s, (t.flags & 255) !== bn) {
+            e.msg = "unknown compression method", t.mode = O;
+            break;
+          }
+          if (t.flags & 57344) {
+            e.msg = "unknown header flags set", t.mode = O;
+            break;
+          }
+          t.head && (t.head.text = s >> 8 & 1), t.flags & 512 && t.wrap & 4 && (m[0] = s & 255, m[1] = s >>> 8 & 255, t.check = R(t.check, m, 2, 0)), s = 0, f = 0, t.mode = wn;
+        case wn:
+          for (; f < 32; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          t.head && (t.head.time = s), t.flags & 512 && t.wrap & 4 && (m[0] = s & 255, m[1] = s >>> 8 & 255, m[2] = s >>> 16 & 255, m[3] = s >>> 24 & 255, t.check = R(t.check, m, 4, 0)), s = 0, f = 0, t.mode = mn;
+        case mn:
+          for (; f < 16; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          t.head && (t.head.xflags = s & 255, t.head.os = s >> 8), t.flags & 512 && t.wrap & 4 && (m[0] = s & 255, m[1] = s >>> 8 & 255, t.check = R(t.check, m, 2, 0)), s = 0, f = 0, t.mode = yn;
+        case yn:
+          if (t.flags & 1024) {
+            for (; f < 16; ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            t.length = s, t.head && (t.head.extra_len = s), t.flags & 512 && t.wrap & 4 && (m[0] = s & 255, m[1] = s >>> 8 & 255, t.check = R(t.check, m, 2, 0)), s = 0, f = 0;
+          } else
+            t.head && (t.head.extra = null);
+          t.mode = vn;
+        case vn:
+          if (t.flags & 1024 && (h = t.length, h > l && (h = l), h && (t.head && (b = t.head.extra_len - t.length, t.head.extra || (t.head.extra = new Uint8Array(t.head.extra_len)), t.head.extra.set(
+            i.subarray(
+              a,
+              // extra field is limited to 65536 bytes
+              // - no need for additional size check
+              a + h
+            ),
+            /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
+            b
+          )), t.flags & 512 && t.wrap & 4 && (t.check = R(t.check, i, h, a)), l -= h, a += h, t.length -= h), t.length))
+            break e;
+          t.length = 0, t.mode = kn;
+        case kn:
+          if (t.flags & 2048) {
+            if (l === 0)
+              break e;
+            h = 0;
+            do
+              b = i[a + h++], t.head && b && t.length < 65536 && (t.head.name += String.fromCharCode(b));
+            while (b && h < l);
+            if (t.flags & 512 && t.wrap & 4 && (t.check = R(t.check, i, h, a)), l -= h, a += h, b)
+              break e;
+          } else
+            t.head && (t.head.name = null);
+          t.length = 0, t.mode = $n;
+        case $n:
+          if (t.flags & 4096) {
+            if (l === 0)
+              break e;
+            h = 0;
+            do
+              b = i[a + h++], t.head && b && t.length < 65536 && (t.head.comment += String.fromCharCode(b));
+            while (b && h < l);
+            if (t.flags & 512 && t.wrap & 4 && (t.check = R(t.check, i, h, a)), l -= h, a += h, b)
+              break e;
+          } else
+            t.head && (t.head.comment = null);
+          t.mode = En;
+        case En:
+          if (t.flags & 512) {
+            for (; f < 16; ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            if (t.wrap & 4 && s !== (t.check & 65535)) {
+              e.msg = "header crc mismatch", t.mode = O;
+              break;
+            }
+            s = 0, f = 0;
+          }
+          t.head && (t.head.hcrc = t.flags >> 9 & 1, t.head.done = !0), e.adler = t.check = 0, t.mode = K;
+          break;
+        case Cn:
+          for (; f < 32; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          e.adler = t.check = Ln(s), s = 0, f = 0, t.mode = at;
+        case at:
+          if (t.havedict === 0)
+            return e.next_out = o, e.avail_out = u, e.next_in = a, e.avail_in = l, t.hold = s, t.bits = f, Qa;
+          e.adler = t.check = 1, t.mode = K;
+        case K:
+          if (n === qa || n === qe)
+            break e;
+        case yt:
+          if (t.last) {
+            s >>>= f & 7, f -= f & 7, t.mode = kt;
+            break;
+          }
+          for (; f < 3; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          switch (t.last = s & 1, s >>>= 1, f -= 1, s & 3) {
+            case 0:
+              t.mode = Sn;
+              break;
+            case 1:
+              if (so(t), t.mode = Je, n === qe) {
+                s >>>= 2, f -= 2;
+                break e;
+              }
+              break;
+            case 2:
+              t.mode = Tn;
+              break;
+            case 3:
+              e.msg = "invalid block type", t.mode = O;
+          }
+          s >>>= 2, f -= 2;
+          break;
+        case Sn:
+          for (s >>>= f & 7, f -= f & 7; f < 32; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          if ((s & 65535) !== (s >>> 16 ^ 65535)) {
+            e.msg = "invalid stored block lengths", t.mode = O;
+            break;
+          }
+          if (t.length = s & 65535, s = 0, f = 0, t.mode = vt, n === qe)
+            break e;
+        case vt:
+          t.mode = Nn;
+        case Nn:
+          if (h = t.length, h) {
+            if (h > l && (h = l), h > u && (h = u), h === 0)
+              break e;
+            r.set(i.subarray(a, a + h), o), l -= h, a += h, u -= h, o += h, t.length -= h;
+            break;
+          }
+          t.mode = K;
+          break;
+        case Tn:
+          for (; f < 14; ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          if (t.nlen = (s & 31) + 257, s >>>= 5, f -= 5, t.ndist = (s & 31) + 1, s >>>= 5, f -= 5, t.ncode = (s & 15) + 4, s >>>= 4, f -= 4, t.nlen > 286 || t.ndist > 30) {
+            e.msg = "too many length or distance symbols", t.mode = O;
+            break;
+          }
+          t.have = 0, t.mode = In;
+        case In:
+          for (; t.have < t.ncode; ) {
+            for (; f < 3; ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            t.lens[ae[t.have++]] = s & 7, s >>>= 3, f -= 3;
+          }
+          for (; t.have < 19; )
+            t.lens[ae[t.have++]] = 0;
+          if (t.lencode = t.lendyn, t.lenbits = 7, v = { bits: t.lenbits }, w = Ae(Xa, t.lens, 0, 19, t.lencode, 0, t.work, v), t.lenbits = v.bits, w) {
+            e.msg = "invalid code lengths set", t.mode = O;
+            break;
+          }
+          t.have = 0, t.mode = An;
+        case An:
+          for (; t.have < t.nlen + t.ndist; ) {
+            for (; k = t.lencode[s & (1 << t.lenbits) - 1], y = k >>> 24, E = k >>> 16 & 255, C = k & 65535, !(y <= f); ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            if (C < 16)
+              s >>>= y, f -= y, t.lens[t.have++] = C;
+            else {
+              if (C === 16) {
+                for (T = y + 2; f < T; ) {
+                  if (l === 0)
+                    break e;
+                  l--, s += i[a++] << f, f += 8;
+                }
+                if (s >>>= y, f -= y, t.have === 0) {
+                  e.msg = "invalid bit length repeat", t.mode = O;
+                  break;
+                }
+                b = t.lens[t.have - 1], h = 3 + (s & 3), s >>>= 2, f -= 2;
+              } else if (C === 17) {
+                for (T = y + 3; f < T; ) {
+                  if (l === 0)
+                    break e;
+                  l--, s += i[a++] << f, f += 8;
+                }
+                s >>>= y, f -= y, b = 0, h = 3 + (s & 7), s >>>= 3, f -= 3;
+              } else {
+                for (T = y + 7; f < T; ) {
+                  if (l === 0)
+                    break e;
+                  l--, s += i[a++] << f, f += 8;
+                }
+                s >>>= y, f -= y, b = 0, h = 11 + (s & 127), s >>>= 7, f -= 7;
+              }
+              if (t.have + h > t.nlen + t.ndist) {
+                e.msg = "invalid bit length repeat", t.mode = O;
+                break;
+              }
+              for (; h--; )
+                t.lens[t.have++] = b;
+            }
+          }
+          if (t.mode === O)
+            break;
+          if (t.lens[256] === 0) {
+            e.msg = "invalid code -- missing end-of-block", t.mode = O;
+            break;
+          }
+          if (t.lenbits = 9, v = { bits: t.lenbits }, w = Ae(wi, t.lens, 0, t.nlen, t.lencode, 0, t.work, v), t.lenbits = v.bits, w) {
+            e.msg = "invalid literal/lengths set", t.mode = O;
+            break;
+          }
+          if (t.distbits = 6, t.distcode = t.distdyn, v = { bits: t.distbits }, w = Ae(mi, t.lens, t.nlen, t.ndist, t.distcode, 0, t.work, v), t.distbits = v.bits, w) {
+            e.msg = "invalid distances set", t.mode = O;
+            break;
+          }
+          if (t.mode = Je, n === qe)
+            break e;
+        case Je:
+          t.mode = Qe;
+        case Qe:
+          if (l >= 6 && u >= 258) {
+            e.next_out = o, e.avail_out = u, e.next_in = a, e.avail_in = l, t.hold = s, t.bits = f, Ha(e, c), o = e.next_out, r = e.output, u = e.avail_out, a = e.next_in, i = e.input, l = e.avail_in, s = t.hold, f = t.bits, t.mode === K && (t.back = -1);
+            break;
+          }
+          for (t.back = 0; k = t.lencode[s & (1 << t.lenbits) - 1], y = k >>> 24, E = k >>> 16 & 255, C = k & 65535, !(y <= f); ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          if (E && !(E & 240)) {
+            for (p = y, $ = E, S = C; k = t.lencode[S + ((s & (1 << p + $) - 1) >> p)], y = k >>> 24, E = k >>> 16 & 255, C = k & 65535, !(p + y <= f); ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            s >>>= p, f -= p, t.back += p;
+          }
+          if (s >>>= y, f -= y, t.back += y, t.length = C, E === 0) {
+            t.mode = Un;
+            break;
+          }
+          if (E & 32) {
+            t.back = -1, t.mode = K;
+            break;
+          }
+          if (E & 64) {
+            e.msg = "invalid literal/length code", t.mode = O;
+            break;
+          }
+          t.extra = E & 15, t.mode = On;
+        case On:
+          if (t.extra) {
+            for (T = t.extra; f < T; ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            t.length += s & (1 << t.extra) - 1, s >>>= t.extra, f -= t.extra, t.back += t.extra;
+          }
+          t.was = t.length, t.mode = zn;
+        case zn:
+          for (; k = t.distcode[s & (1 << t.distbits) - 1], y = k >>> 24, E = k >>> 16 & 255, C = k & 65535, !(y <= f); ) {
+            if (l === 0)
+              break e;
+            l--, s += i[a++] << f, f += 8;
+          }
+          if (!(E & 240)) {
+            for (p = y, $ = E, S = C; k = t.distcode[S + ((s & (1 << p + $) - 1) >> p)], y = k >>> 24, E = k >>> 16 & 255, C = k & 65535, !(p + y <= f); ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            s >>>= p, f -= p, t.back += p;
+          }
+          if (s >>>= y, f -= y, t.back += y, E & 64) {
+            e.msg = "invalid distance code", t.mode = O;
+            break;
+          }
+          t.offset = C, t.extra = E & 15, t.mode = Rn;
+        case Rn:
+          if (t.extra) {
+            for (T = t.extra; f < T; ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            t.offset += s & (1 << t.extra) - 1, s >>>= t.extra, f -= t.extra, t.back += t.extra;
+          }
+          if (t.offset > t.dmax) {
+            e.msg = "invalid distance too far back", t.mode = O;
+            break;
+          }
+          t.mode = Bn;
+        case Bn:
+          if (u === 0)
+            break e;
+          if (h = c - u, t.offset > h) {
+            if (h = t.offset - h, h > t.whave && t.sane) {
+              e.msg = "invalid distance too far back", t.mode = O;
+              break;
+            }
+            h > t.wnext ? (h -= t.wnext, _ = t.wsize - h) : _ = t.wnext - h, h > t.length && (h = t.length), g = t.window;
+          } else
+            g = r, _ = o - t.offset, h = t.length;
+          h > u && (h = u), u -= h, t.length -= h;
+          do
+            r[o++] = g[_++];
+          while (--h);
+          t.length === 0 && (t.mode = Qe);
+          break;
+        case Un:
+          if (u === 0)
+            break e;
+          r[o++] = t.length, u--, t.mode = Qe;
+          break;
+        case kt:
+          if (t.wrap) {
+            for (; f < 32; ) {
+              if (l === 0)
+                break e;
+              l--, s |= i[a++] << f, f += 8;
+            }
+            if (c -= u, e.total_out += c, t.total += c, t.wrap & 4 && c && (e.adler = t.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/
+            t.flags ? R(t.check, r, c, o - c) : Ue(t.check, r, c, o - c)), c = u, t.wrap & 4 && (t.flags ? s : Ln(s)) !== t.check) {
+              e.msg = "incorrect data check", t.mode = O;
+              break;
+            }
+            s = 0, f = 0;
+          }
+          t.mode = Dn;
+        case Dn:
+          if (t.wrap && t.flags) {
+            for (; f < 32; ) {
+              if (l === 0)
+                break e;
+              l--, s += i[a++] << f, f += 8;
+            }
+            if (t.wrap & 4 && s !== (t.total & 4294967295)) {
+              e.msg = "incorrect length check", t.mode = O;
+              break;
+            }
+            s = 0, f = 0;
+          }
+          t.mode = Vn;
+        case Vn:
+          w = Ja;
+          break e;
+        case O:
+          w = yi;
+          break e;
+        case ki:
+          return vi;
+        case $i:
+        default:
+          return P;
+      }
+  return e.next_out = o, e.avail_out = u, e.next_in = a, e.avail_in = l, t.hold = s, t.bits = f, (t.wsize || c !== e.avail_out && t.mode < O && (t.mode < kt || n !== _n)) && Ti(e, e.output, e.next_out, c - e.avail_out), d -= e.avail_in, c -= e.avail_out, e.total_in += d, e.total_out += c, t.total += c, t.wrap & 4 && c && (e.adler = t.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
+  t.flags ? R(t.check, r, c, e.next_out - c) : Ue(t.check, r, c, e.next_out - c)), e.data_type = t.bits + (t.last ? 64 : 0) + (t.mode === K ? 128 : 0) + (t.mode === Je || t.mode === vt ? 256 : 0), (d === 0 && c === 0 || n === _n) && w === he && (w = eo), w;
+}, fo = (e) => {
+  if (ce(e))
+    return P;
+  let n = e.state;
+  return n.window && (n.window = null), e.state = null, he;
+}, uo = (e, n) => {
+  if (ce(e))
+    return P;
+  const t = e.state;
+  return t.wrap & 2 ? (t.head = n, n.done = !1, he) : P;
+}, ho = (e, n) => {
+  const t = n.length;
+  let i, r, a;
+  return ce(e) || (i = e.state, i.wrap !== 0 && i.mode !== at) ? P : i.mode === at && (r = 1, r = Ue(r, n, t, 0), r !== i.check) ? yi : (a = Ti(e, n, t, t), a ? (i.mode = ki, vi) : (i.havedict = 1, he));
+};
+var co = Ci, po = Si, _o = Ei, bo = oo, go = Ni, wo = lo, mo = fo, yo = uo, vo = ho, ko = "pako inflate (from Nodeca project)", X = {
+  inflateReset: co,
+  inflateReset2: po,
+  inflateResetKeep: _o,
+  inflateInit: bo,
+  inflateInit2: go,
+  inflate: wo,
+  inflateEnd: mo,
+  inflateGetHeader: yo,
+  inflateSetDictionary: vo,
+  inflateInfo: ko
+};
+function $o() {
+  this.text = 0, this.time = 0, this.xflags = 0, this.os = 0, this.extra = null, this.extra_len = 0, this.name = "", this.comment = "", this.hcrc = 0, this.done = !1;
+}
+var Eo = $o;
+const Ii = Object.prototype.toString, {
+  Z_NO_FLUSH: Co,
+  Z_FINISH: So,
+  Z_OK: Le,
+  Z_STREAM_END: Ct,
+  Z_NEED_DICT: St,
+  Z_STREAM_ERROR: No,
+  Z_DATA_ERROR: Pn,
+  Z_MEM_ERROR: To
+} = xe;
+function He(e) {
+  this.options = ht.assign({
+    chunkSize: 1024 * 64,
+    windowBits: 15,
+    to: ""
+  }, e || {});
+  const n = this.options;
+  n.raw && n.windowBits >= 0 && n.windowBits < 16 && (n.windowBits = -n.windowBits, n.windowBits === 0 && (n.windowBits = -15)), n.windowBits >= 0 && n.windowBits < 16 && !(e && e.windowBits) && (n.windowBits += 32), n.windowBits > 15 && n.windowBits < 48 && (n.windowBits & 15 || (n.windowBits |= 15)), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new bi(), this.strm.avail_out = 0;
+  let t = X.inflateInit2(
+    this.strm,
+    n.windowBits
+  );
+  if (t !== Le)
+    throw new Error(ge[t]);
+  if (this.header = new Eo(), X.inflateGetHeader(this.strm, this.header), n.dictionary && (typeof n.dictionary == "string" ? n.dictionary = Ve.string2buf(n.dictionary) : Ii.call(n.dictionary) === "[object ArrayBuffer]" && (n.dictionary = new Uint8Array(n.dictionary)), n.raw && (t = X.inflateSetDictionary(this.strm, n.dictionary), t !== Le)))
+    throw new Error(ge[t]);
+}
+He.prototype.push = function(e, n) {
+  const t = this.strm, i = this.options.chunkSize, r = this.options.dictionary;
+  let a, o, l;
+  if (this.ended)
+    return !1;
+  for (n === ~~n ? o = n : o = n === !0 ? So : Co, Ii.call(e) === "[object ArrayBuffer]" ? t.input = new Uint8Array(e) : t.input = e, t.next_in = 0, t.avail_in = t.input.length; ; ) {
+    for (t.avail_out === 0 && (t.output = new Uint8Array(i), t.next_out = 0, t.avail_out = i), a = X.inflate(t, o), a === St && r && (a = X.inflateSetDictionary(t, r), a === Le ? a = X.inflate(t, o) : a === Pn && (a = St)); t.avail_in > 0 && a === Ct && t.state.wrap > 0 && e[t.next_in] !== 0; )
+      X.inflateReset(t), a = X.inflate(t, o);
+    switch (a) {
+      case No:
+      case Pn:
+      case St:
+      case To:
+        return this.onEnd(a), this.ended = !0, !1;
+    }
+    if (l = t.avail_out, t.next_out && (t.avail_out === 0 || a === Ct))
+      if (this.options.to === "string") {
+        let u = Ve.utf8border(t.output, t.next_out), s = t.next_out - u, f = Ve.buf2string(t.output, u);
+        t.next_out = s, t.avail_out = i - s, s && t.output.set(t.output.subarray(u, u + s), 0), this.onData(f);
+      } else
+        this.onData(t.output.length === t.next_out ? t.output : t.output.subarray(0, t.next_out));
+    if (!(a === Le && l === 0)) {
+      if (a === Ct)
+        return a = X.inflateEnd(this.strm), this.onEnd(a), this.ended = !0, !0;
+      if (t.avail_in === 0)
+        break;
+    }
+  }
+  return !0;
+};
+He.prototype.onData = function(e) {
+  this.chunks.push(e);
+};
+He.prototype.onEnd = function(e) {
+  e === Le && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = ht.flattenChunks(this.chunks)), this.chunks = [], this.err = e, this.msg = this.strm.msg;
+};
+function Kt(e, n) {
+  const t = new He(n);
+  if (t.push(e), t.err)
+    throw t.msg || ge[t.err];
+  return t.result;
+}
+function Io(e, n) {
+  return n = n || {}, n.raw = !0, Kt(e, n);
+}
+var Ao = He, Oo = Kt, zo = Io, Ro = Kt, Bo = xe, Uo = {
+  Inflate: Ao,
+  inflate: Oo,
+  inflateRaw: zo,
+  ungzip: Ro,
+  constants: Bo
+};
+const { Inflate: Ds, inflate: Vs, inflateRaw: Do, ungzip: Ls } = Uo;
+var Vo = Do;
+function Lo(e) {
+  return Vo(e.subarray(2));
+}
+class Fo extends Error {
+  constructor(n) {
+    super(n), this.code = "ERR_ABORTED";
+  }
+}
+function Po(e) {
+  e.sort((r, a) => Number(r.offset) - Number(a.offset));
+  const n = [];
+  let t, i;
+  for (const r of e)
+    t && i && Number(r.offset) - i <= 2e3 ? (t.length = BigInt(Number(t.length) + Number(r.length) - i + Number(r.offset)), t.blocks.push(r)) : n.push(t = {
+      blocks: [r],
+      length: r.length,
+      offset: r.offset
+    }), i = Number(t.offset) + Number(t.length);
+  return n;
+}
+function et(e) {
+  if (e && e.aborted)
+    if (typeof DOMException > "u") {
+      const n = new Fo("aborted");
+      throw n.code = "ERR_ABORTED", n;
+    } else
+      throw new DOMException("aborted", "AbortError");
+}
+const Zo = 1, xo = 2, Mo = 3;
+function Nt(e, n, t, i) {
+  return e < i && n >= t;
+}
+function Ho(e) {
+  const n = e ? "big" : "little", t = new N().endianess(n).uint32("chromId").uint32("start").uint32("end").uint32("validCnt").floatle("minScore").floatle("maxScore").floatle("sumData").floatle("sumSqData").saveOffset("offset"), i = new N().endianess(n).uint8("isLeaf").skip(1).uint16("cnt").choice({
+    tag: "isLeaf",
+    choices: {
+      1: new N().endianess(n).array("blocksToFetch", {
+        length: "cnt",
+        type: new N().endianess(n).uint32("startChrom").uint32("startBase").uint32("endChrom").uint32("endBase").uint64("blockOffset").uint64("blockSize").saveOffset("offset")
+      }),
+      0: new N().array("recurOffsets", {
+        length: "cnt",
+        type: new N().endianess(n).uint32("startChrom").uint32("startBase").uint32("endChrom").uint32("endBase").uint64("blockOffset").saveOffset("offset")
+      })
+    }
+  }), r = new N().endianess(n).uint32("chromId").int32("start").int32("end").string("rest", {
+    zeroTerminated: !0
+  }).saveOffset("offset");
+  return {
+    bigWigParser: new N().endianess(n).skip(4).int32("blockStart").skip(4).uint32("itemStep").uint32("itemSpan").uint8("blockType").skip(1).uint16("itemCount").choice({
+      tag: "blockType",
+      choices: {
+        [Mo]: new N().array("items", {
+          length: "itemCount",
+          type: new N().floatle("score")
+        }),
+        [xo]: new N().array("items", {
+          length: "itemCount",
+          type: new N().endianess(n).int32("start").floatle("score")
+        }),
+        [Zo]: new N().array("items", {
+          length: "itemCount",
+          type: new N().endianess(n).int32("start").int32("end").floatle("score")
+        })
+      }
+    }),
+    bigBedParser: r,
+    summaryParser: t,
+    leafParser: i
+  };
+}
+class Ai {
+  constructor(n, t, i, r, a, o) {
+    if (this.bbi = n, this.refsByName = t, this.cirTreeOffset = i, this.isBigEndian = r, this.isCompressed = a, this.blockType = o, this.featureCache = new Yn({
+      cache: new Kn({ maxSize: 1e3 }),
+      fill: async (u, s) => {
+        const f = Number(u.length), d = Number(u.offset), { buffer: c } = await this.bbi.read(Q.Buffer.alloc(f), 0, f, d, {
+          signal: s
+        });
+        return c;
+      }
+    }), !(i >= 0))
+      throw new Error("invalid cirTreeOffset!");
+    const l = Ho(r);
+    this.leafParser = l.leafParser, this.bigBedParser = l.bigBedParser;
+  }
+  async readWigData(n, t, i, r, a) {
+    try {
+      const { refsByName: o, bbi: l, cirTreeOffset: u, isBigEndian: s } = this, f = o[n];
+      f === void 0 && r.complete();
+      const d = { chrId: f, start: t, end: i };
+      this.cirTreePromise || (this.cirTreePromise = l.read(Q.Buffer.alloc(48), 0, 48, Number(u), a));
+      const { buffer: c } = await this.cirTreePromise, h = s ? c.readUInt32BE(4) : c.readUInt32LE(4);
+      let _ = [], g = 0;
+      const k = (p, $, S) => {
+        try {
+          const b = p.subarray($), w = this.leafParser.parse(b);
+          if (w.blocksToFetch && (_ = _.concat(w.blocksToFetch.filter((m) => y(m)).map((m) => ({
+            offset: m.blockOffset,
+            length: m.blockSize
+          })))), w.recurOffsets) {
+            const m = w.recurOffsets.filter((v) => y(v)).map((v) => Number(v.blockOffset));
+            m.length > 0 && C(m, S + 1);
+          }
+        } catch (b) {
+          r.error(b);
+        }
+      }, y = (p) => {
+        const { startChrom: $, startBase: S, endChrom: b, endBase: w } = p;
+        return ($ < f || $ === f && S <= i) && (b > f || b === f && w >= t);
+      }, E = async (p, $, S) => {
+        try {
+          const b = $.max() - $.min(), w = $.min(), m = await this.featureCache.get(`${b}_${w}`, { length: b, offset: w }, a == null ? void 0 : a.signal);
+          for (const v of p)
+            $.contains(v) && (k(m, v - w, S), g -= 1, g === 0 && this.readFeatures(r, _, { ...a, request: d }));
+        } catch (b) {
+          r.error(b);
+        }
+      }, C = (p, $) => {
+        try {
+          g += p.length;
+          const S = 4 + Number(h) * 32;
+          let b = new q(p[0], p[0] + S);
+          for (let w = 1; w < p.length; w += 1) {
+            const m = new q(p[w], p[w] + S);
+            b = b.union(m);
+          }
+          b.getRanges().map((w) => E(p, w, $));
+        } catch (S) {
+          r.error(S);
+        }
+      };
+      return C([Number(u) + 48], 1);
+    } catch (o) {
+      r.error(o);
+    }
+  }
+  parseSummaryBlock(n, t, i) {
+    const r = [];
+    let a = t;
+    const o = new DataView(n.buffer, n.byteOffset, n.length);
+    for (; a < n.byteLength; ) {
+      const l = o.getUint32(a, !0);
+      a += 4;
+      const u = o.getUint32(a, !0);
+      a += 4;
+      const s = o.getUint32(a, !0);
+      a += 4;
+      const f = o.getUint32(a, !0);
+      a += 4;
+      const d = o.getFloat32(a, !0);
+      a += 4;
+      const c = o.getFloat32(a, !0);
+      a += 4;
+      const h = o.getFloat32(a, !0);
+      a += 4, a += 4, (!i || l === i.chrId && Nt(u, s, i.start, i.end)) && r.push({
+        start: u,
+        end: s,
+        maxScore: c,
+        minScore: d,
+        summary: !0,
+        score: h / (f || 1)
+      });
+    }
+    return r;
+  }
+  parseBigBedBlock(n, t, i, r) {
+    const a = [];
+    let o = t;
+    for (; o < n.byteLength; ) {
+      const l = this.bigBedParser.parse(n.subarray(o));
+      a.push({ ...l, uniqueId: `bb-${i + o}` }), o += l.offset;
+    }
+    return r ? a.filter((l) => Nt(l.start, l.end, r.start, r.end)) : a;
+  }
+  parseBigWigBlock(n, t, i) {
+    const r = n.subarray(t), a = new DataView(r.buffer, r.byteOffset, r.length);
+    let o = 0;
+    o += 4;
+    const l = a.getInt32(o, !0);
+    o += 8;
+    const u = a.getUint32(o, !0);
+    o += 4;
+    const s = a.getUint32(o, !0);
+    o += 4;
+    const f = a.getUint8(o);
+    o += 2;
+    const d = a.getUint16(o, !0);
+    o += 2;
+    const c = new Array(d);
+    switch (f) {
+      case 1: {
+        for (let h = 0; h < d; h++) {
+          const _ = a.getInt32(o, !0);
+          o += 4;
+          const g = a.getInt32(o, !0);
+          o += 4;
+          const k = a.getFloat32(o, !0);
+          o += 4, c[h] = { start: _, end: g, score: k };
+        }
+        break;
+      }
+      case 2: {
+        for (let h = 0; h < d; h++) {
+          const _ = a.getInt32(o, !0);
+          o += 4;
+          const g = a.getFloat32(o, !0);
+          o += 4, c[h] = { score: g, start: _, end: _ + s };
+        }
+        break;
+      }
+      case 3: {
+        for (let h = 0; h < d; h++) {
+          const _ = a.getFloat32(o, !0);
+          o += 4;
+          const g = l + h * u;
+          c[h] = { score: _, start: g, end: g + s };
+        }
+        break;
+      }
+    }
+    return i ? c.filter((h) => Nt(h.start, h.end, i.start, i.end)) : c;
+  }
+  async readFeatures(n, t, i = {}) {
+    try {
+      const { blockType: r, isCompressed: a } = this, { signal: o, request: l } = i, u = Po(t);
+      et(o), await Promise.all(u.map(async (s) => {
+        et(o);
+        const { length: f, offset: d } = s, c = await this.featureCache.get(`${f}_${d}`, s, o);
+        for (const h of s.blocks) {
+          et(o);
+          let _ = Number(h.offset) - Number(s.offset), g = c;
+          switch (a && (g = Lo(c.subarray(_)), _ = 0), et(o), r) {
+            case "summary": {
+              n.next(this.parseSummaryBlock(g, _, l));
+              break;
+            }
+            case "bigwig": {
+              n.next(this.parseBigWigBlock(g, _, l));
+              break;
+            }
+            case "bigbed": {
+              n.next(this.parseBigBedBlock(g, _, Number(h.offset) * 256, l));
+              break;
+            }
+            default:
+              console.warn(`Don't know what to do with ${r}`);
+          }
+        }
+      })), n.complete();
+    } catch (r) {
+      n.error(r);
+    }
+  }
+}
+var Pt = function(e, n) {
+  return Pt = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(t, i) {
+    t.__proto__ = i;
+  } || function(t, i) {
+    for (var r in i)
+      Object.prototype.hasOwnProperty.call(i, r) && (t[r] = i[r]);
+  }, Pt(e, n);
+};
+function Wt(e, n) {
+  if (typeof n != "function" && n !== null)
+    throw new TypeError("Class extends value " + String(n) + " is not a constructor or null");
+  Pt(e, n);
+  function t() {
+    this.constructor = e;
+  }
+  e.prototype = n === null ? Object.create(n) : (t.prototype = n.prototype, new t());
+}
+function jo(e, n, t, i) {
+  function r(a) {
+    return a instanceof t ? a : new t(function(o) {
+      o(a);
+    });
+  }
+  return new (t || (t = Promise))(function(a, o) {
+    function l(f) {
+      try {
+        s(i.next(f));
+      } catch (d) {
+        o(d);
+      }
+    }
+    function u(f) {
+      try {
+        s(i.throw(f));
+      } catch (d) {
+        o(d);
+      }
+    }
+    function s(f) {
+      f.done ? a(f.value) : r(f.value).then(l, u);
+    }
+    s((i = i.apply(e, n || [])).next());
+  });
+}
+function Oi(e, n) {
+  var t = { label: 0, sent: function() {
+    if (a[0] & 1)
+      throw a[1];
+    return a[1];
+  }, trys: [], ops: [] }, i, r, a, o;
+  return o = { next: l(0), throw: l(1), return: l(2) }, typeof Symbol == "function" && (o[Symbol.iterator] = function() {
+    return this;
+  }), o;
+  function l(s) {
+    return function(f) {
+      return u([s, f]);
+    };
+  }
+  function u(s) {
+    if (i)
+      throw new TypeError("Generator is already executing.");
+    for (; o && (o = 0, s[0] && (t = 0)), t; )
+      try {
+        if (i = 1, r && (a = s[0] & 2 ? r.return : s[0] ? r.throw || ((a = r.return) && a.call(r), 0) : r.next) && !(a = a.call(r, s[1])).done)
+          return a;
+        switch (r = 0, a && (s = [s[0] & 2, a.value]), s[0]) {
+          case 0:
+          case 1:
+            a = s;
+            break;
+          case 4:
+            return t.label++, { value: s[1], done: !1 };
+          case 5:
+            t.label++, r = s[1], s = [0];
+            continue;
+          case 7:
+            s = t.ops.pop(), t.trys.pop();
+            continue;
+          default:
+            if (a = t.trys, !(a = a.length > 0 && a[a.length - 1]) && (s[0] === 6 || s[0] === 2)) {
+              t = 0;
+              continue;
+            }
+            if (s[0] === 3 && (!a || s[1] > a[0] && s[1] < a[3])) {
+              t.label = s[1];
+              break;
+            }
+            if (s[0] === 6 && t.label < a[1]) {
+              t.label = a[1], a = s;
+              break;
+            }
+            if (a && t.label < a[2]) {
+              t.label = a[2], t.ops.push(s);
+              break;
+            }
+            a[2] && t.ops.pop(), t.trys.pop();
+            continue;
+        }
+        s = n.call(e, t);
+      } catch (f) {
+        s = [6, f], r = 0;
+      } finally {
+        i = a = 0;
+      }
+    if (s[0] & 5)
+      throw s[1];
+    return { value: s[0] ? s[1] : void 0, done: !0 };
+  }
+}
+function Fe(e) {
+  var n = typeof Symbol == "function" && Symbol.iterator, t = n && e[n], i = 0;
+  if (t)
+    return t.call(e);
+  if (e && typeof e.length == "number")
+    return {
+      next: function() {
+        return e && i >= e.length && (e = void 0), { value: e && e[i++], done: !e };
+      }
+    };
+  throw new TypeError(n ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function ot(e, n) {
+  var t = typeof Symbol == "function" && e[Symbol.iterator];
+  if (!t)
+    return e;
+  var i = t.call(e), r, a = [], o;
+  try {
+    for (; (n === void 0 || n-- > 0) && !(r = i.next()).done; )
+      a.push(r.value);
+  } catch (l) {
+    o = { error: l };
+  } finally {
+    try {
+      r && !r.done && (t = i.return) && t.call(i);
+    } finally {
+      if (o)
+        throw o.error;
+    }
+  }
+  return a;
+}
+function st(e, n, t) {
+  if (t || arguments.length === 2)
+    for (var i = 0, r = n.length, a; i < r; i++)
+      (a || !(i in n)) && (a || (a = Array.prototype.slice.call(n, 0, i)), a[i] = n[i]);
+  return e.concat(a || Array.prototype.slice.call(n));
+}
+function be(e) {
+  return this instanceof be ? (this.v = e, this) : new be(e);
+}
+function Go(e, n, t) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var i = t.apply(e, n || []), r, a = [];
+  return r = {}, o("next"), o("throw"), o("return"), r[Symbol.asyncIterator] = function() {
+    return this;
+  }, r;
+  function o(c) {
+    i[c] && (r[c] = function(h) {
+      return new Promise(function(_, g) {
+        a.push([c, h, _, g]) > 1 || l(c, h);
+      });
+    });
+  }
+  function l(c, h) {
+    try {
+      u(i[c](h));
+    } catch (_) {
+      d(a[0][3], _);
+    }
+  }
+  function u(c) {
+    c.value instanceof be ? Promise.resolve(c.value.v).then(s, f) : d(a[0][2], c);
+  }
+  function s(c) {
+    l("next", c);
+  }
+  function f(c) {
+    l("throw", c);
+  }
+  function d(c, h) {
+    c(h), a.shift(), a.length && l(a[0][0], a[0][1]);
+  }
+}
+function Yo(e) {
+  if (!Symbol.asyncIterator)
+    throw new TypeError("Symbol.asyncIterator is not defined.");
+  var n = e[Symbol.asyncIterator], t;
+  return n ? n.call(e) : (e = typeof Fe == "function" ? Fe(e) : e[Symbol.iterator](), t = {}, i("next"), i("throw"), i("return"), t[Symbol.asyncIterator] = function() {
+    return this;
+  }, t);
+  function i(a) {
+    t[a] = e[a] && function(o) {
+      return new Promise(function(l, u) {
+        o = e[a](o), r(l, u, o.done, o.value);
+      });
+    };
+  }
+  function r(a, o, l, u) {
+    Promise.resolve(u).then(function(s) {
+      a({ value: s, done: l });
+    }, o);
+  }
+}
+function z(e) {
+  return typeof e == "function";
+}
+function zi(e) {
+  var n = function(i) {
+    Error.call(i), i.stack = new Error().stack;
+  }, t = e(n);
+  return t.prototype = Object.create(Error.prototype), t.prototype.constructor = t, t;
+}
+var Tt = zi(function(e) {
+  return function(t) {
+    e(this), this.message = t ? t.length + ` errors occurred during unsubscription:
+` + t.map(function(i, r) {
+      return r + 1 + ") " + i.toString();
+    }).join(`
+  `) : "", this.name = "UnsubscriptionError", this.errors = t;
+  };
+});
+function Zn(e, n) {
+  if (e) {
+    var t = e.indexOf(n);
+    0 <= t && e.splice(t, 1);
+  }
+}
+var Xt = function() {
+  function e(n) {
+    this.initialTeardown = n, this.closed = !1, this._parentage = null, this._finalizers = null;
+  }
+  return e.prototype.unsubscribe = function() {
+    var n, t, i, r, a;
+    if (!this.closed) {
+      this.closed = !0;
+      var o = this._parentage;
+      if (o)
+        if (this._parentage = null, Array.isArray(o))
+          try {
+            for (var l = Fe(o), u = l.next(); !u.done; u = l.next()) {
+              var s = u.value;
+              s.remove(this);
+            }
+          } catch (g) {
+            n = { error: g };
+          } finally {
+            try {
+              u && !u.done && (t = l.return) && t.call(l);
+            } finally {
+              if (n)
+                throw n.error;
+            }
+          }
+        else
+          o.remove(this);
+      var f = this.initialTeardown;
+      if (z(f))
+        try {
+          f();
+        } catch (g) {
+          a = g instanceof Tt ? g.errors : [g];
+        }
+      var d = this._finalizers;
+      if (d) {
+        this._finalizers = null;
+        try {
+          for (var c = Fe(d), h = c.next(); !h.done; h = c.next()) {
+            var _ = h.value;
+            try {
+              xn(_);
+            } catch (g) {
+              a = a ?? [], g instanceof Tt ? a = st(st([], ot(a)), ot(g.errors)) : a.push(g);
+            }
+          }
+        } catch (g) {
+          i = { error: g };
+        } finally {
+          try {
+            h && !h.done && (r = c.return) && r.call(c);
+          } finally {
+            if (i)
+              throw i.error;
+          }
+        }
+      }
+      if (a)
+        throw new Tt(a);
+    }
+  }, e.prototype.add = function(n) {
+    var t;
+    if (n && n !== this)
+      if (this.closed)
+        xn(n);
+      else {
+        if (n instanceof e) {
+          if (n.closed || n._hasParent(this))
+            return;
+          n._addParent(this);
+        }
+        (this._finalizers = (t = this._finalizers) !== null && t !== void 0 ? t : []).push(n);
+      }
+  }, e.prototype._hasParent = function(n) {
+    var t = this._parentage;
+    return t === n || Array.isArray(t) && t.includes(n);
+  }, e.prototype._addParent = function(n) {
+    var t = this._parentage;
+    this._parentage = Array.isArray(t) ? (t.push(n), t) : t ? [t, n] : n;
+  }, e.prototype._removeParent = function(n) {
+    var t = this._parentage;
+    t === n ? this._parentage = null : Array.isArray(t) && Zn(t, n);
+  }, e.prototype.remove = function(n) {
+    var t = this._finalizers;
+    t && Zn(t, n), n instanceof e && n._removeParent(this);
+  }, e.EMPTY = function() {
+    var n = new e();
+    return n.closed = !0, n;
+  }(), e;
+}();
+Xt.EMPTY;
+function Ri(e) {
+  return e instanceof Xt || e && "closed" in e && z(e.remove) && z(e.add) && z(e.unsubscribe);
+}
+function xn(e) {
+  z(e) ? e() : e.unsubscribe();
+}
+var Bi = {
+  onUnhandledError: null,
+  onStoppedNotification: null,
+  Promise: void 0,
+  useDeprecatedSynchronousErrorHandling: !1,
+  useDeprecatedNextContext: !1
+}, Zt = {
+  setTimeout: function(e, n) {
+    for (var t = [], i = 2; i < arguments.length; i++)
+      t[i - 2] = arguments[i];
+    var r = Zt.delegate;
+    return r != null && r.setTimeout ? r.setTimeout.apply(r, st([e, n], ot(t))) : setTimeout.apply(void 0, st([e, n], ot(t)));
+  },
+  clearTimeout: function(e) {
+    var n = Zt.delegate;
+    return ((n == null ? void 0 : n.clearTimeout) || clearTimeout)(e);
+  },
+  delegate: void 0
+};
+function Ui(e) {
+  Zt.setTimeout(function() {
+    throw e;
+  });
+}
+function Mn() {
+}
+function Ko(e) {
+  e();
+}
+var qt = function(e) {
+  Wt(n, e);
+  function n(t) {
+    var i = e.call(this) || this;
+    return i.isStopped = !1, t ? (i.destination = t, Ri(t) && t.add(i)) : i.destination = Jo, i;
+  }
+  return n.create = function(t, i, r) {
+    return new lt(t, i, r);
+  }, n.prototype.next = function(t) {
+    this.isStopped || this._next(t);
+  }, n.prototype.error = function(t) {
+    this.isStopped || (this.isStopped = !0, this._error(t));
+  }, n.prototype.complete = function() {
+    this.isStopped || (this.isStopped = !0, this._complete());
+  }, n.prototype.unsubscribe = function() {
+    this.closed || (this.isStopped = !0, e.prototype.unsubscribe.call(this), this.destination = null);
+  }, n.prototype._next = function(t) {
+    this.destination.next(t);
+  }, n.prototype._error = function(t) {
+    try {
+      this.destination.error(t);
+    } finally {
+      this.unsubscribe();
+    }
+  }, n.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  }, n;
+}(Xt), Wo = Function.prototype.bind;
+function It(e, n) {
+  return Wo.call(e, n);
+}
+var Xo = function() {
+  function e(n) {
+    this.partialObserver = n;
+  }
+  return e.prototype.next = function(n) {
+    var t = this.partialObserver;
+    if (t.next)
+      try {
+        t.next(n);
+      } catch (i) {
+        tt(i);
+      }
+  }, e.prototype.error = function(n) {
+    var t = this.partialObserver;
+    if (t.error)
+      try {
+        t.error(n);
+      } catch (i) {
+        tt(i);
+      }
+    else
+      tt(n);
+  }, e.prototype.complete = function() {
+    var n = this.partialObserver;
+    if (n.complete)
+      try {
+        n.complete();
+      } catch (t) {
+        tt(t);
+      }
+  }, e;
+}(), lt = function(e) {
+  Wt(n, e);
+  function n(t, i, r) {
+    var a = e.call(this) || this, o;
+    if (z(t) || !t)
+      o = {
+        next: t ?? void 0,
+        error: i ?? void 0,
+        complete: r ?? void 0
+      };
+    else {
+      var l;
+      a && Bi.useDeprecatedNextContext ? (l = Object.create(t), l.unsubscribe = function() {
+        return a.unsubscribe();
+      }, o = {
+        next: t.next && It(t.next, l),
+        error: t.error && It(t.error, l),
+        complete: t.complete && It(t.complete, l)
+      }) : o = t;
+    }
+    return a.destination = new Xo(o), a;
+  }
+  return n;
+}(qt);
+function tt(e) {
+  Ui(e);
+}
+function qo(e) {
+  throw e;
+}
+var Jo = {
+  closed: !0,
+  next: Mn,
+  error: qo,
+  complete: Mn
+}, Jt = function() {
+  return typeof Symbol == "function" && Symbol.observable || "@@observable";
+}();
+function Di(e) {
+  return e;
+}
+function Qo(e) {
+  return e.length === 0 ? Di : e.length === 1 ? e[0] : function(t) {
+    return e.reduce(function(i, r) {
+      return r(i);
+    }, t);
+  };
+}
+var Z = function() {
+  function e(n) {
+    n && (this._subscribe = n);
+  }
+  return e.prototype.lift = function(n) {
+    var t = new e();
+    return t.source = this, t.operator = n, t;
+  }, e.prototype.subscribe = function(n, t, i) {
+    var r = this, a = ts(n) ? n : new lt(n, t, i);
+    return Ko(function() {
+      var o = r, l = o.operator, u = o.source;
+      a.add(l ? l.call(a, u) : u ? r._subscribe(a) : r._trySubscribe(a));
+    }), a;
+  }, e.prototype._trySubscribe = function(n) {
+    try {
+      return this._subscribe(n);
+    } catch (t) {
+      n.error(t);
+    }
+  }, e.prototype.forEach = function(n, t) {
+    var i = this;
+    return t = Hn(t), new t(function(r, a) {
+      var o = new lt({
+        next: function(l) {
+          try {
+            n(l);
+          } catch (u) {
+            a(u), o.unsubscribe();
+          }
+        },
+        error: a,
+        complete: r
+      });
+      i.subscribe(o);
+    });
+  }, e.prototype._subscribe = function(n) {
+    var t;
+    return (t = this.source) === null || t === void 0 ? void 0 : t.subscribe(n);
+  }, e.prototype[Jt] = function() {
+    return this;
+  }, e.prototype.pipe = function() {
+    for (var n = [], t = 0; t < arguments.length; t++)
+      n[t] = arguments[t];
+    return Qo(n)(this);
+  }, e.prototype.toPromise = function(n) {
+    var t = this;
+    return n = Hn(n), new n(function(i, r) {
+      var a;
+      t.subscribe(function(o) {
+        return a = o;
+      }, function(o) {
+        return r(o);
+      }, function() {
+        return i(a);
+      });
+    });
+  }, e.create = function(n) {
+    return new e(n);
+  }, e;
+}();
+function Hn(e) {
+  var n;
+  return (n = e ?? Bi.Promise) !== null && n !== void 0 ? n : Promise;
+}
+function es(e) {
+  return e && z(e.next) && z(e.error) && z(e.complete);
+}
+function ts(e) {
+  return e && e instanceof qt || es(e) && Ri(e);
+}
+function ns(e) {
+  return z(e == null ? void 0 : e.lift);
+}
+function $e(e) {
+  return function(n) {
+    if (ns(n))
+      return n.lift(function(t) {
+        try {
+          return e(t, this);
+        } catch (i) {
+          this.error(i);
+        }
+      });
+    throw new TypeError("Unable to lift unknown Observable type");
+  };
+}
+function Pe(e, n, t, i, r) {
+  return new is(e, n, t, i, r);
+}
+var is = function(e) {
+  Wt(n, e);
+  function n(t, i, r, a, o, l) {
+    var u = e.call(this, t) || this;
+    return u.onFinalize = o, u.shouldUnsubscribe = l, u._next = i ? function(s) {
+      try {
+        i(s);
+      } catch (f) {
+        t.error(f);
+      }
+    } : e.prototype._next, u._error = a ? function(s) {
+      try {
+        a(s);
+      } catch (f) {
+        t.error(f);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._error, u._complete = r ? function() {
+      try {
+        r();
+      } catch (s) {
+        t.error(s);
+      } finally {
+        this.unsubscribe();
+      }
+    } : e.prototype._complete, u;
+  }
+  return n.prototype.unsubscribe = function() {
+    var t;
+    if (!this.shouldUnsubscribe || this.shouldUnsubscribe()) {
+      var i = this.closed;
+      e.prototype.unsubscribe.call(this), !i && ((t = this.onFinalize) === null || t === void 0 || t.call(this));
+    }
+  }, n;
+}(qt), rs = new Z(function(e) {
+  return e.complete();
+});
+function as(e) {
+  return e && z(e.schedule);
+}
+function Vi(e) {
+  return e[e.length - 1];
+}
+function os(e) {
+  return as(Vi(e)) ? e.pop() : void 0;
+}
+function ss(e, n) {
+  return typeof Vi(e) == "number" ? e.pop() : n;
+}
+var Li = function(e) {
+  return e && typeof e.length == "number" && typeof e != "function";
+};
+function Fi(e) {
+  return z(e == null ? void 0 : e.then);
+}
+function Pi(e) {
+  return z(e[Jt]);
+}
+function Zi(e) {
+  return Symbol.asyncIterator && z(e == null ? void 0 : e[Symbol.asyncIterator]);
+}
+function xi(e) {
+  return new TypeError("You provided " + (e !== null && typeof e == "object" ? "an invalid object" : "'" + e + "'") + " where a stream was expected. You can provide an Observable, Promise, ReadableStream, Array, AsyncIterable, or Iterable.");
+}
+function ls() {
+  return typeof Symbol != "function" || !Symbol.iterator ? "@@iterator" : Symbol.iterator;
+}
+var Mi = ls();
+function Hi(e) {
+  return z(e == null ? void 0 : e[Mi]);
+}
+function ji(e) {
+  return Go(this, arguments, function() {
+    var t, i, r, a;
+    return Oi(this, function(o) {
+      switch (o.label) {
+        case 0:
+          t = e.getReader(), o.label = 1;
+        case 1:
+          o.trys.push([1, , 9, 10]), o.label = 2;
+        case 2:
+          return [4, be(t.read())];
+        case 3:
+          return i = o.sent(), r = i.value, a = i.done, a ? [4, be(void 0)] : [3, 5];
+        case 4:
+          return [2, o.sent()];
+        case 5:
+          return [4, be(r)];
+        case 6:
+          return [4, o.sent()];
+        case 7:
+          return o.sent(), [3, 2];
+        case 8:
+          return [3, 10];
+        case 9:
+          return t.releaseLock(), [7];
+        case 10:
+          return [2];
+      }
+    });
+  });
+}
+function Gi(e) {
+  return z(e == null ? void 0 : e.getReader);
+}
+function Ee(e) {
+  if (e instanceof Z)
+    return e;
+  if (e != null) {
+    if (Pi(e))
+      return fs(e);
+    if (Li(e))
+      return us(e);
+    if (Fi(e))
+      return hs(e);
+    if (Zi(e))
+      return Yi(e);
+    if (Hi(e))
+      return cs(e);
+    if (Gi(e))
+      return ds(e);
+  }
+  throw xi(e);
+}
+function fs(e) {
+  return new Z(function(n) {
+    var t = e[Jt]();
+    if (z(t.subscribe))
+      return t.subscribe(n);
+    throw new TypeError("Provided object does not correctly implement Symbol.observable");
+  });
+}
+function us(e) {
+  return new Z(function(n) {
+    for (var t = 0; t < e.length && !n.closed; t++)
+      n.next(e[t]);
+    n.complete();
+  });
+}
+function hs(e) {
+  return new Z(function(n) {
+    e.then(function(t) {
+      n.closed || (n.next(t), n.complete());
+    }, function(t) {
+      return n.error(t);
+    }).then(null, Ui);
+  });
+}
+function cs(e) {
+  return new Z(function(n) {
+    var t, i;
+    try {
+      for (var r = Fe(e), a = r.next(); !a.done; a = r.next()) {
+        var o = a.value;
+        if (n.next(o), n.closed)
+          return;
+      }
+    } catch (l) {
+      t = { error: l };
+    } finally {
+      try {
+        a && !a.done && (i = r.return) && i.call(r);
+      } finally {
+        if (t)
+          throw t.error;
+      }
+    }
+    n.complete();
+  });
+}
+function Yi(e) {
+  return new Z(function(n) {
+    ps(e, n).catch(function(t) {
+      return n.error(t);
+    });
+  });
+}
+function ds(e) {
+  return Yi(ji(e));
+}
+function ps(e, n) {
+  var t, i, r, a;
+  return jo(this, void 0, void 0, function() {
+    var o, l;
+    return Oi(this, function(u) {
+      switch (u.label) {
+        case 0:
+          u.trys.push([0, 5, 6, 11]), t = Yo(e), u.label = 1;
+        case 1:
+          return [4, t.next()];
+        case 2:
+          if (i = u.sent(), !!i.done)
+            return [3, 4];
+          if (o = i.value, n.next(o), n.closed)
+            return [2];
+          u.label = 3;
+        case 3:
+          return [3, 1];
+        case 4:
+          return [3, 11];
+        case 5:
+          return l = u.sent(), r = { error: l }, [3, 11];
+        case 6:
+          return u.trys.push([6, , 9, 10]), i && !i.done && (a = t.return) ? [4, a.call(t)] : [3, 8];
+        case 7:
+          u.sent(), u.label = 8;
+        case 8:
+          return [3, 10];
+        case 9:
+          if (r)
+            throw r.error;
+          return [7];
+        case 10:
+          return [7];
+        case 11:
+          return n.complete(), [2];
+      }
+    });
+  });
+}
+function re(e, n, t, i, r) {
+  i === void 0 && (i = 0), r === void 0 && (r = !1);
+  var a = n.schedule(function() {
+    t(), r ? e.add(this.schedule(null, i)) : this.unsubscribe();
+  }, i);
+  if (e.add(a), !r)
+    return a;
+}
+function Ki(e, n) {
+  return n === void 0 && (n = 0), $e(function(t, i) {
+    t.subscribe(Pe(i, function(r) {
+      return re(i, e, function() {
+        return i.next(r);
+      }, n);
+    }, function() {
+      return re(i, e, function() {
+        return i.complete();
+      }, n);
+    }, function(r) {
+      return re(i, e, function() {
+        return i.error(r);
+      }, n);
+    }));
+  });
+}
+function Wi(e, n) {
+  return n === void 0 && (n = 0), $e(function(t, i) {
+    i.add(e.schedule(function() {
+      return t.subscribe(i);
+    }, n));
+  });
+}
+function _s(e, n) {
+  return Ee(e).pipe(Wi(n), Ki(n));
+}
+function bs(e, n) {
+  return Ee(e).pipe(Wi(n), Ki(n));
+}
+function gs(e, n) {
+  return new Z(function(t) {
+    var i = 0;
+    return n.schedule(function() {
+      i === e.length ? t.complete() : (t.next(e[i++]), t.closed || this.schedule());
+    });
+  });
+}
+function ws(e, n) {
+  return new Z(function(t) {
+    var i;
+    return re(t, n, function() {
+      i = e[Mi](), re(t, n, function() {
+        var r, a, o;
+        try {
+          r = i.next(), a = r.value, o = r.done;
+        } catch (l) {
+          t.error(l);
+          return;
+        }
+        o ? t.complete() : t.next(a);
+      }, 0, !0);
+    }), function() {
+      return z(i == null ? void 0 : i.return) && i.return();
+    };
+  });
+}
+function Xi(e, n) {
+  if (!e)
+    throw new Error("Iterable cannot be null");
+  return new Z(function(t) {
+    re(t, n, function() {
+      var i = e[Symbol.asyncIterator]();
+      re(t, n, function() {
+        i.next().then(function(r) {
+          r.done ? t.complete() : t.next(r.value);
+        });
+      }, 0, !0);
+    });
+  });
+}
+function ms(e, n) {
+  return Xi(ji(e), n);
+}
+function ys(e, n) {
+  if (e != null) {
+    if (Pi(e))
+      return _s(e, n);
+    if (Li(e))
+      return gs(e, n);
+    if (Fi(e))
+      return bs(e, n);
+    if (Zi(e))
+      return Xi(e, n);
+    if (Hi(e))
+      return ws(e, n);
+    if (Gi(e))
+      return ms(e, n);
+  }
+  throw xi(e);
+}
+function vs(e, n) {
+  return n ? ys(e, n) : Ee(e);
+}
+var ks = zi(function(e) {
+  return function() {
+    e(this), this.name = "EmptyError", this.message = "no elements in sequence";
+  };
+});
+function qi(e, n) {
+  var t = typeof n == "object";
+  return new Promise(function(i, r) {
+    var a = new lt({
+      next: function(o) {
+        i(o), a.unsubscribe();
+      },
+      error: r,
+      complete: function() {
+        t ? i(n.defaultValue) : r(new ks());
+      }
+    });
+    e.subscribe(a);
+  });
+}
+function Ji(e, n) {
+  return $e(function(t, i) {
+    var r = 0;
+    t.subscribe(Pe(i, function(a) {
+      i.next(e.call(n, a, r++));
+    }));
+  });
+}
+function $s(e, n, t, i, r, a, o, l) {
+  var u = [], s = 0, f = 0, d = !1, c = function() {
+    d && !u.length && !s && n.complete();
+  }, h = function(g) {
+    return s < i ? _(g) : u.push(g);
+  }, _ = function(g) {
+    a && n.next(g), s++;
+    var k = !1;
+    Ee(t(g, f++)).subscribe(Pe(n, function(y) {
+      r == null || r(y), a ? h(y) : n.next(y);
+    }, function() {
+      k = !0;
+    }, void 0, function() {
+      if (k)
+        try {
+          s--;
+          for (var y = function() {
+            var E = u.shift();
+            o ? re(n, o, function() {
+              return _(E);
+            }) : _(E);
+          }; u.length && s < i; )
+            y();
+          c();
+        } catch (E) {
+          n.error(E);
+        }
+    }));
+  };
+  return e.subscribe(Pe(n, h, function() {
+    d = !0, c();
+  })), function() {
+    l == null || l();
+  };
+}
+function Qi(e, n, t) {
+  return t === void 0 && (t = 1 / 0), z(n) ? Qi(function(i, r) {
+    return Ji(function(a, o) {
+      return n(i, a, r, o);
+    })(Ee(e(i, r)));
+  }, t) : (typeof n == "number" && (t = n), $e(function(i, r) {
+    return $s(i, r, e, t);
+  }));
+}
+function Es(e) {
+  return e === void 0 && (e = 1 / 0), Qi(Di, e);
+}
+function Cs() {
+  for (var e = [], n = 0; n < arguments.length; n++)
+    e[n] = arguments[n];
+  var t = os(e), i = ss(e, 1 / 0), r = e;
+  return r.length ? r.length === 1 ? Ee(r[0]) : Es(i)(vs(r, t)) : rs;
+}
+function Ss(e, n, t, i, r) {
+  return function(a, o) {
+    var l = t, u = n, s = 0;
+    a.subscribe(Pe(o, function(f) {
+      var d = s++;
+      u = l ? e(u, f, d) : (l = !0, f), i && o.next(u);
+    }, r && function() {
+      l && o.next(u), o.complete();
+    }));
+  };
+}
+function er(e, n) {
+  return $e(Ss(e, n, arguments.length >= 2, !1, !0));
+}
+var Ns = function(e, n) {
+  return e.push(n), e;
+};
+function Ts() {
+  return $e(function(e, n) {
+    er(Ns, [])(e).subscribe(n);
+  });
+}
+const jn = -2003829722, At = -2021002517;
+function Is(e) {
+  return new TextDecoder().decode(e);
+}
+function Gn(e) {
+  const n = e ? "big" : "little", t = new N().endianess(n).int32("magic").uint16("version").uint16("numZoomLevels").uint64("chromTreeOffset").uint64("unzoomedDataOffset").uint64("unzoomedIndexOffset").uint16("fieldCount").uint16("definedFieldCount").uint64("asOffset").uint64("totalSummaryOffset").uint32("uncompressBufSize").uint64("extHeaderOffset").array("zoomLevels", {
+    length: "numZoomLevels",
+    type: new N().endianess(n).uint32("reductionLevel").uint32("reserved").uint64("dataOffset").uint64("indexOffset")
+  }), i = new N().endianess(n).uint64("basesCovered").doublele("scoreMin").doublele("scoreMax").doublele("scoreSum").doublele("scoreSumSquares"), r = new N().endianess(n).uint32("magic").uint32("blockSize").uint32("keySize").uint32("valSize").uint64("itemCount"), a = new N().endianess(n).uint8("isLeafNode").skip(1).uint16("cnt").saveOffset("offset");
+  return {
+    chromTreeParser: r,
+    totalSummaryParser: i,
+    headerParser: t,
+    isLeafNode: a
+  };
+}
+class tr {
+  /* fetch and parse header information from a bigwig or bigbed file
+   * @param abortSignal - abort the operation, can be null
+   * @return a Header object
+   */
+  getHeader(n) {
+    return this.headerP || (this.headerP = this._getHeader(n).catch((t) => {
+      throw this.headerP = void 0, t;
+    })), this.headerP;
+  }
+  /*
+   * @param filehandle - a filehandle from generic-filehandle or implementing something similar to the node10 fs.promises API
+   * @param path - a Local file path as a string
+   * @param url - a URL string
+   * @param renameRefSeqs - an optional method to rename the internal reference sequences using a mapping function
+   */
+  constructor(n) {
+    const { filehandle: t, renameRefSeqs: i = (o) => o, path: r, url: a } = n;
+    if (this.renameRefSeqs = i, t)
+      this.bbi = t;
+    else if (a)
+      this.bbi = new ir(a);
+    else if (r)
+      this.bbi = new nr(r);
+    else
+      throw new Error("no file given");
+  }
+  async _getHeader(n) {
+    const t = await this._getMainHeader(n), i = await this._readChromTree(t, n);
+    return { ...t, ...i };
+  }
+  async _getMainHeader(n, t = 2e3) {
+    const { buffer: i } = await this.bbi.read(Q.Buffer.alloc(t), 0, t, 0, n), r = this._isBigEndian(i), a = Gn(r), o = a.headerParser.parse(i), { magic: l, asOffset: u, totalSummaryOffset: s } = o;
+    if (o.fileType = l === At ? "bigbed" : "bigwig", u > t || s > t)
+      return this._getMainHeader(n, t * 2);
+    if (u) {
+      const f = Number(o.asOffset);
+      o.autoSql = Is(i.subarray(f, i.indexOf(0, f)));
+    }
+    if (o.totalSummaryOffset > t)
+      return this._getMainHeader(n, t * 2);
+    if (o.totalSummaryOffset) {
+      const f = i.subarray(Number(o.totalSummaryOffset)), d = a.totalSummaryParser.parse(f);
+      o.totalSummary = { ...d, basesCovered: Number(d.basesCovered) };
+    }
+    return { ...o, isBigEndian: r };
+  }
+  _isBigEndian(n) {
+    let t = n.readInt32LE(0);
+    if (t === jn || t === At)
+      return !1;
+    if (t = n.readInt32BE(0), t === jn || t === At)
+      return !0;
+    throw new Error("not a BigWig/BigBed file");
+  }
+  // todo: add progress if long running
+  async _readChromTree(n, t) {
+    const i = n.isBigEndian, r = i ? "big" : "little", a = [], o = {};
+    let l = Number(n.unzoomedDataOffset);
+    const u = Number(n.chromTreeOffset);
+    for (; l % 4 !== 0; )
+      l += 1;
+    const s = l - u, { buffer: f } = await this.bbi.read(Q.Buffer.alloc(s), 0, s, Number(u), t), d = Gn(i), { keySize: c } = d.chromTreeParser.parse(f), h = new N().endianess(r).string("key", { stripNull: !0, length: c }).uint32("refId").uint32("refSize").saveOffset("offset"), _ = new N().endianess(r).skip(c).uint64("childOffset").saveOffset("offset"), g = 32, k = async (y) => {
+      let E = y;
+      if (E >= f.length)
+        throw new Error("reading beyond end of buffer");
+      const C = d.isLeafNode.parse(f.subarray(E)), { isLeafNode: p, cnt: $ } = C;
+      if (E += C.offset, p)
+        for (let S = 0; S < $; S += 1) {
+          const b = h.parse(f.subarray(E));
+          E += b.offset;
+          const { key: w, refId: m, refSize: v } = b, T = { name: w, id: m, length: v };
+          o[this.renameRefSeqs(w)] = m, a[m] = T;
+        }
+      else {
+        const S = [];
+        for (let b = 0; b < $; b += 1) {
+          const w = _.parse(f.subarray(E)), { childOffset: m } = w;
+          E += w.offset, S.push(k(Number(m) - Number(u)));
+        }
+        await Promise.all(S);
+      }
+    };
+    return await k(g), {
+      refsByName: o,
+      refsByNumber: a
+    };
+  }
+  /*
+   * fetches the "unzoomed" view of the bigwig data. this is the default for bigbed
+   * @param abortSignal - a signal to optionally abort this operation
+   */
+  async getUnzoomedView(n) {
+    const { unzoomedIndexOffset: t, refsByName: i, uncompressBufSize: r, isBigEndian: a, fileType: o } = await this.getHeader(n);
+    return new Ai(this.bbi, i, t, a, r > 0, o);
+  }
+  /**
+   * Gets features from a BigWig file
+   *
+   * @param refName - The chromosome name
+   * @param start - The start of a region
+   * @param end - The end of a region
+   * @param opts - An object containing basesPerSpan (e.g. pixels per basepair) or scale used to infer the zoomLevel to use
+   */
+  async getFeatureStream(n, t, i, r) {
+    await this.getHeader(r);
+    const a = this.renameRefSeqs(n);
+    let o;
+    const { basesPerSpan: l, scale: u } = r || {};
+    return l ? o = await this.getView(1 / l, r) : u ? o = await this.getView(u, r) : o = await this.getView(1, r), new Z((s) => {
+      o.readWigData(a, t, i, s, r);
+    });
+  }
+  async getFeatures(n, t, i, r) {
+    const a = await this.getFeatureStream(n, t, i, r);
+    return (await qi(a.pipe(Ts()))).flat();
+  }
+}
+class Fs extends tr {
+  /**
+   * Retrieves a BlockView of a specific zoomLevel
+   *
+   * @param scale - number
+   * @param opts - An object containing basesPerSpan (e.g. pixels per basepair) or scale used to infer the zoomLevel to use
+   */
+  async getView(n, t) {
+    const { zoomLevels: i, refsByName: r, fileSize: a, isBigEndian: o, uncompressBufSize: l } = await this.getHeader(t), u = 1 / n;
+    let s = i.length;
+    a || (s -= 1);
+    for (let f = s; f >= 0; f -= 1) {
+      const d = i[f];
+      if (d && d.reductionLevel <= 2 * u) {
+        const c = Number(d.indexOffset);
+        return new Ai(this.bbi, r, c, o, l > 0, "summary");
+      }
+    }
+    return this.getUnzoomedView(t);
+  }
+}
+function As(e) {
+  return e.filter((n) => !!n);
+}
+class Ps extends tr {
+  constructor() {
+    super(...arguments), this.readIndicesCache = new Yn({
+      cache: new Kn({ maxSize: 1 }),
+      fill: (n, t) => this._readIndices({ ...n, signal: t })
+    });
+  }
+  readIndices(n = {}) {
+    const { signal: t, ...i } = n;
+    return this.readIndicesCache.get(JSON.stringify(i), n, t);
+  }
+  /*
+   * retrieve unzoomed view for any scale
+   */
+  async getView(n, t) {
+    return this.getUnzoomedView(t);
+  }
+  /*
+   * parse the bigbed extraIndex fields
+   * @param abortSignal to abort operation
+   * @return a Promise for an array of Index data structure since there can be multiple extraIndexes in a bigbed, see bedToBigBed documentation
+   */
+  async _readIndices(n) {
+    const { extHeaderOffset: t, isBigEndian: i } = await this.getHeader(n), { buffer: r } = await this.bbi.read(Q.Buffer.alloc(64), 0, 64, Number(t)), a = i ? "big" : "little", o = new N().endianess(a).uint16("size").uint16("count").uint64("offset").parse(r), { count: l, offset: u } = o;
+    if (l === 0)
+      return [];
+    const s = 20, f = s * l, { buffer: d } = await this.bbi.read(Q.Buffer.alloc(f), 0, f, Number(u)), c = new N().endianess(a).int16("type").int16("fieldcount").uint64("offset").skip(4).int16("field"), h = [];
+    for (let _ = 0; _ < l; _ += 1)
+      h.push(c.parse(d.subarray(_ * s)));
+    return h;
+  }
+  /*
+   * perform a search in the bigbed extraIndex to find which blocks in the bigbed data to look for the
+   * actual feature data
+   *
+   * @param name - the name to search for
+   * @param opts - a SearchOptions argument with optional signal
+   * @return a Promise for an array of bigbed block Loc entries
+   */
+  async searchExtraIndexBlocks(n, t = {}) {
+    const { isBigEndian: i } = await this.getHeader(t), r = await this.readIndices(t);
+    if (r.length === 0)
+      return [];
+    const a = r.map(async (o) => {
+      const { offset: l, field: u } = o, { buffer: s } = await this.bbi.read(Q.Buffer.alloc(32), 0, 32, Number(l), t), f = i ? "big" : "little", d = new N().endianess(f).int32("magic").int32("blockSize").int32("keySize").int32("valSize").uint64("itemCount"), { blockSize: c, keySize: h, valSize: _ } = d.parse(s), g = new N().endianess(f).int8("nodeType").skip(1).int16("cnt").choice({
+        tag: "nodeType",
+        choices: {
+          0: new N().array("leafkeys", {
+            length: "cnt",
+            type: new N().endianess(f).string("key", { length: h, stripNull: !0 }).uint64("offset")
+          }),
+          1: new N().array("keys", {
+            length: "cnt",
+            type: new N().endianess(f).string("key", { length: h, stripNull: !0 }).uint64("offset").uint32("length").uint32("reserved")
+          })
+        }
+      }), k = async (E) => {
+        const C = Number(E), p = 4 + c * (h + _), { buffer: $ } = await this.bbi.read(Q.Buffer.alloc(p), 0, p, C, t), S = g.parse($);
+        if (S.leafkeys) {
+          let b;
+          for (let w = 0; w < S.leafkeys.length; w += 1) {
+            const { key: m } = S.leafkeys[w];
+            if (n.localeCompare(m) < 0 && b)
+              return k(b);
+            b = S.leafkeys[w].offset;
+          }
+          return k(b);
+        }
+        for (let b = 0; b < S.keys.length; b += 1)
+          if (S.keys[b].key === n)
+            return { ...S.keys[b], field: u };
+      }, y = 32;
+      return k(Number(l) + y);
+    });
+    return As(await Promise.all(a));
+  }
+  /*
+   * retrieve the features from the bigbed data that were found through the lookup of the extraIndex
+   * note that there can be multiple extraIndex, see the BigBed specification and the -extraIndex argument to bedToBigBed
+   *
+   * @param name - the name to search for
+   * @param opts - a SearchOptions argument with optional signal
+   * @return a Promise for an array of Feature
+   */
+  async searchExtraIndex(n, t = {}) {
+    const i = await this.searchExtraIndexBlocks(n, t);
+    if (i.length === 0)
+      return [];
+    const r = await this.getUnzoomedView(t), a = i.map((l) => new Z((u) => {
+      r.readFeatures(u, [l], t);
+    }).pipe(er((u, s) => u.concat(s)), Ji((u) => {
+      for (const s of u)
+        s.field = l.field;
+      return u;
+    })));
+    return (await qi(Cs(...a))).filter((l) => {
+      var u;
+      return ((u = l.rest) === null || u === void 0 ? void 0 : u.split("	")[(l.field || 0) - 3]) === n;
+    });
+  }
+}
+export {
+  Ps as BigBed,
+  Fs as BigWig
+};