@agile-team/mach-report 2.16.0 → 2.18.0

package/dist/index-CPh6tqge.js

@@ -0,0 +1,1575 @@
+function Ht(t, i = "utf8") {
+  return new TextDecoder(i).decode(t);
+}
+const Ie = new TextEncoder();
+function Re(t) {
+  return Ie.encode(t);
+}
+const Oe = 1024 * 8, Be = (() => {
+  const t = new Uint8Array(4), i = new Uint32Array(t.buffer);
+  return !((i[0] = 1) & t[0]);
+})(), bt = {
+  int8: globalThis.Int8Array,
+  uint8: globalThis.Uint8Array,
+  int16: globalThis.Int16Array,
+  uint16: globalThis.Uint16Array,
+  int32: globalThis.Int32Array,
+  uint32: globalThis.Uint32Array,
+  uint64: globalThis.BigUint64Array,
+  int64: globalThis.BigInt64Array,
+  float32: globalThis.Float32Array,
+  float64: globalThis.Float64Array
+};
+class st {
+  /**
+   * Reference to the internal ArrayBuffer object.
+   */
+  buffer;
+  /**
+   * Byte length of the internal ArrayBuffer.
+   */
+  byteLength;
+  /**
+   * Byte offset of the internal ArrayBuffer.
+   */
+  byteOffset;
+  /**
+   * Byte length of the internal ArrayBuffer.
+   */
+  length;
+  /**
+   * The current offset of the buffer's pointer.
+   */
+  offset;
+  lastWrittenByte;
+  littleEndian;
+  _data;
+  _mark;
+  _marks;
+  /**
+   * Create a new IOBuffer.
+   * @param data - The data to construct the IOBuffer with.
+   * If data is a number, it will be the new buffer's length<br>
+   * If data is `undefined`, the buffer will be initialized with a default length of 8Kb<br>
+   * If data is an ArrayBuffer, SharedArrayBuffer, an ArrayBufferView (Typed Array), an IOBuffer instance,
+   * or a Node.js Buffer, a view will be created over the underlying ArrayBuffer.
+   * @param options - An object for the options.
+   * @returns A new IOBuffer instance.
+   */
+  constructor(i = Oe, e = {}) {
+    let n = !1;
+    typeof i == "number" ? i = new ArrayBuffer(i) : (n = !0, this.lastWrittenByte = i.byteLength);
+    const a = e.offset ? e.offset >>> 0 : 0, r = i.byteLength - a;
+    let l = a;
+    (ArrayBuffer.isView(i) || i instanceof st) && (i.byteLength !== i.buffer.byteLength && (l = i.byteOffset + a), i = i.buffer), n ? this.lastWrittenByte = r : this.lastWrittenByte = 0, this.buffer = i, this.length = r, this.byteLength = r, this.byteOffset = l, this.offset = 0, this.littleEndian = !0, this._data = new DataView(this.buffer, l, r), this._mark = 0, this._marks = [];
+  }
+  /**
+   * Checks if the memory allocated to the buffer is sufficient to store more
+   * bytes after the offset.
+   * @param byteLength - The needed memory in bytes.
+   * @returns `true` if there is sufficient space and `false` otherwise.
+   */
+  available(i = 1) {
+    return this.offset + i <= this.length;
+  }
+  /**
+   * Check if little-endian mode is used for reading and writing multi-byte
+   * values.
+   * @returns `true` if little-endian mode is used, `false` otherwise.
+   */
+  isLittleEndian() {
+    return this.littleEndian;
+  }
+  /**
+   * Set little-endian mode for reading and writing multi-byte values.
+   * @returns This.
+   */
+  setLittleEndian() {
+    return this.littleEndian = !0, this;
+  }
+  /**
+   * Check if big-endian mode is used for reading and writing multi-byte values.
+   * @returns `true` if big-endian mode is used, `false` otherwise.
+   */
+  isBigEndian() {
+    return !this.littleEndian;
+  }
+  /**
+   * Switches to big-endian mode for reading and writing multi-byte values.
+   * @returns This.
+   */
+  setBigEndian() {
+    return this.littleEndian = !1, this;
+  }
+  /**
+   * Move the pointer n bytes forward.
+   * @param n - Number of bytes to skip.
+   * @returns This.
+   */
+  skip(i = 1) {
+    return this.offset += i, this;
+  }
+  /**
+   * Move the pointer n bytes backward.
+   * @param n - Number of bytes to move back.
+   * @returns This.
+   */
+  back(i = 1) {
+    return this.offset -= i, this;
+  }
+  /**
+   * Move the pointer to the given offset.
+   * @param offset - The offset to move to.
+   * @returns This.
+   */
+  seek(i) {
+    return this.offset = i, this;
+  }
+  /**
+   * Store the current pointer offset.
+   * @see {@link IOBuffer#reset}
+   * @returns This.
+   */
+  mark() {
+    return this._mark = this.offset, this;
+  }
+  /**
+   * Move the pointer back to the last pointer offset set by mark.
+   * @see {@link IOBuffer#mark}
+   * @returns This.
+   */
+  reset() {
+    return this.offset = this._mark, this;
+  }
+  /**
+   * Push the current pointer offset to the mark stack.
+   * @see {@link IOBuffer#popMark}
+   * @returns This.
+   */
+  pushMark() {
+    return this._marks.push(this.offset), this;
+  }
+  /**
+   * Pop the last pointer offset from the mark stack, and set the current
+   * pointer offset to the popped value.
+   * @see {@link IOBuffer#pushMark}
+   * @returns This.
+   */
+  popMark() {
+    const i = this._marks.pop();
+    if (i === void 0)
+      throw new Error("Mark stack empty");
+    return this.seek(i), this;
+  }
+  /**
+   * Move the pointer offset back to 0.
+   * @returns This.
+   */
+  rewind() {
+    return this.offset = 0, this;
+  }
+  /**
+   * Make sure the buffer has sufficient memory to write a given byteLength at
+   * the current pointer offset.
+   * If the buffer's memory is insufficient, this method will create a new
+   * buffer (a copy) with a length that is twice (byteLength + current offset).
+   * @param byteLength - The needed memory in bytes.
+   * @returns This.
+   */
+  ensureAvailable(i = 1) {
+    if (!this.available(i)) {
+      const n = (this.offset + i) * 2, a = new Uint8Array(n);
+      a.set(new Uint8Array(this.buffer)), this.buffer = a.buffer, this.length = n, this.byteLength = n, this._data = new DataView(this.buffer);
+    }
+    return this;
+  }
+  /**
+   * Read a byte and return false if the byte's value is 0, or true otherwise.
+   * Moves pointer forward by one byte.
+   * @returns The read boolean.
+   */
+  readBoolean() {
+    return this.readUint8() !== 0;
+  }
+  /**
+   * Read a signed 8-bit integer and move pointer forward by 1 byte.
+   * @returns The read byte.
+   */
+  readInt8() {
+    return this._data.getInt8(this.offset++);
+  }
+  /**
+   * Read an unsigned 8-bit integer and move pointer forward by 1 byte.
+   * @returns The read byte.
+   */
+  readUint8() {
+    return this._data.getUint8(this.offset++);
+  }
+  /**
+   * Alias for {@link IOBuffer#readUint8}.
+   * @returns The read byte.
+   */
+  readByte() {
+    return this.readUint8();
+  }
+  /**
+   * Read `n` bytes and move pointer forward by `n` bytes.
+   * @param n - Number of bytes to read.
+   * @returns The read bytes.
+   */
+  readBytes(i = 1) {
+    return this.readArray(i, "uint8");
+  }
+  /**
+   * Creates an array of corresponding to the type `type` and size `size`.
+   * For example type `uint8` will create a `Uint8Array`.
+   * @param size - size of the resulting array
+   * @param type - number type of elements to read
+   * @returns The read array.
+   */
+  readArray(i, e) {
+    const n = bt[e].BYTES_PER_ELEMENT * i, a = this.byteOffset + this.offset, r = this.buffer.slice(a, a + n);
+    if (this.littleEndian === Be && e !== "uint8" && e !== "int8") {
+      const h = new Uint8Array(this.buffer.slice(a, a + n));
+      h.reverse();
+      const o = new bt[e](h.buffer);
+      return this.offset += n, o.reverse(), o;
+    }
+    const l = new bt[e](r);
+    return this.offset += n, l;
+  }
+  /**
+   * Read a 16-bit signed integer and move pointer forward by 2 bytes.
+   * @returns The read value.
+   */
+  readInt16() {
+    const i = this._data.getInt16(this.offset, this.littleEndian);
+    return this.offset += 2, i;
+  }
+  /**
+   * Read a 16-bit unsigned integer and move pointer forward by 2 bytes.
+   * @returns The read value.
+   */
+  readUint16() {
+    const i = this._data.getUint16(this.offset, this.littleEndian);
+    return this.offset += 2, i;
+  }
+  /**
+   * Read a 32-bit signed integer and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readInt32() {
+    const i = this._data.getInt32(this.offset, this.littleEndian);
+    return this.offset += 4, i;
+  }
+  /**
+   * Read a 32-bit unsigned integer and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readUint32() {
+    const i = this._data.getUint32(this.offset, this.littleEndian);
+    return this.offset += 4, i;
+  }
+  /**
+   * Read a 32-bit floating number and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readFloat32() {
+    const i = this._data.getFloat32(this.offset, this.littleEndian);
+    return this.offset += 4, i;
+  }
+  /**
+   * Read a 64-bit floating number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readFloat64() {
+    const i = this._data.getFloat64(this.offset, this.littleEndian);
+    return this.offset += 8, i;
+  }
+  /**
+   * Read a 64-bit signed integer number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readBigInt64() {
+    const i = this._data.getBigInt64(this.offset, this.littleEndian);
+    return this.offset += 8, i;
+  }
+  /**
+   * Read a 64-bit unsigned integer number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readBigUint64() {
+    const i = this._data.getBigUint64(this.offset, this.littleEndian);
+    return this.offset += 8, i;
+  }
+  /**
+   * Read a 1-byte ASCII character and move pointer forward by 1 byte.
+   * @returns The read character.
+   */
+  readChar() {
+    return String.fromCharCode(this.readInt8());
+  }
+  /**
+   * Read `n` 1-byte ASCII characters and move pointer forward by `n` bytes.
+   * @param n - Number of characters to read.
+   * @returns The read characters.
+   */
+  readChars(i = 1) {
+    let e = "";
+    for (let n = 0; n < i; n++)
+      e += this.readChar();
+    return e;
+  }
+  /**
+   * Read the next `n` bytes, return a UTF-8 decoded string and move pointer
+   * forward by `n` bytes.
+   * @param n - Number of bytes to read.
+   * @returns The decoded string.
+   */
+  readUtf8(i = 1) {
+    return Ht(this.readBytes(i));
+  }
+  /**
+   * Read the next `n` bytes, return a string decoded with `encoding` and move pointer
+   * forward by `n` bytes.
+   * If no encoding is passed, the function is equivalent to @see {@link IOBuffer#readUtf8}
+   * @param n - Number of bytes to read.
+   * @param encoding - The encoding to use. Default is 'utf8'.
+   * @returns The decoded string.
+   */
+  decodeText(i = 1, e = "utf8") {
+    return Ht(this.readBytes(i), e);
+  }
+  /**
+   * Write 0xff if the passed value is truthy, 0x00 otherwise and move pointer
+   * forward by 1 byte.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeBoolean(i) {
+    return this.writeUint8(i ? 255 : 0), this;
+  }
+  /**
+   * Write `value` as an 8-bit signed integer and move pointer forward by 1 byte.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeInt8(i) {
+    return this.ensureAvailable(1), this._data.setInt8(this.offset++, i), this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as an 8-bit unsigned integer and move pointer forward by 1
+   * byte.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeUint8(i) {
+    return this.ensureAvailable(1), this._data.setUint8(this.offset++, i), this._updateLastWrittenByte(), this;
+  }
+  /**
+   * An alias for {@link IOBuffer#writeUint8}.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeByte(i) {
+    return this.writeUint8(i);
+  }
+  /**
+   * Write all elements of `bytes` as uint8 values and move pointer forward by
+   * `bytes.length` bytes.
+   * @param bytes - The array of bytes to write.
+   * @returns This.
+   */
+  writeBytes(i) {
+    this.ensureAvailable(i.length);
+    for (let e = 0; e < i.length; e++)
+      this._data.setUint8(this.offset++, i[e]);
+    return this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 16-bit signed integer and move pointer forward by 2
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeInt16(i) {
+    return this.ensureAvailable(2), this._data.setInt16(this.offset, i, this.littleEndian), this.offset += 2, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 16-bit unsigned integer and move pointer forward by 2
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeUint16(i) {
+    return this.ensureAvailable(2), this._data.setUint16(this.offset, i, this.littleEndian), this.offset += 2, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 32-bit signed integer and move pointer forward by 4
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeInt32(i) {
+    return this.ensureAvailable(4), this._data.setInt32(this.offset, i, this.littleEndian), this.offset += 4, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 32-bit unsigned integer and move pointer forward by 4
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeUint32(i) {
+    return this.ensureAvailable(4), this._data.setUint32(this.offset, i, this.littleEndian), this.offset += 4, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 32-bit floating number and move pointer forward by 4
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeFloat32(i) {
+    return this.ensureAvailable(4), this._data.setFloat32(this.offset, i, this.littleEndian), this.offset += 4, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 64-bit floating number and move pointer forward by 8
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeFloat64(i) {
+    return this.ensureAvailable(8), this._data.setFloat64(this.offset, i, this.littleEndian), this.offset += 8, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 64-bit signed bigint and move pointer forward by 8
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeBigInt64(i) {
+    return this.ensureAvailable(8), this._data.setBigInt64(this.offset, i, this.littleEndian), this.offset += 8, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write `value` as a 64-bit unsigned bigint and move pointer forward by 8
+   * bytes.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeBigUint64(i) {
+    return this.ensureAvailable(8), this._data.setBigUint64(this.offset, i, this.littleEndian), this.offset += 8, this._updateLastWrittenByte(), this;
+  }
+  /**
+   * Write the charCode of `str`'s first character as an 8-bit unsigned integer
+   * and move pointer forward by 1 byte.
+   * @param str - The character to write.
+   * @returns This.
+   */
+  writeChar(i) {
+    return this.writeUint8(i.charCodeAt(0));
+  }
+  /**
+   * Write the charCodes of all `str`'s characters as 8-bit unsigned integers
+   * and move pointer forward by `str.length` bytes.
+   * @param str - The characters to write.
+   * @returns This.
+   */
+  writeChars(i) {
+    for (let e = 0; e < i.length; e++)
+      this.writeUint8(i.charCodeAt(e));
+    return this;
+  }
+  /**
+   * UTF-8 encode and write `str` to the current pointer offset and move pointer
+   * forward according to the encoded length.
+   * @param str - The string to write.
+   * @returns This.
+   */
+  writeUtf8(i) {
+    return this.writeBytes(Re(i));
+  }
+  /**
+   * Export a Uint8Array view of the internal buffer.
+   * The view starts at the byte offset and its length
+   * is calculated to stop at the last written byte or the original length.
+   * @returns A new Uint8Array view.
+   */
+  toArray() {
+    return new Uint8Array(this.buffer, this.byteOffset, this.lastWrittenByte);
+  }
+  /**
+   *  Get the total number of bytes written so far, regardless of the current offset.
+   * @returns - Total number of bytes.
+   */
+  getWrittenByteLength() {
+    return this.lastWrittenByte - this.byteOffset;
+  }
+  /**
+   * Update the last written byte offset
+   * @private
+   */
+  _updateLastWrittenByte() {
+    this.offset > this.lastWrittenByte && (this.lastWrittenByte = this.offset);
+  }
+}
+const Ne = 4, Wt = 0, Pt = 1, Ce = 2;
+function Y(t) {
+  let i = t.length;
+  for (; --i >= 0; )
+    t[i] = 0;
+}
+const Ze = 0, ie = 1, Fe = 2, Me = 3, $e = 258, Ot = 29, lt = 256, et = lt + 1 + Ot, W = 30, Bt = 19, ne = 2 * et + 1, B = 15, yt = 16, He = 7, Nt = 256, ae = 16, re = 17, le = 18, Tt = (
+  /* 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])
+), _t = (
+  /* 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])
+), We = (
+  /* 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])
+), oe = new Uint8Array([16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15]), Pe = 512, S = new Array((et + 2) * 2);
+Y(S);
+const Q = new Array(W * 2);
+Y(Q);
+const it = new Array(Pe);
+Y(it);
+const nt = new Array($e - Me + 1);
+Y(nt);
+const Ct = new Array(Ot);
+Y(Ct);
+const ft = new Array(W);
+Y(ft);
+function xt(t, i, e, n, a) {
+  this.static_tree = t, this.extra_bits = i, this.extra_base = e, this.elems = n, this.max_length = a, this.has_stree = t && t.length;
+}
+let he, _e, se;
+function Et(t, i) {
+  this.dyn_tree = t, this.max_code = 0, this.stat_desc = i;
+}
+const fe = (t) => t < 256 ? it[t] : it[256 + (t >>> 7)], at = (t, i) => {
+  t.pending_buf[t.pending++] = i & 255, t.pending_buf[t.pending++] = i >>> 8 & 255;
+}, w = (t, i, e) => {
+  t.bi_valid > yt - e ? (t.bi_buf |= i << t.bi_valid & 65535, at(t, t.bi_buf), t.bi_buf = i >> yt - t.bi_valid, t.bi_valid += e - yt) : (t.bi_buf |= i << t.bi_valid & 65535, t.bi_valid += e);
+}, A = (t, i, e) => {
+  w(
+    t,
+    e[i * 2],
+    e[i * 2 + 1]
+    /*.Len*/
+  );
+}, de = (t, i) => {
+  let e = 0;
+  do
+    e |= t & 1, t >>>= 1, e <<= 1;
+  while (--i > 0);
+  return e >>> 1;
+}, Ke = (t) => {
+  t.bi_valid === 16 ? (at(t, t.bi_buf), t.bi_buf = 0, t.bi_valid = 0) : t.bi_valid >= 8 && (t.pending_buf[t.pending++] = t.bi_buf & 255, t.bi_buf >>= 8, t.bi_valid -= 8);
+}, Ye = (t, i) => {
+  const e = i.dyn_tree, n = i.max_code, a = i.stat_desc.static_tree, r = i.stat_desc.has_stree, l = i.stat_desc.extra_bits, h = i.stat_desc.extra_base, o = i.stat_desc.max_length;
+  let _, u, c, d, E, k, z = 0;
+  for (d = 0; d <= B; d++)
+    t.bl_count[d] = 0;
+  for (e[t.heap[t.heap_max] * 2 + 1] = 0, _ = t.heap_max + 1; _ < ne; _++)
+    u = t.heap[_], d = e[e[u * 2 + 1] * 2 + 1] + 1, d > o && (d = o, z++), e[u * 2 + 1] = d, !(u > n) && (t.bl_count[d]++, E = 0, u >= h && (E = l[u - h]), k = e[u * 2], t.opt_len += k * (d + E), r && (t.static_len += k * (a[u * 2 + 1] + E)));
+  if (z !== 0) {
+    do {
+      for (d = o - 1; t.bl_count[d] === 0; )
+        d--;
+      t.bl_count[d]--, t.bl_count[d + 1] += 2, t.bl_count[o]--, z -= 2;
+    } while (z > 0);
+    for (d = o; d !== 0; d--)
+      for (u = t.bl_count[d]; u !== 0; )
+        c = t.heap[--_], !(c > n) && (e[c * 2 + 1] !== d && (t.opt_len += (d - e[c * 2 + 1]) * e[c * 2], e[c * 2 + 1] = d), u--);
+  }
+}, ce = (t, i, e) => {
+  const n = new Array(B + 1);
+  let a = 0, r, l;
+  for (r = 1; r <= B; r++)
+    a = a + e[r - 1] << 1, n[r] = a;
+  for (l = 0; l <= i; l++) {
+    let h = t[l * 2 + 1];
+    h !== 0 && (t[l * 2] = de(n[h]++, h));
+  }
+}, Xe = () => {
+  let t, i, e, n, a;
+  const r = new Array(B + 1);
+  for (e = 0, n = 0; n < Ot - 1; n++)
+    for (Ct[n] = e, t = 0; t < 1 << Tt[n]; t++)
+      nt[e++] = n;
+  for (nt[e - 1] = n, a = 0, n = 0; n < 16; n++)
+    for (ft[n] = a, t = 0; t < 1 << _t[n]; t++)
+      it[a++] = n;
+  for (a >>= 7; n < W; n++)
+    for (ft[n] = a << 7, t = 0; t < 1 << _t[n] - 7; t++)
+      it[256 + a++] = n;
+  for (i = 0; i <= B; i++)
+    r[i] = 0;
+  for (t = 0; t <= 143; )
+    S[t * 2 + 1] = 8, t++, r[8]++;
+  for (; t <= 255; )
+    S[t * 2 + 1] = 9, t++, r[9]++;
+  for (; t <= 279; )
+    S[t * 2 + 1] = 7, t++, r[7]++;
+  for (; t <= 287; )
+    S[t * 2 + 1] = 8, t++, r[8]++;
+  for (ce(S, et + 1, r), t = 0; t < W; t++)
+    Q[t * 2 + 1] = 5, Q[t * 2] = de(t, 5);
+  he = new xt(S, Tt, lt + 1, et, B), _e = new xt(Q, _t, 0, W, B), se = new xt(new Array(0), We, 0, Bt, He);
+}, ue = (t) => {
+  let i;
+  for (i = 0; i < et; i++)
+    t.dyn_ltree[i * 2] = 0;
+  for (i = 0; i < W; i++)
+    t.dyn_dtree[i * 2] = 0;
+  for (i = 0; i < Bt; i++)
+    t.bl_tree[i * 2] = 0;
+  t.dyn_ltree[Nt * 2] = 1, t.opt_len = t.static_len = 0, t.sym_next = t.matches = 0;
+}, ge = (t) => {
+  t.bi_valid > 8 ? at(t, t.bi_buf) : t.bi_valid > 0 && (t.pending_buf[t.pending++] = t.bi_buf), t.bi_buf = 0, t.bi_valid = 0;
+}, Kt = (t, i, e, n) => {
+  const a = i * 2, r = e * 2;
+  return t[a] < t[r] || t[a] === t[r] && n[i] <= n[e];
+}, vt = (t, i, e) => {
+  const n = t.heap[e];
+  let a = e << 1;
+  for (; a <= t.heap_len && (a < t.heap_len && Kt(i, t.heap[a + 1], t.heap[a], t.depth) && a++, !Kt(i, n, t.heap[a], t.depth)); )
+    t.heap[e] = t.heap[a], e = a, a <<= 1;
+  t.heap[e] = n;
+}, Yt = (t, i, e) => {
+  let n, a, r = 0, l, h;
+  if (t.sym_next !== 0)
+    do
+      n = t.pending_buf[t.sym_buf + r++] & 255, n += (t.pending_buf[t.sym_buf + r++] & 255) << 8, a = t.pending_buf[t.sym_buf + r++], n === 0 ? A(t, a, i) : (l = nt[a], A(t, l + lt + 1, i), h = Tt[l], h !== 0 && (a -= Ct[l], w(t, a, h)), n--, l = fe(n), A(t, l, e), h = _t[l], h !== 0 && (n -= ft[l], w(t, n, h)));
+    while (r < t.sym_next);
+  A(t, Nt, i);
+}, kt = (t, i) => {
+  const e = i.dyn_tree, n = i.stat_desc.static_tree, a = i.stat_desc.has_stree, r = i.stat_desc.elems;
+  let l, h, o = -1, _;
+  for (t.heap_len = 0, t.heap_max = ne, l = 0; l < r; l++)
+    e[l * 2] !== 0 ? (t.heap[++t.heap_len] = o = l, t.depth[l] = 0) : e[l * 2 + 1] = 0;
+  for (; t.heap_len < 2; )
+    _ = t.heap[++t.heap_len] = o < 2 ? ++o : 0, e[_ * 2] = 1, t.depth[_] = 0, t.opt_len--, a && (t.static_len -= n[_ * 2 + 1]);
+  for (i.max_code = o, l = t.heap_len >> 1; l >= 1; l--)
+    vt(t, e, l);
+  _ = r;
+  do
+    l = t.heap[
+      1
+      /*SMALLEST*/
+    ], t.heap[
+      1
+      /*SMALLEST*/
+    ] = t.heap[t.heap_len--], vt(
+      t,
+      e,
+      1
+      /*SMALLEST*/
+    ), h = t.heap[
+      1
+      /*SMALLEST*/
+    ], t.heap[--t.heap_max] = l, t.heap[--t.heap_max] = h, e[_ * 2] = e[l * 2] + e[h * 2], t.depth[_] = (t.depth[l] >= t.depth[h] ? t.depth[l] : t.depth[h]) + 1, e[l * 2 + 1] = e[h * 2 + 1] = _, t.heap[
+      1
+      /*SMALLEST*/
+    ] = _++, vt(
+      t,
+      e,
+      1
+      /*SMALLEST*/
+    );
+  while (t.heap_len >= 2);
+  t.heap[--t.heap_max] = t.heap[
+    1
+    /*SMALLEST*/
+  ], Ye(t, i), ce(e, o, t.bl_count);
+}, Xt = (t, i, e) => {
+  let n, a = -1, r, l = i[1], h = 0, o = 7, _ = 4;
+  for (l === 0 && (o = 138, _ = 3), i[(e + 1) * 2 + 1] = 65535, n = 0; n <= e; n++)
+    r = l, l = i[(n + 1) * 2 + 1], !(++h < o && r === l) && (h < _ ? t.bl_tree[r * 2] += h : r !== 0 ? (r !== a && t.bl_tree[r * 2]++, t.bl_tree[ae * 2]++) : h <= 10 ? t.bl_tree[re * 2]++ : t.bl_tree[le * 2]++, h = 0, a = r, l === 0 ? (o = 138, _ = 3) : r === l ? (o = 6, _ = 3) : (o = 7, _ = 4));
+}, Gt = (t, i, e) => {
+  let n, a = -1, r, l = i[1], h = 0, o = 7, _ = 4;
+  for (l === 0 && (o = 138, _ = 3), n = 0; n <= e; n++)
+    if (r = l, l = i[(n + 1) * 2 + 1], !(++h < o && r === l)) {
+      if (h < _)
+        do
+          A(t, r, t.bl_tree);
+        while (--h !== 0);
+      else r !== 0 ? (r !== a && (A(t, r, t.bl_tree), h--), A(t, ae, t.bl_tree), w(t, h - 3, 2)) : h <= 10 ? (A(t, re, t.bl_tree), w(t, h - 3, 3)) : (A(t, le, t.bl_tree), w(t, h - 11, 7));
+      h = 0, a = r, l === 0 ? (o = 138, _ = 3) : r === l ? (o = 6, _ = 3) : (o = 7, _ = 4);
+    }
+}, Ge = (t) => {
+  let i;
+  for (Xt(t, t.dyn_ltree, t.l_desc.max_code), Xt(t, t.dyn_dtree, t.d_desc.max_code), kt(t, t.bl_desc), i = Bt - 1; i >= 3 && t.bl_tree[oe[i] * 2 + 1] === 0; i--)
+    ;
+  return t.opt_len += 3 * (i + 1) + 5 + 5 + 4, i;
+}, je = (t, i, e, n) => {
+  let a;
+  for (w(t, i - 257, 5), w(t, e - 1, 5), w(t, n - 4, 4), a = 0; a < n; a++)
+    w(t, t.bl_tree[oe[a] * 2 + 1], 3);
+  Gt(t, t.dyn_ltree, i - 1), Gt(t, t.dyn_dtree, e - 1);
+}, Ve = (t) => {
+  let i = 4093624447, e;
+  for (e = 0; e <= 31; e++, i >>>= 1)
+    if (i & 1 && t.dyn_ltree[e * 2] !== 0)
+      return Wt;
+  if (t.dyn_ltree[18] !== 0 || t.dyn_ltree[20] !== 0 || t.dyn_ltree[26] !== 0)
+    return Pt;
+  for (e = 32; e < lt; e++)
+    if (t.dyn_ltree[e * 2] !== 0)
+      return Pt;
+  return Wt;
+};
+let jt = !1;
+const qe = (t) => {
+  jt || (Xe(), jt = !0), t.l_desc = new Et(t.dyn_ltree, he), t.d_desc = new Et(t.dyn_dtree, _e), t.bl_desc = new Et(t.bl_tree, se), t.bi_buf = 0, t.bi_valid = 0, ue(t);
+}, pe = (t, i, e, n) => {
+  w(t, (Ze << 1) + (n ? 1 : 0), 3), ge(t), at(t, e), at(t, ~e), e && t.pending_buf.set(t.window.subarray(i, i + e), t.pending), t.pending += e;
+}, Je = (t) => {
+  w(t, ie << 1, 3), A(t, Nt, S), Ke(t);
+}, Qe = (t, i, e, n) => {
+  let a, r, l = 0;
+  t.level > 0 ? (t.strm.data_type === Ce && (t.strm.data_type = Ve(t)), kt(t, t.l_desc), kt(t, t.d_desc), l = Ge(t), a = t.opt_len + 3 + 7 >>> 3, r = t.static_len + 3 + 7 >>> 3, r <= a && (a = r)) : a = r = e + 5, e + 4 <= a && i !== -1 ? pe(t, i, e, n) : t.strategy === Ne || r === a ? (w(t, (ie << 1) + (n ? 1 : 0), 3), Yt(t, S, Q)) : (w(t, (Fe << 1) + (n ? 1 : 0), 3), je(t, t.l_desc.max_code + 1, t.d_desc.max_code + 1, l + 1), Yt(t, t.dyn_ltree, t.dyn_dtree)), ue(t), n && ge(t);
+}, ti = (t, i, e) => (t.pending_buf[t.sym_buf + t.sym_next++] = i, t.pending_buf[t.sym_buf + t.sym_next++] = i >> 8, t.pending_buf[t.sym_buf + t.sym_next++] = e, i === 0 ? t.dyn_ltree[e * 2]++ : (t.matches++, i--, t.dyn_ltree[(nt[e] + lt + 1) * 2]++, t.dyn_dtree[fe(i) * 2]++), t.sym_next === t.sym_end);
+var ei = qe, ii = pe, ni = Qe, ai = ti, ri = Je, li = {
+  _tr_init: ei,
+  _tr_stored_block: ii,
+  _tr_flush_block: ni,
+  _tr_tally: ai,
+  _tr_align: ri
+};
+const oi = (t, i, e, n) => {
+  let a = t & 65535 | 0, r = t >>> 16 & 65535 | 0, l = 0;
+  for (; e !== 0; ) {
+    l = e > 2e3 ? 2e3 : e, e -= l;
+    do
+      a = a + i[n++] | 0, r = r + a | 0;
+    while (--l);
+    a %= 65521, r %= 65521;
+  }
+  return a | r << 16 | 0;
+};
+var we = oi;
+const hi = () => {
+  let t, i = [];
+  for (var e = 0; e < 256; e++) {
+    t = e;
+    for (var n = 0; n < 8; n++)
+      t = t & 1 ? 3988292384 ^ t >>> 1 : t >>> 1;
+    i[e] = t;
+  }
+  return i;
+}, _i = new Uint32Array(hi()), si = (t, i, e, n) => {
+  const a = _i, r = n + e;
+  t ^= -1;
+  for (let l = n; l < r; l++)
+    t = t >>> 8 ^ a[(t ^ i[l]) & 255];
+  return t ^ -1;
+};
+var U = si, dt = {
+  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) */
+}, be = {
+  /* 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,
+  /* 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_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_BUF_ERROR: -5,
+  Z_DEFAULT_COMPRESSION: -1,
+  Z_FILTERED: 1,
+  Z_HUFFMAN_ONLY: 2,
+  Z_RLE: 3,
+  Z_FIXED: 4,
+  Z_DEFAULT_STRATEGY: 0,
+  //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: fi, _tr_stored_block: St, _tr_flush_block: di, _tr_tally: I, _tr_align: ci } = li, {
+  Z_NO_FLUSH: R,
+  Z_PARTIAL_FLUSH: ui,
+  Z_FULL_FLUSH: gi,
+  Z_FINISH: x,
+  Z_BLOCK: Vt,
+  Z_OK: g,
+  Z_STREAM_END: qt,
+  Z_STREAM_ERROR: m,
+  Z_DATA_ERROR: pi,
+  Z_BUF_ERROR: At,
+  Z_DEFAULT_COMPRESSION: wi,
+  Z_FILTERED: bi,
+  Z_HUFFMAN_ONLY: ht,
+  Z_RLE: yi,
+  Z_FIXED: xi,
+  Z_DEFAULT_STRATEGY: Ei,
+  Z_UNKNOWN: vi,
+  Z_DEFLATED: ut
+} = be, Ai = 9, mi = 15, Ti = 8, ki = 29, Si = 256, zt = Si + 1 + ki, zi = 30, Ui = 19, Li = 2 * zt + 1, Di = 15, s = 3, D = 258, T = D + s + 1, Ii = 32, P = 42, Zt = 57, Ut = 69, Lt = 73, Dt = 91, It = 103, N = 113, q = 666, p = 1, X = 2, Z = 3, G = 4, Ri = 3, C = (t, i) => (t.msg = dt[i], i), Jt = (t) => t * 2 - (t > 4 ? 9 : 0), L = (t) => {
+  let i = t.length;
+  for (; --i >= 0; )
+    t[i] = 0;
+}, Oi = (t) => {
+  let i, e, n, a = t.w_size;
+  i = t.hash_size, n = i;
+  do
+    e = t.head[--n], t.head[n] = e >= a ? e - a : 0;
+  while (--i);
+  i = a, n = i;
+  do
+    e = t.prev[--n], t.prev[n] = e >= a ? e - a : 0;
+  while (--i);
+};
+let Ft = (t, i, e) => (i << t.hash_shift ^ e) & t.hash_mask;
+const F = (t, i) => {
+  let e;
+  if (t.legacy_hash)
+    e = t.ins_h = Ft(t, t.ins_h, t.window[i + s - 1]);
+  else {
+    const a = t.window, r = a[i] | a[i + 1] << 8 | a[i + 2] << 16 | a[i + 3] << 24;
+    e = t.ins_h = Math.imul(r, 66521) + 66521 >>> 16 & t.hash_mask;
+  }
+  const n = t.prev[i & t.w_mask] = t.head[e];
+  return t.head[e] = i, n;
+}, b = (t) => {
+  const i = t.state;
+  let e = i.pending;
+  e > t.avail_out && (e = t.avail_out), e !== 0 && (t.output.set(i.pending_buf.subarray(i.pending_out, i.pending_out + e), t.next_out), t.next_out += e, i.pending_out += e, t.total_out += e, t.avail_out -= e, i.pending -= e, i.pending === 0 && (i.pending_out = 0));
+}, y = (t, i) => {
+  di(t, t.block_start >= 0 ? t.block_start : -1, t.strstart - t.block_start, i), t.block_start = t.strstart, b(t.strm);
+}, f = (t, i) => {
+  t.pending_buf[t.pending++] = i;
+}, j = (t, i) => {
+  t.pending_buf[t.pending++] = i >>> 8 & 255, t.pending_buf[t.pending++] = i & 255;
+}, Rt = (t, i, e, n) => {
+  let a = t.avail_in;
+  return a > n && (a = n), a === 0 ? 0 : (t.avail_in -= a, i.set(t.input.subarray(t.next_in, t.next_in + a), e), t.state.wrap === 1 ? t.adler = we(t.adler, i, a, e) : t.state.wrap === 2 && (t.adler = U(t.adler, i, a, e)), t.next_in += a, t.total_in += a, a);
+}, ye = (t, i) => {
+  let e = t.max_chain_length, n = t.strstart, a, r, l = t.prev_length, h = t.nice_match;
+  const o = t.strstart > t.w_size - T ? t.strstart - (t.w_size - T) : 0, _ = t.window, u = t.w_mask, c = t.prev, d = t.strstart + D;
+  let E = _[n + l - 1], k = _[n + l];
+  t.prev_length >= t.good_match && (e >>= 2), h > t.lookahead && (h = t.lookahead);
+  do
+    if (a = i, !(_[a + l] !== k || _[a + l - 1] !== E || _[a] !== _[n] || _[++a] !== _[n + 1])) {
+      n += 2, a++;
+      do
+        ;
+      while (_[++n] === _[++a] && _[++n] === _[++a] && _[++n] === _[++a] && _[++n] === _[++a] && _[++n] === _[++a] && _[++n] === _[++a] && _[++n] === _[++a] && _[++n] === _[++a] && n < d);
+      if (r = D - (d - n), n = d - D, r > l) {
+        if (t.match_start = i, l = r, r >= h)
+          break;
+        E = _[n + l - 1], k = _[n + l];
+      }
+    }
+  while ((i = c[i & u]) > o && --e !== 0);
+  return l <= t.lookahead ? l : t.lookahead;
+}, K = (t) => {
+  const i = t.w_size;
+  let e, n, a;
+  do {
+    if (n = t.window_size - t.lookahead - t.strstart, t.strstart >= i + (i - T) && (t.window.set(t.window.subarray(i, i + i - n), 0), t.match_start -= i, t.strstart -= i, t.block_start -= i, t.insert > t.strstart && (t.insert = t.strstart), Oi(t), n += i), t.strm.avail_in === 0)
+      break;
+    if (e = Rt(t.strm, t.window, t.strstart + t.lookahead, n), t.lookahead += e, t.legacy_hash) {
+      if (t.lookahead + t.insert >= s)
+        for (a = t.strstart - t.insert, t.ins_h = t.window[a], t.ins_h = Ft(t, t.ins_h, t.window[a + 1]); t.insert && (F(t, a), a++, t.insert--, !(t.lookahead + t.insert < s)); )
+          ;
+    } else if (t.lookahead + t.insert > s)
+      for (a = t.strstart - t.insert; t.insert && (F(t, a), a++, t.insert--, !(t.lookahead + t.insert <= s)); )
+        ;
+  } while (t.lookahead < T && t.strm.avail_in !== 0);
+}, xe = (t, i) => {
+  let e = t.pending_buf_size - 5 > t.w_size ? t.w_size : t.pending_buf_size - 5, n, a, r, l = 0, h = t.strm.avail_in;
+  do {
+    if (n = 65535, r = t.bi_valid + 42 >> 3, t.strm.avail_out < r || (r = t.strm.avail_out - r, a = t.strstart - t.block_start, n > a + t.strm.avail_in && (n = a + t.strm.avail_in), n > r && (n = r), n < e && (n === 0 && i !== x || i === R || n !== a + t.strm.avail_in)))
+      break;
+    l = i === x && n === a + t.strm.avail_in ? 1 : 0, St(t, 0, 0, l), t.pending_buf[t.pending - 4] = n, t.pending_buf[t.pending - 3] = n >> 8, t.pending_buf[t.pending - 2] = ~n, t.pending_buf[t.pending - 1] = ~n >> 8, b(t.strm), a && (a > n && (a = n), t.strm.output.set(t.window.subarray(t.block_start, t.block_start + a), t.strm.next_out), t.strm.next_out += a, t.strm.avail_out -= a, t.strm.total_out += a, t.block_start += a, n -= a), n && (Rt(t.strm, t.strm.output, t.strm.next_out, n), t.strm.next_out += n, t.strm.avail_out -= n, t.strm.total_out += n);
+  } while (l === 0);
+  return h -= t.strm.avail_in, h && (h >= t.w_size ? (t.matches = 2, t.window.set(t.strm.input.subarray(t.strm.next_in - t.w_size, t.strm.next_in), 0), t.strstart = t.w_size, t.insert = t.strstart) : (t.window_size - t.strstart <= h && (t.strstart -= t.w_size, t.window.set(t.window.subarray(t.w_size, t.w_size + t.strstart), 0), t.matches < 2 && t.matches++, t.insert > t.strstart && (t.insert = t.strstart)), t.window.set(t.strm.input.subarray(t.strm.next_in - h, t.strm.next_in), t.strstart), t.strstart += h, t.insert += h > t.w_size - t.insert ? t.w_size - t.insert : h), t.block_start = t.strstart), t.high_water < t.strstart && (t.high_water = t.strstart), l ? G : i !== R && i !== x && t.strm.avail_in === 0 && t.strstart === t.block_start ? X : (r = t.window_size - t.strstart, t.strm.avail_in > r && t.block_start >= t.w_size && (t.block_start -= t.w_size, t.strstart -= t.w_size, t.window.set(t.window.subarray(t.w_size, t.w_size + t.strstart), 0), t.matches < 2 && t.matches++, r += t.w_size, t.insert > t.strstart && (t.insert = t.strstart)), r > t.strm.avail_in && (r = t.strm.avail_in), r && (Rt(t.strm, t.window, t.strstart, r), t.strstart += r, t.insert += r > t.w_size - t.insert ? t.w_size - t.insert : r), t.high_water < t.strstart && (t.high_water = t.strstart), r = t.bi_valid + 42 >> 3, r = t.pending_buf_size - r > 65535 ? 65535 : t.pending_buf_size - r, e = r > t.w_size ? t.w_size : r, a = t.strstart - t.block_start, (a >= e || (a || i === x) && i !== R && t.strm.avail_in === 0 && a <= r) && (n = a > r ? r : a, l = i === x && t.strm.avail_in === 0 && n === a ? 1 : 0, St(t, t.block_start, n, l), t.block_start += n, b(t.strm)), l ? Z : p);
+}, mt = (t, i) => {
+  let e, n;
+  for (; ; ) {
+    if (t.lookahead < T) {
+      if (K(t), t.lookahead < T && i === R)
+        return p;
+      if (t.lookahead === 0)
+        break;
+    }
+    if (e = 0, t.lookahead >= s && (e = F(t, t.strstart)), e !== 0 && t.strstart - e <= t.w_size - T && (t.match_length = ye(t, e)), t.match_length >= s)
+      if (n = I(t, t.strstart - t.match_start, t.match_length - s), t.lookahead -= t.match_length, t.match_length <= t.max_lazy_match && t.lookahead >= s) {
+        t.match_length--;
+        do
+          t.strstart++, e = F(t, t.strstart);
+        while (--t.match_length !== 0);
+        t.strstart++;
+      } else
+        t.strstart += t.match_length, t.match_length = 0, t.legacy_hash && (t.ins_h = t.window[t.strstart], t.ins_h = Ft(t, t.ins_h, t.window[t.strstart + 1]));
+    else
+      n = I(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++;
+    if (n && (y(t, !1), t.strm.avail_out === 0))
+      return p;
+  }
+  return t.insert = t.strstart < s - 1 ? t.strstart : s - 1, i === x ? (y(t, !0), t.strm.avail_out === 0 ? Z : G) : t.sym_next && (y(t, !1), t.strm.avail_out === 0) ? p : X;
+}, $ = (t, i) => {
+  let e, n, a;
+  for (; ; ) {
+    if (t.lookahead < T) {
+      if (K(t), t.lookahead < T && i === R)
+        return p;
+      if (t.lookahead === 0)
+        break;
+    }
+    if (e = 0, t.lookahead >= s && (e = F(t, t.strstart)), t.prev_length = t.match_length, t.prev_match = t.match_start, t.match_length = s - 1, e !== 0 && t.prev_length < t.max_lazy_match && t.strstart - e <= t.w_size - T && (t.match_length = ye(t, e), t.match_length <= 5 && (t.strategy === bi || t.match_length === s && t.strstart - t.match_start > 4096) && (t.match_length = s - 1)), t.prev_length >= s && t.match_length <= t.prev_length) {
+      a = t.strstart + t.lookahead - s, n = I(t, t.strstart - 1 - t.prev_match, t.prev_length - s), t.lookahead -= t.prev_length - 1, t.prev_length -= 2;
+      do
+        ++t.strstart <= a && (e = F(t, t.strstart));
+      while (--t.prev_length !== 0);
+      if (t.match_available = 0, t.match_length = s - 1, t.strstart++, n && (y(t, !1), t.strm.avail_out === 0))
+        return p;
+    } else if (t.match_available) {
+      if (n = I(t, 0, t.window[t.strstart - 1]), n && y(t, !1), t.strstart++, t.lookahead--, t.strm.avail_out === 0)
+        return p;
+    } else
+      t.match_available = 1, t.strstart++, t.lookahead--;
+  }
+  return t.match_available && (n = I(t, 0, t.window[t.strstart - 1]), t.match_available = 0), t.insert = t.strstart < s - 1 ? t.strstart : s - 1, i === x ? (y(t, !0), t.strm.avail_out === 0 ? Z : G) : t.sym_next && (y(t, !1), t.strm.avail_out === 0) ? p : X;
+}, Bi = (t, i) => {
+  let e, n, a, r;
+  const l = t.window;
+  for (; ; ) {
+    if (t.lookahead <= D) {
+      if (K(t), t.lookahead <= D && i === R)
+        return p;
+      if (t.lookahead === 0)
+        break;
+    }
+    if (t.match_length = 0, t.lookahead >= s && t.strstart > 0 && (a = t.strstart - 1, n = l[a], n === l[++a] && n === l[++a] && n === l[++a])) {
+      r = t.strstart + D;
+      do
+        ;
+      while (n === l[++a] && n === l[++a] && n === l[++a] && n === l[++a] && n === l[++a] && n === l[++a] && n === l[++a] && n === l[++a] && a < r);
+      t.match_length = D - (r - a), t.match_length > t.lookahead && (t.match_length = t.lookahead);
+    }
+    if (t.match_length >= s ? (e = I(t, 1, t.match_length - s), t.lookahead -= t.match_length, t.strstart += t.match_length, t.match_length = 0) : (e = I(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++), e && (y(t, !1), t.strm.avail_out === 0))
+      return p;
+  }
+  return t.insert = 0, i === x ? (y(t, !0), t.strm.avail_out === 0 ? Z : G) : t.sym_next && (y(t, !1), t.strm.avail_out === 0) ? p : X;
+}, Ni = (t, i) => {
+  let e;
+  for (; ; ) {
+    if (t.lookahead === 0 && (K(t), t.lookahead === 0)) {
+      if (i === R)
+        return p;
+      break;
+    }
+    if (t.match_length = 0, e = I(t, 0, t.window[t.strstart]), t.lookahead--, t.strstart++, e && (y(t, !1), t.strm.avail_out === 0))
+      return p;
+  }
+  return t.insert = 0, i === x ? (y(t, !0), t.strm.avail_out === 0 ? Z : G) : t.sym_next && (y(t, !1), t.strm.avail_out === 0) ? p : X;
+};
+function v(t, i, e, n, a) {
+  this.good_length = t, this.max_lazy = i, this.nice_length = e, this.max_chain = n, this.func = a;
+}
+const J = [
+  /*      good lazy nice chain */
+  new v(0, 0, 0, 0, xe),
+  /* 0 store only */
+  new v(4, 4, 8, 4, mt),
+  /* 1 max speed, no lazy matches */
+  new v(4, 5, 16, 8, mt),
+  /* 2 */
+  new v(4, 6, 32, 32, mt),
+  /* 3 */
+  new v(4, 4, 16, 16, $),
+  /* 4 lazy matches */
+  new v(8, 16, 32, 32, $),
+  /* 5 */
+  new v(8, 16, 128, 128, $),
+  /* 6 */
+  new v(8, 32, 128, 256, $),
+  /* 7 */
+  new v(32, 128, 258, 1024, $),
+  /* 8 */
+  new v(32, 258, 258, 4096, $)
+  /* 9 max compression */
+], Ci = (t) => {
+  t.window_size = 2 * t.w_size, L(t.head), t.max_lazy_match = J[t.level].max_lazy, t.good_match = J[t.level].good_length, t.nice_match = J[t.level].nice_length, t.max_chain_length = J[t.level].max_chain, t.strstart = 0, t.block_start = 0, t.lookahead = 0, t.insert = 0, t.match_length = t.prev_length = s - 1, t.match_available = 0, t.ins_h = 0;
+};
+function Zi() {
+  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.legacy_hash = 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(Li * 2), this.dyn_dtree = new Uint16Array((2 * zi + 1) * 2), this.bl_tree = new Uint16Array((2 * Ui + 1) * 2), L(this.dyn_ltree), L(this.dyn_dtree), L(this.bl_tree), this.l_desc = null, this.d_desc = null, this.bl_desc = null, this.bl_count = new Uint16Array(Di + 1), this.heap = new Uint16Array(2 * zt + 1), L(this.heap), this.heap_len = 0, this.heap_max = 0, this.depth = new Uint16Array(2 * zt + 1), L(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 ot = (t) => {
+  if (!t)
+    return 1;
+  const i = t.state;
+  return !i || i.strm !== t || i.status !== P && //#ifdef GZIP
+  i.status !== Zt && //#endif
+  i.status !== Ut && i.status !== Lt && i.status !== Dt && i.status !== It && i.status !== N && i.status !== q ? 1 : 0;
+}, Ee = (t) => {
+  if (ot(t))
+    return C(t, m);
+  t.total_in = t.total_out = 0, t.data_type = vi;
+  const i = t.state;
+  return i.pending = 0, i.pending_out = 0, i.wrap < 0 && (i.wrap = -i.wrap), i.status = //#ifdef GZIP
+  i.wrap === 2 ? Zt : (
+    //#endif
+    i.wrap ? P : N
+  ), t.adler = i.wrap === 2 ? 0 : 1, i.last_flush = -2, fi(i), g;
+}, ve = (t) => {
+  const i = Ee(t);
+  return i === g && Ci(t.state), i;
+}, Fi = (t, i) => ot(t) || t.state.wrap !== 2 ? m : (t.state.gzhead = i, g), Ae = (t, i, e, n, a, r, l) => {
+  if (!t)
+    return m;
+  let h = 1;
+  if (i === wi && (i = 6), n < 0 ? (h = 0, n = -n) : n > 15 && (h = 2, n -= 16), a < 1 || a > Ai || e !== ut || n < 8 || n > 15 || i < 0 || i > 9 || r < 0 || r > xi || n === 8 && h !== 1)
+    return C(t, m);
+  n === 8 && (n = 9);
+  const o = new Zi();
+  return t.state = o, o.strm = t, o.status = P, o.wrap = h, o.gzhead = null, o.w_bits = n, o.w_size = 1 << o.w_bits, o.w_mask = o.w_size - 1, o.legacy_hash = l ? 1 : 0, o.hash_bits = a + 7, !o.legacy_hash && o.hash_bits < 15 && (o.hash_bits = 15), o.hash_size = 1 << o.hash_bits, o.hash_mask = o.hash_size - 1, o.hash_shift = ~~((o.hash_bits + s - 1) / s), o.window = new Uint8Array(o.w_size * 2), o.head = new Uint16Array(o.hash_size), o.prev = new Uint16Array(o.w_size), o.lit_bufsize = 1 << a + 6, o.pending_buf_size = o.lit_bufsize * 4, o.pending_buf = new Uint8Array(o.pending_buf_size), o.sym_buf = o.lit_bufsize, o.sym_end = (o.lit_bufsize - 1) * 3, o.level = i, o.strategy = r, o.method = e, ve(t);
+}, Mi = (t, i) => Ae(t, i, ut, mi, Ti, Ei), $i = (t, i) => {
+  if (ot(t) || i > Vt || i < 0)
+    return t ? C(t, m) : m;
+  const e = t.state;
+  if (!t.output || t.avail_in !== 0 && !t.input || e.status === q && i !== x)
+    return C(t, t.avail_out === 0 ? At : m);
+  const n = e.last_flush;
+  if (e.last_flush = i, e.pending !== 0) {
+    if (b(t), t.avail_out === 0)
+      return e.last_flush = -1, g;
+  } else if (t.avail_in === 0 && Jt(i) <= Jt(n) && i !== x)
+    return C(t, At);
+  if (e.status === q && t.avail_in !== 0)
+    return C(t, At);
+  if (e.status === P && e.wrap === 0 && (e.status = N), e.status === P) {
+    let a = ut + (e.w_bits - 8 << 4) << 8, r = -1;
+    if (e.strategy >= ht || e.level < 2 ? r = 0 : e.level < 6 ? r = 1 : e.level === 6 ? r = 2 : r = 3, a |= r << 6, e.strstart !== 0 && (a |= Ii), a += 31 - a % 31, j(e, a), e.strstart !== 0 && (j(e, t.adler >>> 16), j(e, t.adler & 65535)), t.adler = 1, e.status = N, b(t), e.pending !== 0)
+      return e.last_flush = -1, g;
+  }
+  if (e.status === Zt) {
+    if (t.adler = 0, f(e, 31), f(e, 139), f(e, 8), e.gzhead)
+      f(
+        e,
+        (e.gzhead.text ? 1 : 0) + (e.gzhead.hcrc ? 2 : 0) + (e.gzhead.extra ? 4 : 0) + (e.gzhead.name ? 8 : 0) + (e.gzhead.comment ? 16 : 0)
+      ), f(e, e.gzhead.time & 255), f(e, e.gzhead.time >> 8 & 255), f(e, e.gzhead.time >> 16 & 255), f(e, e.gzhead.time >> 24 & 255), f(e, e.level === 9 ? 2 : e.strategy >= ht || e.level < 2 ? 4 : 0), f(e, e.gzhead.os & 255), e.gzhead.extra && e.gzhead.extra.length && (f(e, e.gzhead.extra.length & 255), f(e, e.gzhead.extra.length >> 8 & 255)), e.gzhead.hcrc && (t.adler = U(t.adler, e.pending_buf, e.pending, 0)), e.gzindex = 0, e.status = Ut;
+    else if (f(e, 0), f(e, 0), f(e, 0), f(e, 0), f(e, 0), f(e, e.level === 9 ? 2 : e.strategy >= ht || e.level < 2 ? 4 : 0), f(e, Ri), e.status = N, b(t), e.pending !== 0)
+      return e.last_flush = -1, g;
+  }
+  if (e.status === Ut) {
+    if (e.gzhead.extra) {
+      let a = e.pending, r = (e.gzhead.extra.length & 65535) - e.gzindex;
+      for (; e.pending + r > e.pending_buf_size; ) {
+        let h = e.pending_buf_size - e.pending;
+        if (e.pending_buf.set(e.gzhead.extra.subarray(e.gzindex, e.gzindex + h), e.pending), e.pending = e.pending_buf_size, e.gzhead.hcrc && e.pending > a && (t.adler = U(t.adler, e.pending_buf, e.pending - a, a)), e.gzindex += h, b(t), e.pending !== 0)
+          return e.last_flush = -1, g;
+        a = 0, r -= h;
+      }
+      let l = new Uint8Array(e.gzhead.extra);
+      e.pending_buf.set(l.subarray(e.gzindex, e.gzindex + r), e.pending), e.pending += r, e.gzhead.hcrc && e.pending > a && (t.adler = U(t.adler, e.pending_buf, e.pending - a, a)), e.gzindex = 0;
+    }
+    e.status = Lt;
+  }
+  if (e.status === Lt) {
+    if (e.gzhead.name) {
+      let a = e.pending, r;
+      do {
+        if (e.pending === e.pending_buf_size) {
+          if (e.gzhead.hcrc && e.pending > a && (t.adler = U(t.adler, e.pending_buf, e.pending - a, a)), b(t), e.pending !== 0)
+            return e.last_flush = -1, g;
+          a = 0;
+        }
+        e.gzindex < e.gzhead.name.length ? r = e.gzhead.name.charCodeAt(e.gzindex++) & 255 : r = 0, f(e, r);
+      } while (r !== 0);
+      e.gzhead.hcrc && e.pending > a && (t.adler = U(t.adler, e.pending_buf, e.pending - a, a)), e.gzindex = 0;
+    }
+    e.status = Dt;
+  }
+  if (e.status === Dt) {
+    if (e.gzhead.comment) {
+      let a = e.pending, r;
+      do {
+        if (e.pending === e.pending_buf_size) {
+          if (e.gzhead.hcrc && e.pending > a && (t.adler = U(t.adler, e.pending_buf, e.pending - a, a)), b(t), e.pending !== 0)
+            return e.last_flush = -1, g;
+          a = 0;
+        }
+        e.gzindex < e.gzhead.comment.length ? r = e.gzhead.comment.charCodeAt(e.gzindex++) & 255 : r = 0, f(e, r);
+      } while (r !== 0);
+      e.gzhead.hcrc && e.pending > a && (t.adler = U(t.adler, e.pending_buf, e.pending - a, a));
+    }
+    e.status = It;
+  }
+  if (e.status === It) {
+    if (e.gzhead.hcrc) {
+      if (e.pending + 2 > e.pending_buf_size && (b(t), e.pending !== 0))
+        return e.last_flush = -1, g;
+      f(e, t.adler & 255), f(e, t.adler >> 8 & 255), t.adler = 0;
+    }
+    if (e.status = N, b(t), e.pending !== 0)
+      return e.last_flush = -1, g;
+  }
+  if (t.avail_in !== 0 || e.lookahead !== 0 || i !== R && e.status !== q) {
+    let a = e.level === 0 ? xe(e, i) : e.strategy === ht ? Ni(e, i) : e.strategy === yi ? Bi(e, i) : J[e.level].func(e, i);
+    if ((a === Z || a === G) && (e.status = q), a === p || a === Z)
+      return t.avail_out === 0 && (e.last_flush = -1), g;
+    if (a === X && (i === ui ? ci(e) : i !== Vt && (St(e, 0, 0, !1), i === gi && (L(e.head), e.lookahead === 0 && (e.strstart = 0, e.block_start = 0, e.insert = 0))), b(t), t.avail_out === 0))
+      return e.last_flush = -1, g;
+  }
+  return i !== x ? g : e.wrap <= 0 ? qt : (e.wrap === 2 ? (f(e, t.adler & 255), f(e, t.adler >> 8 & 255), f(e, t.adler >> 16 & 255), f(e, t.adler >> 24 & 255), f(e, t.total_in & 255), f(e, t.total_in >> 8 & 255), f(e, t.total_in >> 16 & 255), f(e, t.total_in >> 24 & 255)) : (j(e, t.adler >>> 16), j(e, t.adler & 65535)), b(t), e.wrap > 0 && (e.wrap = -e.wrap), e.pending !== 0 ? g : qt);
+}, Hi = (t) => {
+  if (ot(t))
+    return m;
+  const i = t.state.status;
+  return t.state = null, i === N ? C(t, pi) : g;
+}, Wi = (t, i) => {
+  let e = i.length;
+  if (ot(t))
+    return m;
+  const n = t.state, a = n.wrap;
+  if (a === 2 || a === 1 && n.status !== P || n.lookahead)
+    return m;
+  if (a === 1 && (t.adler = we(t.adler, i, e, 0)), n.wrap = 0, e >= n.w_size) {
+    a === 0 && (L(n.head), n.strstart = 0, n.block_start = 0, n.insert = 0);
+    let o = new Uint8Array(n.w_size);
+    o.set(i.subarray(e - n.w_size, e), 0), i = o, e = n.w_size;
+  }
+  const r = t.avail_in, l = t.next_in, h = t.input;
+  for (t.avail_in = e, t.next_in = 0, t.input = i, K(n); n.lookahead >= s; ) {
+    let o = n.strstart, _ = n.lookahead - (s - 1);
+    do
+      F(n, o), o++;
+    while (--_);
+    n.strstart = o, n.lookahead = s - 1, K(n);
+  }
+  return n.strstart += n.lookahead, n.block_start = n.strstart, n.insert = n.lookahead, n.lookahead = 0, n.match_length = n.prev_length = s - 1, n.match_available = 0, t.next_in = l, t.input = h, t.avail_in = r, n.wrap = a, g;
+};
+var Pi = Mi, Ki = Ae, Yi = ve, Xi = Ee, Gi = Fi, ji = $i, Vi = Hi, qi = Wi, Ji = "pako deflate (from Nodeca project)", tt = {
+  deflateInit: Pi,
+  deflateInit2: Ki,
+  deflateReset: Yi,
+  deflateResetKeep: Xi,
+  deflateSetHeader: Gi,
+  deflate: ji,
+  deflateEnd: Vi,
+  deflateSetDictionary: qi,
+  deflateInfo: Ji
+};
+const Qi = (t, i) => Object.prototype.hasOwnProperty.call(t, i);
+var tn = function(t) {
+  const i = Array.prototype.slice.call(arguments, 1);
+  for (; i.length; ) {
+    const e = i.shift();
+    if (e) {
+      if (typeof e != "object")
+        throw new TypeError(e + "must be non-object");
+      for (const n in e)
+        Qi(e, n) && (t[n] = e[n]);
+    }
+  }
+  return t;
+}, en = (t) => {
+  let i = 0;
+  for (let n = 0, a = t.length; n < a; n++)
+    i += t[n].length;
+  const e = new Uint8Array(i);
+  for (let n = 0, a = 0, r = t.length; n < r; n++) {
+    let l = t[n];
+    e.set(l, a), a += l.length;
+  }
+  return e;
+}, me = {
+  assign: tn,
+  flattenChunks: en
+};
+let Te = !0;
+try {
+  String.fromCharCode.apply(null, new Uint8Array(1));
+} catch {
+  Te = !1;
+}
+const rt = new Uint8Array(256);
+for (let t = 0; t < 256; t++)
+  rt[t] = t >= 252 ? 6 : t >= 248 ? 5 : t >= 240 ? 4 : t >= 224 ? 3 : t >= 192 ? 2 : 1;
+rt[254] = rt[255] = 1;
+var nn = (t) => {
+  if (typeof TextEncoder == "function" && TextEncoder.prototype.encode)
+    return new TextEncoder().encode(t);
+  let i, e, n, a, r, l = t.length, h = 0;
+  for (a = 0; a < l; a++)
+    e = t.charCodeAt(a), (e & 64512) === 55296 && a + 1 < l && (n = t.charCodeAt(a + 1), (n & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (n - 56320), a++)), h += e < 128 ? 1 : e < 2048 ? 2 : e < 65536 ? 3 : 4;
+  for (i = new Uint8Array(h), r = 0, a = 0; r < h; a++)
+    e = t.charCodeAt(a), (e & 64512) === 55296 && a + 1 < l && (n = t.charCodeAt(a + 1), (n & 64512) === 56320 && (e = 65536 + (e - 55296 << 10) + (n - 56320), a++)), e < 128 ? i[r++] = e : e < 2048 ? (i[r++] = 192 | e >>> 6, i[r++] = 128 | e & 63) : e < 65536 ? (i[r++] = 224 | e >>> 12, i[r++] = 128 | e >>> 6 & 63, i[r++] = 128 | e & 63) : (i[r++] = 240 | e >>> 18, i[r++] = 128 | e >>> 12 & 63, i[r++] = 128 | e >>> 6 & 63, i[r++] = 128 | e & 63);
+  return i;
+};
+const an = (t, i) => {
+  if (i < 65534 && t.subarray && Te)
+    return String.fromCharCode.apply(null, t.length === i ? t : t.subarray(0, i));
+  let e = "";
+  for (let n = 0; n < i; n++)
+    e += String.fromCharCode(t[n]);
+  return e;
+};
+var rn = (t, i) => {
+  const e = i || t.length;
+  if (typeof TextDecoder == "function" && TextDecoder.prototype.decode)
+    return new TextDecoder().decode(t.subarray(0, i));
+  let n, a;
+  const r = new Array(e * 2);
+  for (a = 0, n = 0; n < e; ) {
+    let l = t[n++];
+    if (l < 128) {
+      r[a++] = l;
+      continue;
+    }
+    let h = rt[l];
+    if (h > 4) {
+      r[a++] = 65533, n += h - 1;
+      continue;
+    }
+    for (l &= h === 2 ? 31 : h === 3 ? 15 : 7; h > 1 && n < e; )
+      l = l << 6 | t[n++] & 63, h--;
+    if (h > 1) {
+      r[a++] = 65533;
+      continue;
+    }
+    l < 65536 ? r[a++] = l : (l -= 65536, r[a++] = 55296 | l >> 10 & 1023, r[a++] = 56320 | l & 1023);
+  }
+  return an(r, a);
+}, ln = (t, i) => {
+  i = i || t.length, i > t.length && (i = t.length);
+  let e = i - 1;
+  for (; e >= 0 && (t[e] & 192) === 128; )
+    e--;
+  return e < 0 || e === 0 ? i : e + rt[t[e]] > i ? e : i;
+}, ke = {
+  string2buf: nn,
+  buf2string: rn,
+  utf8border: ln
+};
+function on() {
+  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 hn = on;
+const Se = Object.prototype.toString, {
+  Z_NO_FLUSH: _n,
+  Z_SYNC_FLUSH: sn,
+  Z_FULL_FLUSH: fn,
+  Z_FINISH: dn,
+  Z_OK: ct,
+  Z_STREAM_END: cn,
+  Z_DEFAULT_COMPRESSION: un,
+  Z_DEFAULT_STRATEGY: gn,
+  Z_DEFLATED: pn
+} = be, wn = {
+  level: un,
+  method: pn,
+  chunkSize: 16384,
+  windowBits: 15,
+  memLevel: 8,
+  strategy: gn,
+  legacyHash: !0
+};
+function gt(t) {
+  this.options = me.assign({}, wn, t || {});
+  let i = this.options;
+  i.raw && i.windowBits > 0 ? i.windowBits = -i.windowBits : i.gzip && i.windowBits > 0 && i.windowBits < 16 && (i.windowBits += 16), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new hn(), this.strm.avail_out = 0;
+  let e = tt.deflateInit2(
+    this.strm,
+    i.level,
+    i.method,
+    i.windowBits,
+    i.memLevel,
+    i.strategy,
+    i.legacyHash
+  );
+  if (e !== ct)
+    throw new Error(dt[e]);
+  if (i.header && tt.deflateSetHeader(this.strm, i.header), i.dictionary) {
+    let n;
+    if (typeof i.dictionary == "string" ? n = ke.string2buf(i.dictionary) : Se.call(i.dictionary) === "[object ArrayBuffer]" ? n = new Uint8Array(i.dictionary) : n = i.dictionary, e = tt.deflateSetDictionary(this.strm, n), e !== ct)
+      throw new Error(dt[e]);
+    this._dict_set = !0;
+  }
+}
+gt.prototype.push = function(t, i) {
+  const e = this.strm, n = this.options.chunkSize;
+  let a, r;
+  if (this.ended)
+    return !1;
+  for (i === ~~i ? r = i : r = i === !0 ? dn : _n, typeof t == "string" ? e.input = ke.string2buf(t) : Se.call(t) === "[object ArrayBuffer]" ? e.input = new Uint8Array(t) : e.input = t, e.next_in = 0, e.avail_in = e.input.length; ; ) {
+    if (e.avail_out === 0 && (e.output = new Uint8Array(n), e.next_out = 0, e.avail_out = n), (r === sn || r === fn) && e.avail_out <= 6) {
+      this.onData(e.output.subarray(0, e.next_out)), e.avail_out = 0;
+      continue;
+    }
+    if (a = tt.deflate(e, r), a === cn)
+      return e.next_out > 0 && this.onData(e.output.subarray(0, e.next_out)), a = tt.deflateEnd(this.strm), this.onEnd(a), this.ended = !0, a === ct;
+    if (e.avail_out === 0) {
+      this.onData(e.output);
+      continue;
+    }
+    if (r > 0 && e.next_out > 0) {
+      this.onData(e.output.subarray(0, e.next_out)), e.avail_out = 0;
+      continue;
+    }
+    if (e.avail_in === 0) break;
+  }
+  return !0;
+};
+gt.prototype.onData = function(t) {
+  this.chunks.push(t);
+};
+gt.prototype.onEnd = function(t) {
+  t === ct && (this.result = me.flattenChunks(this.chunks)), this.chunks = [], this.err = t, this.msg = this.strm.msg;
+};
+function bn(t, i) {
+  const e = new gt(i);
+  if (e.push(t, !0), e.err)
+    throw e.msg || dt[e.err];
+  return e.result;
+}
+var yn = bn, xn = {
+  deflate: yn
+};
+const { deflate: En } = xn;
+var vn = En;
+const ze = [];
+for (let t = 0; t < 256; t++) {
+  let i = t;
+  for (let e = 0; e < 8; e++)
+    i & 1 ? i = 3988292384 ^ i >>> 1 : i = i >>> 1;
+  ze[t] = i;
+}
+const Qt = 4294967295;
+function An(t, i, e) {
+  let n = t;
+  for (let a = 0; a < e; a++)
+    n = ze[(n ^ i[a]) & 255] ^ n >>> 8;
+  return n;
+}
+function mn(t, i) {
+  return (An(Qt, t, i) ^ Qt) >>> 0;
+}
+function H(t, i) {
+  t.writeUint32(mn(new Uint8Array(t.buffer, t.byteOffset + t.offset - i, i), i));
+}
+const Tn = new Uint16Array([255]), kn = new Uint8Array(Tn.buffer);
+kn[0];
+const Sn = new Uint16Array([255]), zn = new Uint8Array(Sn.buffer);
+zn[0];
+const Un = Uint8Array.of(137, 80, 78, 71, 13, 10, 26, 10);
+function Ln(t) {
+  t.writeBytes(Un);
+}
+const Dn = "tEXt", In = 0;
+new TextDecoder("latin1");
+function Rn(t) {
+  if (Ue(t), t.length === 0 || t.length > 79)
+    throw new Error("keyword length must be between 1 and 79");
+}
+const On = /^[\u0000-\u00FF]*$/;
+function Ue(t) {
+  if (!On.test(t))
+    throw new Error("invalid latin1 text");
+}
+function Bn(t, i, e) {
+  Rn(i), Ue(e);
+  const n = i.length + 1 + e.length;
+  t.writeUint32(n), t.writeChars(Dn), t.writeChars(i), t.writeByte(In), t.writeChars(e), H(t, n + 4);
+}
+const O = {
+  UNKNOWN: -1,
+  GREYSCALE: 0,
+  TRUECOLOUR: 2,
+  INDEXED_COLOUR: 3,
+  GREYSCALE_ALPHA: 4,
+  TRUECOLOUR_ALPHA: 6
+}, Nn = {
+  DEFLATE: 0
+}, Cn = {
+  ADAPTIVE: 0
+}, V = {
+  NO_INTERLACE: 0,
+  ADAM7: 1
+}, Zn = {
+  level: 3
+};
+class Fn extends st {
+  _png;
+  _zlibOptions;
+  _colorType;
+  _interlaceMethod;
+  constructor(i, e = {}) {
+    super(), this._colorType = O.UNKNOWN, this._zlibOptions = { ...Zn, ...e.zlib }, this._png = this._checkData(i), this._interlaceMethod = (e.interlace === "Adam7" ? V.ADAM7 : V.NO_INTERLACE) ?? V.NO_INTERLACE, this.setBigEndian();
+  }
+  encode() {
+    if (Ln(this), this.encodeIHDR(), this._png.palette && (this.encodePLTE(), this._png.palette[0].length === 4 && this.encodeTRNS()), this.encodeData(), this._png.text)
+      for (const [i, e] of Object.entries(this._png.text))
+        Bn(this, i, e);
+    return this.encodeIEND(), this.toArray();
+  }
+  // https://www.w3.org/TR/PNG/#11IHDR
+  encodeIHDR() {
+    this.writeUint32(13), this.writeChars("IHDR"), this.writeUint32(this._png.width), this.writeUint32(this._png.height), this.writeByte(this._png.depth), this.writeByte(this._colorType), this.writeByte(Nn.DEFLATE), this.writeByte(Cn.ADAPTIVE), this.writeByte(this._interlaceMethod), H(this, 17);
+  }
+  // https://www.w3.org/TR/PNG/#11IEND
+  encodeIEND() {
+    this.writeUint32(0), this.writeChars("IEND"), H(this, 4);
+  }
+  encodePLTE() {
+    const i = this._png.palette?.length * 3;
+    this.writeUint32(i), this.writeChars("PLTE");
+    for (const e of this._png.palette)
+      this.writeByte(e[0]), this.writeByte(e[1]), this.writeByte(e[2]);
+    H(this, 4 + i);
+  }
+  encodeTRNS() {
+    const i = this._png.palette.filter((e) => e.at(-1) !== 255);
+    this.writeUint32(i.length), this.writeChars("tRNS");
+    for (const e of i)
+      this.writeByte(e.at(-1));
+    H(this, 4 + i.length);
+  }
+  // https://www.w3.org/TR/PNG/#11IDAT
+  encodeIDAT(i) {
+    this.writeUint32(i.length), this.writeChars("IDAT"), this.writeBytes(i), H(this, i.length + 4);
+  }
+  encodeData() {
+    const { width: i, height: e, channels: n, depth: a, data: r } = this._png, l = a <= 8 ? Math.ceil(i * a / 8) * n : Math.ceil(i * a / 8 * n / 2), h = new st().setBigEndian();
+    let o = 0;
+    if (this._interlaceMethod === V.NO_INTERLACE)
+      for (let c = 0; c < e; c++)
+        h.writeByte(0), a === 16 ? o = Wn(r, h, l, o) : o = $n(r, h, l, o);
+    else this._interlaceMethod === V.ADAM7 && (o = Hn(this._png, r, h, o));
+    const _ = h.toArray(), u = vn(_, this._zlibOptions);
+    this.encodeIDAT(u);
+  }
+  _checkData(i) {
+    const { colorType: e, channels: n, depth: a } = Mn(i, i.palette), r = {
+      width: te(i.width, "width"),
+      height: te(i.height, "height"),
+      channels: n,
+      data: i.data,
+      depth: a,
+      text: i.text,
+      palette: i.palette
+    };
+    this._colorType = e;
+    const l = a < 8 ? Math.ceil(r.width * a / 8) * r.height * n : r.width * r.height * n;
+    if (r.data.length !== l)
+      throw new RangeError(`wrong data size. Found ${r.data.length}, expected ${l}`);
+    return r;
+  }
+}
+function te(t, i) {
+  if (Number.isInteger(t) && t > 0)
+    return t;
+  throw new TypeError(`${i} must be a positive integer`);
+}
+function Mn(t, i) {
+  const { channels: e = 4, depth: n = 8 } = t;
+  if (e !== 4 && e !== 3 && e !== 2 && e !== 1)
+    throw new RangeError(`unsupported number of channels: ${e}`);
+  const a = {
+    channels: e,
+    depth: n,
+    colorType: O.UNKNOWN
+  };
+  switch (e) {
+    case 4:
+      a.colorType = O.TRUECOLOUR_ALPHA;
+      break;
+    case 3:
+      a.colorType = O.TRUECOLOUR;
+      break;
+    case 1:
+      i ? a.colorType = O.INDEXED_COLOUR : a.colorType = O.GREYSCALE;
+      break;
+    case 2:
+      a.colorType = O.GREYSCALE_ALPHA;
+      break;
+    default:
+      throw new Error("unsupported number of channels");
+  }
+  return a;
+}
+function $n(t, i, e, n) {
+  for (let a = 0; a < e; a++)
+    i.writeByte(t[n++]);
+  return n;
+}
+function Hn(t, i, e, n) {
+  const a = [
+    { x: 0, y: 0, xStep: 8, yStep: 8 },
+    { x: 4, y: 0, xStep: 8, yStep: 8 },
+    { x: 0, y: 4, xStep: 4, yStep: 8 },
+    { x: 2, y: 0, xStep: 4, yStep: 4 },
+    { x: 0, y: 2, xStep: 2, yStep: 4 },
+    { x: 1, y: 0, xStep: 2, yStep: 2 },
+    { x: 0, y: 1, xStep: 1, yStep: 2 }
+  ], { width: r, height: l, channels: h, depth: o } = t;
+  let _ = 0;
+  o === 16 ? _ = h * o / 8 / 2 : _ = h * o / 8;
+  for (let u = 0; u < 7; u++) {
+    const c = a[u], d = Math.floor((r - c.x + c.xStep - 1) / c.xStep), E = Math.floor((l - c.y + c.yStep - 1) / c.yStep);
+    if (d <= 0 || E <= 0)
+      continue;
+    const k = d * _;
+    for (let z = 0; z < E; z++) {
+      const Mt = c.y + z * c.yStep, pt = o <= 8 ? new Uint8Array(k) : new Uint16Array(k);
+      let Le = 0;
+      for (let M = 0; M < d; M++) {
+        const $t = c.x + M * c.xStep;
+        if ($t < r && Mt < l) {
+          const De = (Mt * r + $t) * _;
+          for (let wt = 0; wt < _; wt++)
+            pt[Le++] = i[De + wt];
+        }
+      }
+      if (e.writeByte(0), o === 8)
+        e.writeBytes(pt);
+      else if (o === 16)
+        for (const M of pt)
+          e.writeByte(M >> 8 & 255), e.writeByte(M & 255);
+    }
+  }
+  return n;
+}
+function Wn(t, i, e, n) {
+  for (let a = 0; a < e; a++)
+    i.writeUint16(t[n++]);
+  return n;
+}
+var ee;
+(function(t) {
+  t[t.UNKNOWN = 0] = "UNKNOWN", t[t.METRE = 1] = "METRE";
+})(ee || (ee = {}));
+function Pn(t, i) {
+  return new Fn(t, i).encode();
+}
+export {
+  Pn as e
+};