locar-tiler 0.0.2

package/dist/locar-tiler.mjs

@@ -0,0 +1,2420 @@
+class N {
+  static EARTH = 4007501668e-2;
+  static HALF_EARTH = 2003750834e-2;
+}
+class q {
+  x;
+  y;
+  z;
+  constructor(e, t, n) {
+    this.x = e, this.y = t, this.z = n;
+  }
+  getMetresInTile() {
+    return N.EARTH / Math.pow(2, this.z);
+  }
+  getBottomLeft() {
+    var e = this.getMetresInTile();
+    return { e: this.x * e - N.HALF_EARTH, n: N.HALF_EARTH - (this.y + 1) * e };
+  }
+  getTopRight() {
+    var e = this.getBottomLeft(), t = this.getMetresInTile();
+    return e.e += t, e.n += t, e;
+  }
+  getIndex() {
+    return `${this.z}/${this.x}/${this.y}`;
+  }
+}
+class Ue {
+  project(e) {
+    return { e: this.#t(e.lon), n: this.#e(e.lat) };
+  }
+  unproject(e) {
+    return { lon: this.#i(e[0]), lat: this.#n(e[1]) };
+  }
+  #t(e) {
+    return e / 180 * N.HALF_EARTH;
+  }
+  #e(e) {
+    var t = Math.log(Math.tan((90 + e) * Math.PI / 360)) / (Math.PI / 180);
+    return t * N.HALF_EARTH / 180;
+  }
+  #i(e) {
+    return e / N.HALF_EARTH * 180;
+  }
+  #n(e) {
+    var t = e / N.HALF_EARTH * 180;
+    return t = 180 / Math.PI * (2 * Math.atan(Math.exp(t * Math.PI / 180)) - Math.PI / 2), t;
+  }
+  getTile(e, t) {
+    var n = new q(-1, -1, t), a = n.getMetresInTile();
+    return n.x = Math.floor((N.HALF_EARTH + e.e) / a), n.y = Math.floor((N.HALF_EARTH - e.n) / a), n;
+  }
+  getTileFromLonLat(e, t) {
+    return this.getTile(this.project(e), t);
+  }
+  getID() {
+    return "epsg:3857";
+  }
+}
+class ee {
+  tile;
+  url;
+  sphMerc;
+  dataTiles;
+  constructor(e) {
+    this.tile = new q(0, 0, 13), this.url = e, this.sphMerc = new Ue(), this.dataTiles = /* @__PURE__ */ new Map();
+  }
+  setZoom(e) {
+    this.tile.z = e;
+  }
+  lonLatToSphMerc(e) {
+    return this.sphMerc.project(e);
+  }
+  getTile(e, t) {
+    return this.sphMerc.getTile(e, t);
+  }
+  async update(e) {
+    const t = [];
+    let n = null;
+    if (n = this.updateTile(e)) {
+      this.tile = n;
+      const a = [n.x, n.x - 1, n.x + 1], s = [n.y, n.y - 1, n.y + 1];
+      for (let l = 0; l < a.length; l++)
+        for (let h = 0; h < s.length; h++) {
+          const _ = new q(a[l], s[h], n.z), r = await this.loadTile(_);
+          r !== null && t.push({ data: r.data, tile: _ });
+        }
+    }
+    return t;
+  }
+  async updateByLonLat(e) {
+    return this.update(this.lonLatToSphMerc(e));
+  }
+  getCurrentTiles() {
+    const e = [], t = [this.tile.x, this.tile.x - 1, this.tile.x + 1], n = [this.tile.y, this.tile.y - 1, this.tile.y + 1];
+    for (let a = 0; a < t.length; a++)
+      for (let s = 0; s < n.length; s++) {
+        const l = new q(t[a], n[s], this.tile.z), h = this.dataTiles[l.getIndex()];
+        h !== null && e.push({ data: h, tile: l });
+      }
+    return e;
+  }
+  updateTile(e) {
+    if (this.tile) {
+      const t = this.sphMerc.getTile(e, this.tile.z);
+      return t.x != this.tile.x || t.y != this.tile.y ? t : null;
+    }
+    return null;
+  }
+  async loadTile(e) {
+    const t = e.getIndex();
+    if (this.dataTiles[t] === void 0) {
+      const n = await this.readTile(
+        this.url.replace("{x}", e.x.toString()).replace("{y}", e.y.toString()).replace("{z}", e.z.toString())
+      );
+      return this.dataTiles[t] = n, this.dataTiles[t];
+    }
+    return null;
+  }
+  // for a given sphmerc pos, downloads data if necessary and returns
+  // the data at the tile corresponding to that position
+  async getData(e, t = 13) {
+    await this.update(e);
+    const n = this.sphMerc.getTile(e, t);
+    return this.dataTiles[`${t}/${n.x}/${n.y}`];
+  }
+  // can be overridden if we want to store something other than the raw data
+  // (for example DEM objects if we are dealing with DEM tiles)
+  rawTileToStoredTile(e, t) {
+    return { tile: e, data: t };
+  }
+}
+function bt(i, e = "utf8") {
+  return new TextDecoder(e).decode(i);
+}
+const Se = new TextEncoder();
+function Ie(i) {
+  return Se.encode(i);
+}
+const Oe = 1024 * 8, Re = (() => {
+  const i = new Uint8Array(4), e = new Uint32Array(i.buffer);
+  return !((e[0] = 1) & i[0]);
+})(), et = {
+  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 wt {
+  /**
+   * 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(e = Oe, t = {}) {
+    let n = !1;
+    typeof e == "number" ? e = new ArrayBuffer(e) : (n = !0, this.lastWrittenByte = e.byteLength);
+    const a = t.offset ? t.offset >>> 0 : 0, s = e.byteLength - a;
+    let l = a;
+    (ArrayBuffer.isView(e) || e instanceof wt) && (e.byteLength !== e.buffer.byteLength && (l = e.byteOffset + a), e = e.buffer), n ? this.lastWrittenByte = s : this.lastWrittenByte = 0, this.buffer = e, this.length = s, this.byteLength = s, this.byteOffset = l, this.offset = 0, this.littleEndian = !0, this._data = new DataView(this.buffer, l, s), 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(e = 1) {
+    return this.offset + e <= 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(e = 1) {
+    return this.offset += e, this;
+  }
+  /**
+   * Move the pointer n bytes backward.
+   * @param n - Number of bytes to move back.
+   * @returns This.
+   */
+  back(e = 1) {
+    return this.offset -= e, this;
+  }
+  /**
+   * Move the pointer to the given offset.
+   * @param offset - The offset to move to.
+   * @returns This.
+   */
+  seek(e) {
+    return this.offset = e, 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 e = this._marks.pop();
+    if (e === void 0)
+      throw new Error("Mark stack empty");
+    return this.seek(e), 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(e = 1) {
+    if (!this.available(e)) {
+      const n = (this.offset + e) * 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(e = 1) {
+    return this.readArray(e, "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(e, t) {
+    const n = et[t].BYTES_PER_ELEMENT * e, a = this.byteOffset + this.offset, s = this.buffer.slice(a, a + n);
+    if (this.littleEndian === Re && t !== "uint8" && t !== "int8") {
+      const h = new Uint8Array(this.buffer.slice(a, a + n));
+      h.reverse();
+      const _ = new et[t](h.buffer);
+      return this.offset += n, _.reverse(), _;
+    }
+    const l = new et[t](s);
+    return this.offset += n, l;
+  }
+  /**
+   * Read a 16-bit signed integer and move pointer forward by 2 bytes.
+   * @returns The read value.
+   */
+  readInt16() {
+    const e = this._data.getInt16(this.offset, this.littleEndian);
+    return this.offset += 2, e;
+  }
+  /**
+   * Read a 16-bit unsigned integer and move pointer forward by 2 bytes.
+   * @returns The read value.
+   */
+  readUint16() {
+    const e = this._data.getUint16(this.offset, this.littleEndian);
+    return this.offset += 2, e;
+  }
+  /**
+   * Read a 32-bit signed integer and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readInt32() {
+    const e = this._data.getInt32(this.offset, this.littleEndian);
+    return this.offset += 4, e;
+  }
+  /**
+   * Read a 32-bit unsigned integer and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readUint32() {
+    const e = this._data.getUint32(this.offset, this.littleEndian);
+    return this.offset += 4, e;
+  }
+  /**
+   * Read a 32-bit floating number and move pointer forward by 4 bytes.
+   * @returns The read value.
+   */
+  readFloat32() {
+    const e = this._data.getFloat32(this.offset, this.littleEndian);
+    return this.offset += 4, e;
+  }
+  /**
+   * Read a 64-bit floating number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readFloat64() {
+    const e = this._data.getFloat64(this.offset, this.littleEndian);
+    return this.offset += 8, e;
+  }
+  /**
+   * Read a 64-bit signed integer number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readBigInt64() {
+    const e = this._data.getBigInt64(this.offset, this.littleEndian);
+    return this.offset += 8, e;
+  }
+  /**
+   * Read a 64-bit unsigned integer number and move pointer forward by 8 bytes.
+   * @returns The read value.
+   */
+  readBigUint64() {
+    const e = this._data.getBigUint64(this.offset, this.littleEndian);
+    return this.offset += 8, e;
+  }
+  /**
+   * 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(e = 1) {
+    let t = "";
+    for (let n = 0; n < e; n++)
+      t += this.readChar();
+    return t;
+  }
+  /**
+   * 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(e = 1) {
+    return bt(this.readBytes(e));
+  }
+  /**
+   * 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(e = 1, t = "utf8") {
+    return bt(this.readBytes(e), t);
+  }
+  /**
+   * 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(e) {
+    return this.writeUint8(e ? 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(e) {
+    return this.ensureAvailable(1), this._data.setInt8(this.offset++, e), 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(e) {
+    return this.ensureAvailable(1), this._data.setUint8(this.offset++, e), this._updateLastWrittenByte(), this;
+  }
+  /**
+   * An alias for {@link IOBuffer#writeUint8}.
+   * @param value - The value to write.
+   * @returns This.
+   */
+  writeByte(e) {
+    return this.writeUint8(e);
+  }
+  /**
+   * 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(e) {
+    this.ensureAvailable(e.length);
+    for (let t = 0; t < e.length; t++)
+      this._data.setUint8(this.offset++, e[t]);
+    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(e) {
+    return this.ensureAvailable(2), this._data.setInt16(this.offset, e, 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(e) {
+    return this.ensureAvailable(2), this._data.setUint16(this.offset, e, 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(e) {
+    return this.ensureAvailable(4), this._data.setInt32(this.offset, e, 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(e) {
+    return this.ensureAvailable(4), this._data.setUint32(this.offset, e, 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(e) {
+    return this.ensureAvailable(4), this._data.setFloat32(this.offset, e, 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(e) {
+    return this.ensureAvailable(8), this._data.setFloat64(this.offset, e, 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(e) {
+    return this.ensureAvailable(8), this._data.setBigInt64(this.offset, e, 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(e) {
+    return this.ensureAvailable(8), this._data.setBigUint64(this.offset, e, 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(e) {
+    return this.writeUint8(e.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(e) {
+    for (let t = 0; t < e.length; t++)
+      this.writeUint8(e.charCodeAt(t));
+    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(e) {
+    return this.writeBytes(Ie(e));
+  }
+  /**
+   * 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);
+  }
+}
+function H(i) {
+  let e = i.length;
+  for (; --e >= 0; )
+    i[e] = 0;
+}
+const Ce = 3, Ne = 258, ie = 29, De = 256, Me = De + 1 + ie, ne = 30, Le = 512, Be = new Array((Me + 2) * 2);
+H(Be);
+const $e = new Array(ne * 2);
+H($e);
+const He = new Array(Le);
+H(He);
+const Fe = new Array(Ne - Ce + 1);
+H(Fe);
+const We = new Array(ie);
+H(We);
+const Ze = new Array(ne);
+H(Ze);
+const ze = (i, e, t, n) => {
+  let a = i & 65535 | 0, s = i >>> 16 & 65535 | 0, l = 0;
+  for (; t !== 0; ) {
+    l = t > 2e3 ? 2e3 : t, t -= l;
+    do
+      a = a + e[n++] | 0, s = s + a | 0;
+    while (--l);
+    a %= 65521, s %= 65521;
+  }
+  return a | s << 16 | 0;
+};
+var ut = ze;
+const Pe = () => {
+  let i, e = [];
+  for (var t = 0; t < 256; t++) {
+    i = t;
+    for (var n = 0; n < 8; n++)
+      i = i & 1 ? 3988292384 ^ i >>> 1 : i >>> 1;
+    e[t] = i;
+  }
+  return e;
+}, Ge = new Uint32Array(Pe()), Ke = (i, e, t, n) => {
+  const a = Ge, s = n + t;
+  i ^= -1;
+  for (let l = n; l < s; l++)
+    i = i >>> 8 ^ a[(i ^ e[l]) & 255];
+  return i ^ -1;
+};
+var R = Ke, _t = {
+  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) */
+}, se = {
+  /* Allowed flush values; see deflate() and inflate() below for details */
+  Z_NO_FLUSH: 0,
+  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_STREAM_ERROR: -2,
+  Z_DATA_ERROR: -3,
+  Z_MEM_ERROR: -4,
+  Z_BUF_ERROR: -5,
+  /* The deflate compression method */
+  Z_DEFLATED: 8
+  //Z_NULL:                 null // Use -1 or null inline, depending on var type
+};
+const Ye = (i, e) => Object.prototype.hasOwnProperty.call(i, e);
+var Xe = function(i) {
+  const e = Array.prototype.slice.call(arguments, 1);
+  for (; e.length; ) {
+    const t = e.shift();
+    if (t) {
+      if (typeof t != "object")
+        throw new TypeError(t + "must be non-object");
+      for (const n in t)
+        Ye(t, n) && (i[n] = t[n]);
+    }
+  }
+  return i;
+}, je = (i) => {
+  let e = 0;
+  for (let n = 0, a = i.length; n < a; n++)
+    e += i[n].length;
+  const t = new Uint8Array(e);
+  for (let n = 0, a = 0, s = i.length; n < s; n++) {
+    let l = i[n];
+    t.set(l, a), a += l.length;
+  }
+  return t;
+}, ae = {
+  assign: Xe,
+  flattenChunks: je
+};
+let re = !0;
+try {
+  String.fromCharCode.apply(null, new Uint8Array(1));
+} catch {
+  re = !1;
+}
+const W = new Uint8Array(256);
+for (let i = 0; i < 256; i++)
+  W[i] = i >= 252 ? 6 : i >= 248 ? 5 : i >= 240 ? 4 : i >= 224 ? 3 : i >= 192 ? 2 : 1;
+W[254] = W[254] = 1;
+var Ve = (i) => {
+  if (typeof TextEncoder == "function" && TextEncoder.prototype.encode)
+    return new TextEncoder().encode(i);
+  let e, t, n, a, s, l = i.length, h = 0;
+  for (a = 0; a < l; a++)
+    t = i.charCodeAt(a), (t & 64512) === 55296 && a + 1 < l && (n = i.charCodeAt(a + 1), (n & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (n - 56320), a++)), h += t < 128 ? 1 : t < 2048 ? 2 : t < 65536 ? 3 : 4;
+  for (e = new Uint8Array(h), s = 0, a = 0; s < h; a++)
+    t = i.charCodeAt(a), (t & 64512) === 55296 && a + 1 < l && (n = i.charCodeAt(a + 1), (n & 64512) === 56320 && (t = 65536 + (t - 55296 << 10) + (n - 56320), a++)), t < 128 ? e[s++] = t : t < 2048 ? (e[s++] = 192 | t >>> 6, e[s++] = 128 | t & 63) : t < 65536 ? (e[s++] = 224 | t >>> 12, e[s++] = 128 | t >>> 6 & 63, e[s++] = 128 | t & 63) : (e[s++] = 240 | t >>> 18, e[s++] = 128 | t >>> 12 & 63, e[s++] = 128 | t >>> 6 & 63, e[s++] = 128 | t & 63);
+  return e;
+};
+const qe = (i, e) => {
+  if (e < 65534 && i.subarray && re)
+    return String.fromCharCode.apply(null, i.length === e ? i : i.subarray(0, e));
+  let t = "";
+  for (let n = 0; n < e; n++)
+    t += String.fromCharCode(i[n]);
+  return t;
+};
+var Je = (i, e) => {
+  const t = e || i.length;
+  if (typeof TextDecoder == "function" && TextDecoder.prototype.decode)
+    return new TextDecoder().decode(i.subarray(0, e));
+  let n, a;
+  const s = new Array(t * 2);
+  for (a = 0, n = 0; n < t; ) {
+    let l = i[n++];
+    if (l < 128) {
+      s[a++] = l;
+      continue;
+    }
+    let h = W[l];
+    if (h > 4) {
+      s[a++] = 65533, n += h - 1;
+      continue;
+    }
+    for (l &= h === 2 ? 31 : h === 3 ? 15 : 7; h > 1 && n < t; )
+      l = l << 6 | i[n++] & 63, h--;
+    if (h > 1) {
+      s[a++] = 65533;
+      continue;
+    }
+    l < 65536 ? s[a++] = l : (l -= 65536, s[a++] = 55296 | l >> 10 & 1023, s[a++] = 56320 | l & 1023);
+  }
+  return qe(s, a);
+}, Qe = (i, e) => {
+  e = e || i.length, e > i.length && (e = i.length);
+  let t = e - 1;
+  for (; t >= 0 && (i[t] & 192) === 128; )
+    t--;
+  return t < 0 || t === 0 ? e : t + W[i[t]] > e ? t : e;
+}, pt = {
+  string2buf: Ve,
+  buf2string: Je,
+  utf8border: Qe
+};
+function ti() {
+  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 ei = ti;
+const K = 16209, ii = 16191;
+var ni = function(e, t) {
+  let n, a, s, l, h, _, r, o, w, d, f, u, U, x, g, T, y, c, E, S, p, m, A, b;
+  const k = e.state;
+  n = e.next_in, A = e.input, a = n + (e.avail_in - 5), s = e.next_out, b = e.output, l = s - (t - e.avail_out), h = s + (e.avail_out - 257), _ = k.dmax, r = k.wsize, o = k.whave, w = k.wnext, d = k.window, f = k.hold, u = k.bits, U = k.lencode, x = k.distcode, g = (1 << k.lenbits) - 1, T = (1 << k.distbits) - 1;
+  t:
+    do {
+      u < 15 && (f += A[n++] << u, u += 8, f += A[n++] << u, u += 8), y = U[f & g];
+      e:
+        for (; ; ) {
+          if (c = y >>> 24, f >>>= c, u -= c, c = y >>> 16 & 255, c === 0)
+            b[s++] = y & 65535;
+          else if (c & 16) {
+            E = y & 65535, c &= 15, c && (u < c && (f += A[n++] << u, u += 8), E += f & (1 << c) - 1, f >>>= c, u -= c), u < 15 && (f += A[n++] << u, u += 8, f += A[n++] << u, u += 8), y = x[f & T];
+            i:
+              for (; ; ) {
+                if (c = y >>> 24, f >>>= c, u -= c, c = y >>> 16 & 255, c & 16) {
+                  if (S = y & 65535, c &= 15, u < c && (f += A[n++] << u, u += 8, u < c && (f += A[n++] << u, u += 8)), S += f & (1 << c) - 1, S > _) {
+                    e.msg = "invalid distance too far back", k.mode = K;
+                    break t;
+                  }
+                  if (f >>>= c, u -= c, c = s - l, S > c) {
+                    if (c = S - c, c > o && k.sane) {
+                      e.msg = "invalid distance too far back", k.mode = K;
+                      break t;
+                    }
+                    if (p = 0, m = d, w === 0) {
+                      if (p += r - c, c < E) {
+                        E -= c;
+                        do
+                          b[s++] = d[p++];
+                        while (--c);
+                        p = s - S, m = b;
+                      }
+                    } else if (w < c) {
+                      if (p += r + w - c, c -= w, c < E) {
+                        E -= c;
+                        do
+                          b[s++] = d[p++];
+                        while (--c);
+                        if (p = 0, w < E) {
+                          c = w, E -= c;
+                          do
+                            b[s++] = d[p++];
+                          while (--c);
+                          p = s - S, m = b;
+                        }
+                      }
+                    } else if (p += w - c, c < E) {
+                      E -= c;
+                      do
+                        b[s++] = d[p++];
+                      while (--c);
+                      p = s - S, m = b;
+                    }
+                    for (; E > 2; )
+                      b[s++] = m[p++], b[s++] = m[p++], b[s++] = m[p++], E -= 3;
+                    E && (b[s++] = m[p++], E > 1 && (b[s++] = m[p++]));
+                  } else {
+                    p = s - S;
+                    do
+                      b[s++] = b[p++], b[s++] = b[p++], b[s++] = b[p++], E -= 3;
+                    while (E > 2);
+                    E && (b[s++] = b[p++], E > 1 && (b[s++] = b[p++]));
+                  }
+                } else if ((c & 64) === 0) {
+                  y = x[(y & 65535) + (f & (1 << c) - 1)];
+                  continue i;
+                } else {
+                  e.msg = "invalid distance code", k.mode = K;
+                  break t;
+                }
+                break;
+              }
+          } else if ((c & 64) === 0) {
+            y = U[(y & 65535) + (f & (1 << c) - 1)];
+            continue e;
+          } else if (c & 32) {
+            k.mode = ii;
+            break t;
+          } else {
+            e.msg = "invalid literal/length code", k.mode = K;
+            break t;
+          }
+          break;
+        }
+    } while (n < a && s < h);
+  E = u >> 3, n -= E, u -= E << 3, f &= (1 << u) - 1, e.next_in = n, e.next_out = s, e.avail_in = n < a ? 5 + (a - n) : 5 - (n - a), e.avail_out = s < h ? 257 + (h - s) : 257 - (s - h), k.hold = f, k.bits = u;
+};
+const $ = 15, xt = 852, yt = 592, kt = 0, it = 1, Et = 2, si = 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
+]), ai = 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
+]), ri = 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
+]), oi = 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
+]), hi = (i, e, t, n, a, s, l, h) => {
+  const _ = h.bits;
+  let r = 0, o = 0, w = 0, d = 0, f = 0, u = 0, U = 0, x = 0, g = 0, T = 0, y, c, E, S, p, m = null, A;
+  const b = new Uint16Array($ + 1), k = new Uint16Array($ + 1);
+  let M = null, gt, P, G;
+  for (r = 0; r <= $; r++)
+    b[r] = 0;
+  for (o = 0; o < n; o++)
+    b[e[t + o]]++;
+  for (f = _, d = $; d >= 1 && b[d] === 0; d--)
+    ;
+  if (f > d && (f = d), d === 0)
+    return a[s++] = 1 << 24 | 64 << 16 | 0, a[s++] = 1 << 24 | 64 << 16 | 0, h.bits = 1, 0;
+  for (w = 1; w < d && b[w] === 0; w++)
+    ;
+  for (f < w && (f = w), x = 1, r = 1; r <= $; r++)
+    if (x <<= 1, x -= b[r], x < 0)
+      return -1;
+  if (x > 0 && (i === kt || d !== 1))
+    return -1;
+  for (k[1] = 0, r = 1; r < $; r++)
+    k[r + 1] = k[r] + b[r];
+  for (o = 0; o < n; o++)
+    e[t + o] !== 0 && (l[k[e[t + o]]++] = o);
+  if (i === kt ? (m = M = l, A = 20) : i === it ? (m = si, M = ai, A = 257) : (m = ri, M = oi, A = 0), T = 0, o = 0, r = w, p = s, u = f, U = 0, E = -1, g = 1 << f, S = g - 1, i === it && g > xt || i === Et && g > yt)
+    return 1;
+  for (; ; ) {
+    gt = r - U, l[o] + 1 < A ? (P = 0, G = l[o]) : l[o] >= A ? (P = M[l[o] - A], G = m[l[o] - A]) : (P = 96, G = 0), y = 1 << r - U, c = 1 << u, w = c;
+    do
+      c -= y, a[p + (T >> U) + c] = gt << 24 | P << 16 | G | 0;
+    while (c !== 0);
+    for (y = 1 << r - 1; T & y; )
+      y >>= 1;
+    if (y !== 0 ? (T &= y - 1, T += y) : T = 0, o++, --b[r] === 0) {
+      if (r === d)
+        break;
+      r = e[t + l[o]];
+    }
+    if (r > f && (T & S) !== E) {
+      for (U === 0 && (U = f), p += w, u = r - U, x = 1 << u; u + U < d && (x -= b[u + U], !(x <= 0)); )
+        u++, x <<= 1;
+      if (g += 1 << u, i === it && g > xt || i === Et && g > yt)
+        return 1;
+      E = T & S, a[E] = f << 24 | u << 16 | p - s | 0;
+    }
+  }
+  return T !== 0 && (a[p + T] = r - U << 24 | 64 << 16 | 0), h.bits = f, 0;
+};
+var F = hi;
+const fi = 0, oe = 1, he = 2, {
+  Z_FINISH: At,
+  Z_BLOCK: li,
+  Z_TREES: Y,
+  Z_OK: L,
+  Z_STREAM_END: ci,
+  Z_NEED_DICT: di,
+  Z_STREAM_ERROR: O,
+  Z_DATA_ERROR: fe,
+  Z_MEM_ERROR: le,
+  Z_BUF_ERROR: ui,
+  Z_DEFLATED: Tt
+} = se, tt = 16180, mt = 16181, vt = 16182, Ut = 16183, St = 16184, It = 16185, Ot = 16186, Rt = 16187, Ct = 16188, Nt = 16189, Q = 16190, C = 16191, nt = 16192, Dt = 16193, st = 16194, Mt = 16195, Lt = 16196, Bt = 16197, $t = 16198, X = 16199, j = 16200, Ht = 16201, Ft = 16202, Wt = 16203, Zt = 16204, zt = 16205, at = 16206, Pt = 16207, Gt = 16208, v = 16209, ce = 16210, de = 16211, _i = 852, pi = 592, wi = 15, gi = wi, Kt = (i) => (i >>> 24 & 255) + (i >>> 8 & 65280) + ((i & 65280) << 8) + ((i & 255) << 24);
+function bi() {
+  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 B = (i) => {
+  if (!i)
+    return 1;
+  const e = i.state;
+  return !e || e.strm !== i || e.mode < tt || e.mode > de ? 1 : 0;
+}, ue = (i) => {
+  if (B(i))
+    return O;
+  const e = i.state;
+  return i.total_in = i.total_out = e.total = 0, i.msg = "", e.wrap && (i.adler = e.wrap & 1), e.mode = tt, e.last = 0, e.havedict = 0, e.flags = -1, e.dmax = 32768, e.head = null, e.hold = 0, e.bits = 0, e.lencode = e.lendyn = new Int32Array(_i), e.distcode = e.distdyn = new Int32Array(pi), e.sane = 1, e.back = -1, L;
+}, _e = (i) => {
+  if (B(i))
+    return O;
+  const e = i.state;
+  return e.wsize = 0, e.whave = 0, e.wnext = 0, ue(i);
+}, pe = (i, e) => {
+  let t;
+  if (B(i))
+    return O;
+  const n = i.state;
+  return e < 0 ? (t = 0, e = -e) : (t = (e >> 4) + 5, e < 48 && (e &= 15)), e && (e < 8 || e > 15) ? O : (n.window !== null && n.wbits !== e && (n.window = null), n.wrap = t, n.wbits = e, _e(i));
+}, we = (i, e) => {
+  if (!i)
+    return O;
+  const t = new bi();
+  i.state = t, t.strm = i, t.window = null, t.mode = tt;
+  const n = pe(i, e);
+  return n !== L && (i.state = null), n;
+}, xi = (i) => we(i, gi);
+let Yt = !0, rt, ot;
+const yi = (i) => {
+  if (Yt) {
+    rt = new Int32Array(512), ot = new Int32Array(32);
+    let e = 0;
+    for (; e < 144; )
+      i.lens[e++] = 8;
+    for (; e < 256; )
+      i.lens[e++] = 9;
+    for (; e < 280; )
+      i.lens[e++] = 7;
+    for (; e < 288; )
+      i.lens[e++] = 8;
+    for (F(oe, i.lens, 0, 288, rt, 0, i.work, { bits: 9 }), e = 0; e < 32; )
+      i.lens[e++] = 5;
+    F(he, i.lens, 0, 32, ot, 0, i.work, { bits: 5 }), Yt = !1;
+  }
+  i.lencode = rt, i.lenbits = 9, i.distcode = ot, i.distbits = 5;
+}, ge = (i, e, t, n) => {
+  let a;
+  const s = i.state;
+  return s.window === null && (s.wsize = 1 << s.wbits, s.wnext = 0, s.whave = 0, s.window = new Uint8Array(s.wsize)), n >= s.wsize ? (s.window.set(e.subarray(t - s.wsize, t), 0), s.wnext = 0, s.whave = s.wsize) : (a = s.wsize - s.wnext, a > n && (a = n), s.window.set(e.subarray(t - n, t - n + a), s.wnext), n -= a, n ? (s.window.set(e.subarray(t - n, t), 0), s.wnext = n, s.whave = s.wsize) : (s.wnext += a, s.wnext === s.wsize && (s.wnext = 0), s.whave < s.wsize && (s.whave += a))), 0;
+}, ki = (i, e) => {
+  let t, n, a, s, l, h, _, r, o, w, d, f, u, U, x = 0, g, T, y, c, E, S, p, m;
+  const A = new Uint8Array(4);
+  let b, k;
+  const M = (
+    /* 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 (B(i) || !i.output || !i.input && i.avail_in !== 0)
+    return O;
+  t = i.state, t.mode === C && (t.mode = nt), l = i.next_out, a = i.output, _ = i.avail_out, s = i.next_in, n = i.input, h = i.avail_in, r = t.hold, o = t.bits, w = h, d = _, m = L;
+  t:
+    for (; ; )
+      switch (t.mode) {
+        case tt:
+          if (t.wrap === 0) {
+            t.mode = nt;
+            break;
+          }
+          for (; o < 16; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          if (t.wrap & 2 && r === 35615) {
+            t.wbits === 0 && (t.wbits = 15), t.check = 0, A[0] = r & 255, A[1] = r >>> 8 & 255, t.check = R(t.check, A, 2, 0), r = 0, o = 0, t.mode = mt;
+            break;
+          }
+          if (t.head && (t.head.done = !1), !(t.wrap & 1) || /* check if zlib header allowed */
+          (((r & 255) << 8) + (r >> 8)) % 31) {
+            i.msg = "incorrect header check", t.mode = v;
+            break;
+          }
+          if ((r & 15) !== Tt) {
+            i.msg = "unknown compression method", t.mode = v;
+            break;
+          }
+          if (r >>>= 4, o -= 4, p = (r & 15) + 8, t.wbits === 0 && (t.wbits = p), p > 15 || p > t.wbits) {
+            i.msg = "invalid window size", t.mode = v;
+            break;
+          }
+          t.dmax = 1 << t.wbits, t.flags = 0, i.adler = t.check = 1, t.mode = r & 512 ? Nt : C, r = 0, o = 0;
+          break;
+        case mt:
+          for (; o < 16; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          if (t.flags = r, (t.flags & 255) !== Tt) {
+            i.msg = "unknown compression method", t.mode = v;
+            break;
+          }
+          if (t.flags & 57344) {
+            i.msg = "unknown header flags set", t.mode = v;
+            break;
+          }
+          t.head && (t.head.text = r >> 8 & 1), t.flags & 512 && t.wrap & 4 && (A[0] = r & 255, A[1] = r >>> 8 & 255, t.check = R(t.check, A, 2, 0)), r = 0, o = 0, t.mode = vt;
+        /* falls through */
+        case vt:
+          for (; o < 32; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          t.head && (t.head.time = r), t.flags & 512 && t.wrap & 4 && (A[0] = r & 255, A[1] = r >>> 8 & 255, A[2] = r >>> 16 & 255, A[3] = r >>> 24 & 255, t.check = R(t.check, A, 4, 0)), r = 0, o = 0, t.mode = Ut;
+        /* falls through */
+        case Ut:
+          for (; o < 16; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          t.head && (t.head.xflags = r & 255, t.head.os = r >> 8), t.flags & 512 && t.wrap & 4 && (A[0] = r & 255, A[1] = r >>> 8 & 255, t.check = R(t.check, A, 2, 0)), r = 0, o = 0, t.mode = St;
+        /* falls through */
+        case St:
+          if (t.flags & 1024) {
+            for (; o < 16; ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            t.length = r, t.head && (t.head.extra_len = r), t.flags & 512 && t.wrap & 4 && (A[0] = r & 255, A[1] = r >>> 8 & 255, t.check = R(t.check, A, 2, 0)), r = 0, o = 0;
+          } else t.head && (t.head.extra = null);
+          t.mode = It;
+        /* falls through */
+        case It:
+          if (t.flags & 1024 && (f = t.length, f > h && (f = h), f && (t.head && (p = t.head.extra_len - t.length, t.head.extra || (t.head.extra = new Uint8Array(t.head.extra_len)), t.head.extra.set(
+            n.subarray(
+              s,
+              // extra field is limited to 65536 bytes
+              // - no need for additional size check
+              s + f
+            ),
+            /*len + copy > state.head.extra_max - len ? state.head.extra_max : copy,*/
+            p
+          )), t.flags & 512 && t.wrap & 4 && (t.check = R(t.check, n, f, s)), h -= f, s += f, t.length -= f), t.length))
+            break t;
+          t.length = 0, t.mode = Ot;
+        /* falls through */
+        case Ot:
+          if (t.flags & 2048) {
+            if (h === 0)
+              break t;
+            f = 0;
+            do
+              p = n[s + f++], t.head && p && t.length < 65536 && (t.head.name += String.fromCharCode(p));
+            while (p && f < h);
+            if (t.flags & 512 && t.wrap & 4 && (t.check = R(t.check, n, f, s)), h -= f, s += f, p)
+              break t;
+          } else t.head && (t.head.name = null);
+          t.length = 0, t.mode = Rt;
+        /* falls through */
+        case Rt:
+          if (t.flags & 4096) {
+            if (h === 0)
+              break t;
+            f = 0;
+            do
+              p = n[s + f++], t.head && p && t.length < 65536 && (t.head.comment += String.fromCharCode(p));
+            while (p && f < h);
+            if (t.flags & 512 && t.wrap & 4 && (t.check = R(t.check, n, f, s)), h -= f, s += f, p)
+              break t;
+          } else t.head && (t.head.comment = null);
+          t.mode = Ct;
+        /* falls through */
+        case Ct:
+          if (t.flags & 512) {
+            for (; o < 16; ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            if (t.wrap & 4 && r !== (t.check & 65535)) {
+              i.msg = "header crc mismatch", t.mode = v;
+              break;
+            }
+            r = 0, o = 0;
+          }
+          t.head && (t.head.hcrc = t.flags >> 9 & 1, t.head.done = !0), i.adler = t.check = 0, t.mode = C;
+          break;
+        case Nt:
+          for (; o < 32; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          i.adler = t.check = Kt(r), r = 0, o = 0, t.mode = Q;
+        /* falls through */
+        case Q:
+          if (t.havedict === 0)
+            return i.next_out = l, i.avail_out = _, i.next_in = s, i.avail_in = h, t.hold = r, t.bits = o, di;
+          i.adler = t.check = 1, t.mode = C;
+        /* falls through */
+        case C:
+          if (e === li || e === Y)
+            break t;
+        /* falls through */
+        case nt:
+          if (t.last) {
+            r >>>= o & 7, o -= o & 7, t.mode = at;
+            break;
+          }
+          for (; o < 3; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          switch (t.last = r & 1, r >>>= 1, o -= 1, r & 3) {
+            case 0:
+              t.mode = Dt;
+              break;
+            case 1:
+              if (yi(t), t.mode = X, e === Y) {
+                r >>>= 2, o -= 2;
+                break t;
+              }
+              break;
+            case 2:
+              t.mode = Lt;
+              break;
+            case 3:
+              i.msg = "invalid block type", t.mode = v;
+          }
+          r >>>= 2, o -= 2;
+          break;
+        case Dt:
+          for (r >>>= o & 7, o -= o & 7; o < 32; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          if ((r & 65535) !== (r >>> 16 ^ 65535)) {
+            i.msg = "invalid stored block lengths", t.mode = v;
+            break;
+          }
+          if (t.length = r & 65535, r = 0, o = 0, t.mode = st, e === Y)
+            break t;
+        /* falls through */
+        case st:
+          t.mode = Mt;
+        /* falls through */
+        case Mt:
+          if (f = t.length, f) {
+            if (f > h && (f = h), f > _ && (f = _), f === 0)
+              break t;
+            a.set(n.subarray(s, s + f), l), h -= f, s += f, _ -= f, l += f, t.length -= f;
+            break;
+          }
+          t.mode = C;
+          break;
+        case Lt:
+          for (; o < 14; ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          if (t.nlen = (r & 31) + 257, r >>>= 5, o -= 5, t.ndist = (r & 31) + 1, r >>>= 5, o -= 5, t.ncode = (r & 15) + 4, r >>>= 4, o -= 4, t.nlen > 286 || t.ndist > 30) {
+            i.msg = "too many length or distance symbols", t.mode = v;
+            break;
+          }
+          t.have = 0, t.mode = Bt;
+        /* falls through */
+        case Bt:
+          for (; t.have < t.ncode; ) {
+            for (; o < 3; ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            t.lens[M[t.have++]] = r & 7, r >>>= 3, o -= 3;
+          }
+          for (; t.have < 19; )
+            t.lens[M[t.have++]] = 0;
+          if (t.lencode = t.lendyn, t.lenbits = 7, b = { bits: t.lenbits }, m = F(fi, t.lens, 0, 19, t.lencode, 0, t.work, b), t.lenbits = b.bits, m) {
+            i.msg = "invalid code lengths set", t.mode = v;
+            break;
+          }
+          t.have = 0, t.mode = $t;
+        /* falls through */
+        case $t:
+          for (; t.have < t.nlen + t.ndist; ) {
+            for (; x = t.lencode[r & (1 << t.lenbits) - 1], g = x >>> 24, T = x >>> 16 & 255, y = x & 65535, !(g <= o); ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            if (y < 16)
+              r >>>= g, o -= g, t.lens[t.have++] = y;
+            else {
+              if (y === 16) {
+                for (k = g + 2; o < k; ) {
+                  if (h === 0)
+                    break t;
+                  h--, r += n[s++] << o, o += 8;
+                }
+                if (r >>>= g, o -= g, t.have === 0) {
+                  i.msg = "invalid bit length repeat", t.mode = v;
+                  break;
+                }
+                p = t.lens[t.have - 1], f = 3 + (r & 3), r >>>= 2, o -= 2;
+              } else if (y === 17) {
+                for (k = g + 3; o < k; ) {
+                  if (h === 0)
+                    break t;
+                  h--, r += n[s++] << o, o += 8;
+                }
+                r >>>= g, o -= g, p = 0, f = 3 + (r & 7), r >>>= 3, o -= 3;
+              } else {
+                for (k = g + 7; o < k; ) {
+                  if (h === 0)
+                    break t;
+                  h--, r += n[s++] << o, o += 8;
+                }
+                r >>>= g, o -= g, p = 0, f = 11 + (r & 127), r >>>= 7, o -= 7;
+              }
+              if (t.have + f > t.nlen + t.ndist) {
+                i.msg = "invalid bit length repeat", t.mode = v;
+                break;
+              }
+              for (; f--; )
+                t.lens[t.have++] = p;
+            }
+          }
+          if (t.mode === v)
+            break;
+          if (t.lens[256] === 0) {
+            i.msg = "invalid code -- missing end-of-block", t.mode = v;
+            break;
+          }
+          if (t.lenbits = 9, b = { bits: t.lenbits }, m = F(oe, t.lens, 0, t.nlen, t.lencode, 0, t.work, b), t.lenbits = b.bits, m) {
+            i.msg = "invalid literal/lengths set", t.mode = v;
+            break;
+          }
+          if (t.distbits = 6, t.distcode = t.distdyn, b = { bits: t.distbits }, m = F(he, t.lens, t.nlen, t.ndist, t.distcode, 0, t.work, b), t.distbits = b.bits, m) {
+            i.msg = "invalid distances set", t.mode = v;
+            break;
+          }
+          if (t.mode = X, e === Y)
+            break t;
+        /* falls through */
+        case X:
+          t.mode = j;
+        /* falls through */
+        case j:
+          if (h >= 6 && _ >= 258) {
+            i.next_out = l, i.avail_out = _, i.next_in = s, i.avail_in = h, t.hold = r, t.bits = o, ni(i, d), l = i.next_out, a = i.output, _ = i.avail_out, s = i.next_in, n = i.input, h = i.avail_in, r = t.hold, o = t.bits, t.mode === C && (t.back = -1);
+            break;
+          }
+          for (t.back = 0; x = t.lencode[r & (1 << t.lenbits) - 1], g = x >>> 24, T = x >>> 16 & 255, y = x & 65535, !(g <= o); ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          if (T && (T & 240) === 0) {
+            for (c = g, E = T, S = y; x = t.lencode[S + ((r & (1 << c + E) - 1) >> c)], g = x >>> 24, T = x >>> 16 & 255, y = x & 65535, !(c + g <= o); ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            r >>>= c, o -= c, t.back += c;
+          }
+          if (r >>>= g, o -= g, t.back += g, t.length = y, T === 0) {
+            t.mode = zt;
+            break;
+          }
+          if (T & 32) {
+            t.back = -1, t.mode = C;
+            break;
+          }
+          if (T & 64) {
+            i.msg = "invalid literal/length code", t.mode = v;
+            break;
+          }
+          t.extra = T & 15, t.mode = Ht;
+        /* falls through */
+        case Ht:
+          if (t.extra) {
+            for (k = t.extra; o < k; ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            t.length += r & (1 << t.extra) - 1, r >>>= t.extra, o -= t.extra, t.back += t.extra;
+          }
+          t.was = t.length, t.mode = Ft;
+        /* falls through */
+        case Ft:
+          for (; x = t.distcode[r & (1 << t.distbits) - 1], g = x >>> 24, T = x >>> 16 & 255, y = x & 65535, !(g <= o); ) {
+            if (h === 0)
+              break t;
+            h--, r += n[s++] << o, o += 8;
+          }
+          if ((T & 240) === 0) {
+            for (c = g, E = T, S = y; x = t.distcode[S + ((r & (1 << c + E) - 1) >> c)], g = x >>> 24, T = x >>> 16 & 255, y = x & 65535, !(c + g <= o); ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            r >>>= c, o -= c, t.back += c;
+          }
+          if (r >>>= g, o -= g, t.back += g, T & 64) {
+            i.msg = "invalid distance code", t.mode = v;
+            break;
+          }
+          t.offset = y, t.extra = T & 15, t.mode = Wt;
+        /* falls through */
+        case Wt:
+          if (t.extra) {
+            for (k = t.extra; o < k; ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            t.offset += r & (1 << t.extra) - 1, r >>>= t.extra, o -= t.extra, t.back += t.extra;
+          }
+          if (t.offset > t.dmax) {
+            i.msg = "invalid distance too far back", t.mode = v;
+            break;
+          }
+          t.mode = Zt;
+        /* falls through */
+        case Zt:
+          if (_ === 0)
+            break t;
+          if (f = d - _, t.offset > f) {
+            if (f = t.offset - f, f > t.whave && t.sane) {
+              i.msg = "invalid distance too far back", t.mode = v;
+              break;
+            }
+            f > t.wnext ? (f -= t.wnext, u = t.wsize - f) : u = t.wnext - f, f > t.length && (f = t.length), U = t.window;
+          } else
+            U = a, u = l - t.offset, f = t.length;
+          f > _ && (f = _), _ -= f, t.length -= f;
+          do
+            a[l++] = U[u++];
+          while (--f);
+          t.length === 0 && (t.mode = j);
+          break;
+        case zt:
+          if (_ === 0)
+            break t;
+          a[l++] = t.length, _--, t.mode = j;
+          break;
+        case at:
+          if (t.wrap) {
+            for (; o < 32; ) {
+              if (h === 0)
+                break t;
+              h--, r |= n[s++] << o, o += 8;
+            }
+            if (d -= _, i.total_out += d, t.total += d, t.wrap & 4 && d && (i.adler = t.check = /*UPDATE_CHECK(state.check, put - _out, _out);*/
+            t.flags ? R(t.check, a, d, l - d) : ut(t.check, a, d, l - d)), d = _, t.wrap & 4 && (t.flags ? r : Kt(r)) !== t.check) {
+              i.msg = "incorrect data check", t.mode = v;
+              break;
+            }
+            r = 0, o = 0;
+          }
+          t.mode = Pt;
+        /* falls through */
+        case Pt:
+          if (t.wrap && t.flags) {
+            for (; o < 32; ) {
+              if (h === 0)
+                break t;
+              h--, r += n[s++] << o, o += 8;
+            }
+            if (t.wrap & 4 && r !== (t.total & 4294967295)) {
+              i.msg = "incorrect length check", t.mode = v;
+              break;
+            }
+            r = 0, o = 0;
+          }
+          t.mode = Gt;
+        /* falls through */
+        case Gt:
+          m = ci;
+          break t;
+        case v:
+          m = fe;
+          break t;
+        case ce:
+          return le;
+        case de:
+        /* falls through */
+        default:
+          return O;
+      }
+  return i.next_out = l, i.avail_out = _, i.next_in = s, i.avail_in = h, t.hold = r, t.bits = o, (t.wsize || d !== i.avail_out && t.mode < v && (t.mode < at || e !== At)) && ge(i, i.output, i.next_out, d - i.avail_out), w -= i.avail_in, d -= i.avail_out, i.total_in += w, i.total_out += d, t.total += d, t.wrap & 4 && d && (i.adler = t.check = /*UPDATE_CHECK(state.check, strm.next_out - _out, _out);*/
+  t.flags ? R(t.check, a, d, i.next_out - d) : ut(t.check, a, d, i.next_out - d)), i.data_type = t.bits + (t.last ? 64 : 0) + (t.mode === C ? 128 : 0) + (t.mode === X || t.mode === st ? 256 : 0), (w === 0 && d === 0 || e === At) && m === L && (m = ui), m;
+}, Ei = (i) => {
+  if (B(i))
+    return O;
+  let e = i.state;
+  return e.window && (e.window = null), i.state = null, L;
+}, Ai = (i, e) => {
+  if (B(i))
+    return O;
+  const t = i.state;
+  return (t.wrap & 2) === 0 ? O : (t.head = e, e.done = !1, L);
+}, Ti = (i, e) => {
+  const t = e.length;
+  let n, a, s;
+  return B(i) || (n = i.state, n.wrap !== 0 && n.mode !== Q) ? O : n.mode === Q && (a = 1, a = ut(a, e, t, 0), a !== n.check) ? fe : (s = ge(i, e, t, t), s ? (n.mode = ce, le) : (n.havedict = 1, L));
+};
+var mi = _e, vi = pe, Ui = ue, Si = xi, Ii = we, Oi = ki, Ri = Ei, Ci = Ai, Ni = Ti, Di = "pako inflate (from Nodeca project)", D = {
+  inflateReset: mi,
+  inflateReset2: vi,
+  inflateResetKeep: Ui,
+  inflateInit: Si,
+  inflateInit2: Ii,
+  inflate: Oi,
+  inflateEnd: Ri,
+  inflateGetHeader: Ci,
+  inflateSetDictionary: Ni,
+  inflateInfo: Di
+};
+function Mi() {
+  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 Li = Mi;
+const be = Object.prototype.toString, {
+  Z_NO_FLUSH: Bi,
+  Z_FINISH: $i,
+  Z_OK: Z,
+  Z_STREAM_END: ht,
+  Z_NEED_DICT: ft,
+  Z_STREAM_ERROR: Hi,
+  Z_DATA_ERROR: Xt,
+  Z_MEM_ERROR: Fi
+} = se;
+function z(i) {
+  this.options = ae.assign({
+    chunkSize: 1024 * 64,
+    windowBits: 15,
+    to: ""
+  }, i || {});
+  const e = this.options;
+  e.raw && e.windowBits >= 0 && e.windowBits < 16 && (e.windowBits = -e.windowBits, e.windowBits === 0 && (e.windowBits = -15)), e.windowBits >= 0 && e.windowBits < 16 && !(i && i.windowBits) && (e.windowBits += 32), e.windowBits > 15 && e.windowBits < 48 && (e.windowBits & 15) === 0 && (e.windowBits |= 15), this.err = 0, this.msg = "", this.ended = !1, this.chunks = [], this.strm = new ei(), this.strm.avail_out = 0;
+  let t = D.inflateInit2(
+    this.strm,
+    e.windowBits
+  );
+  if (t !== Z)
+    throw new Error(_t[t]);
+  if (this.header = new Li(), D.inflateGetHeader(this.strm, this.header), e.dictionary && (typeof e.dictionary == "string" ? e.dictionary = pt.string2buf(e.dictionary) : be.call(e.dictionary) === "[object ArrayBuffer]" && (e.dictionary = new Uint8Array(e.dictionary)), e.raw && (t = D.inflateSetDictionary(this.strm, e.dictionary), t !== Z)))
+    throw new Error(_t[t]);
+}
+z.prototype.push = function(i, e) {
+  const t = this.strm, n = this.options.chunkSize, a = this.options.dictionary;
+  let s, l, h;
+  if (this.ended) return !1;
+  for (e === ~~e ? l = e : l = e === !0 ? $i : Bi, be.call(i) === "[object ArrayBuffer]" ? t.input = new Uint8Array(i) : t.input = i, t.next_in = 0, t.avail_in = t.input.length; ; ) {
+    for (t.avail_out === 0 && (t.output = new Uint8Array(n), t.next_out = 0, t.avail_out = n), s = D.inflate(t, l), s === ft && a && (s = D.inflateSetDictionary(t, a), s === Z ? s = D.inflate(t, l) : s === Xt && (s = ft)); t.avail_in > 0 && s === ht && t.state.wrap > 0 && i[t.next_in] !== 0; )
+      D.inflateReset(t), s = D.inflate(t, l);
+    switch (s) {
+      case Hi:
+      case Xt:
+      case ft:
+      case Fi:
+        return this.onEnd(s), this.ended = !0, !1;
+    }
+    if (h = t.avail_out, t.next_out && (t.avail_out === 0 || s === ht))
+      if (this.options.to === "string") {
+        let _ = pt.utf8border(t.output, t.next_out), r = t.next_out - _, o = pt.buf2string(t.output, _);
+        t.next_out = r, t.avail_out = n - r, r && t.output.set(t.output.subarray(_, _ + r), 0), this.onData(o);
+      } else
+        this.onData(t.output.length === t.next_out ? t.output : t.output.subarray(0, t.next_out));
+    if (!(s === Z && h === 0)) {
+      if (s === ht)
+        return s = D.inflateEnd(this.strm), this.onEnd(s), this.ended = !0, !0;
+      if (t.avail_in === 0) break;
+    }
+  }
+  return !0;
+};
+z.prototype.onData = function(i) {
+  this.chunks.push(i);
+};
+z.prototype.onEnd = function(i) {
+  i === Z && (this.options.to === "string" ? this.result = this.chunks.join("") : this.result = ae.flattenChunks(this.chunks)), this.chunks = [], this.err = i, this.msg = this.strm.msg;
+};
+function Wi(i, e) {
+  const t = new z(e);
+  if (t.push(i), t.err) throw t.msg || _t[t.err];
+  return t.result;
+}
+var Zi = z, zi = Wi, Pi = {
+  Inflate: Zi,
+  inflate: zi
+};
+const { Inflate: Gi, inflate: Ki } = Pi;
+var jt = Gi, Yi = Ki;
+const xe = [];
+for (let i = 0; i < 256; i++) {
+  let e = i;
+  for (let t = 0; t < 8; t++)
+    e & 1 ? e = 3988292384 ^ e >>> 1 : e = e >>> 1;
+  xe[i] = e;
+}
+const Vt = 4294967295;
+function Xi(i, e, t) {
+  let n = i;
+  for (let a = 0; a < t; a++)
+    n = xe[(n ^ e[a]) & 255] ^ n >>> 8;
+  return n;
+}
+function ji(i, e) {
+  return (Xi(Vt, i, e) ^ Vt) >>> 0;
+}
+function qt(i, e, t) {
+  const n = i.readUint32(), a = ji(new Uint8Array(i.buffer, i.byteOffset + i.offset - e - 4, e), e);
+  if (a !== n)
+    throw new Error(`CRC mismatch for chunk ${t}. Expected ${n}, found ${a}`);
+}
+function ye(i, e, t) {
+  for (let n = 0; n < t; n++)
+    e[n] = i[n];
+}
+function ke(i, e, t, n) {
+  let a = 0;
+  for (; a < n; a++)
+    e[a] = i[a];
+  for (; a < t; a++)
+    e[a] = i[a] + e[a - n] & 255;
+}
+function Ee(i, e, t, n) {
+  let a = 0;
+  if (t.length === 0)
+    for (; a < n; a++)
+      e[a] = i[a];
+  else
+    for (; a < n; a++)
+      e[a] = i[a] + t[a] & 255;
+}
+function Ae(i, e, t, n, a) {
+  let s = 0;
+  if (t.length === 0) {
+    for (; s < a; s++)
+      e[s] = i[s];
+    for (; s < n; s++)
+      e[s] = i[s] + (e[s - a] >> 1) & 255;
+  } else {
+    for (; s < a; s++)
+      e[s] = i[s] + (t[s] >> 1) & 255;
+    for (; s < n; s++)
+      e[s] = i[s] + (e[s - a] + t[s] >> 1) & 255;
+  }
+}
+function Te(i, e, t, n, a) {
+  let s = 0;
+  if (t.length === 0) {
+    for (; s < a; s++)
+      e[s] = i[s];
+    for (; s < n; s++)
+      e[s] = i[s] + e[s - a] & 255;
+  } else {
+    for (; s < a; s++)
+      e[s] = i[s] + t[s] & 255;
+    for (; s < n; s++)
+      e[s] = i[s] + Vi(e[s - a], t[s], t[s - a]) & 255;
+  }
+}
+function Vi(i, e, t) {
+  const n = i + e - t, a = Math.abs(n - i), s = Math.abs(n - e), l = Math.abs(n - t);
+  return a <= s && a <= l ? i : s <= l ? e : t;
+}
+function qi(i, e, t, n, a, s) {
+  switch (i) {
+    case 0:
+      ye(e, t, a);
+      break;
+    case 1:
+      ke(e, t, a, s);
+      break;
+    case 2:
+      Ee(e, t, n, a);
+      break;
+    case 3:
+      Ae(e, t, n, a, s);
+      break;
+    case 4:
+      Te(e, t, n, a, s);
+      break;
+    default:
+      throw new Error(`Unsupported filter: ${i}`);
+  }
+}
+const Ji = new Uint16Array([255]), Qi = new Uint8Array(Ji.buffer), tn = Qi[0] === 255;
+function en(i) {
+  const { data: e, width: t, height: n, channels: a, depth: s } = i, l = [
+    { x: 0, y: 0, xStep: 8, yStep: 8 },
+    // Pass 1
+    { x: 4, y: 0, xStep: 8, yStep: 8 },
+    // Pass 2
+    { x: 0, y: 4, xStep: 4, yStep: 8 },
+    // Pass 3
+    { x: 2, y: 0, xStep: 4, yStep: 4 },
+    // Pass 4
+    { x: 0, y: 2, xStep: 2, yStep: 4 },
+    // Pass 5
+    { x: 1, y: 0, xStep: 2, yStep: 2 },
+    // Pass 6
+    { x: 0, y: 1, xStep: 1, yStep: 2 }
+    // Pass 7
+  ], h = Math.ceil(s / 8) * a, _ = new Uint8Array(n * t * h);
+  let r = 0;
+  for (let o = 0; o < 7; o++) {
+    const w = l[o], d = Math.ceil((t - w.x) / w.xStep), f = Math.ceil((n - w.y) / w.yStep);
+    if (d <= 0 || f <= 0)
+      continue;
+    const u = d * h, U = new Uint8Array(u);
+    for (let x = 0; x < f; x++) {
+      const g = e[r++], T = e.subarray(r, r + u);
+      r += u;
+      const y = new Uint8Array(u);
+      qi(g, T, y, U, u, h), U.set(y);
+      for (let c = 0; c < d; c++) {
+        const E = w.x + c * w.xStep, S = w.y + x * w.yStep;
+        if (!(E >= t || S >= n))
+          for (let p = 0; p < h; p++)
+            _[(S * t + E) * h + p] = y[c * h + p];
+      }
+    }
+  }
+  if (s === 16) {
+    const o = new Uint16Array(_.buffer);
+    if (tn)
+      for (let w = 0; w < o.length; w++)
+        o[w] = nn(o[w]);
+    return o;
+  } else
+    return _;
+}
+function nn(i) {
+  return (i & 255) << 8 | i >> 8 & 255;
+}
+const sn = new Uint16Array([255]), an = new Uint8Array(sn.buffer), rn = an[0] === 255, on = new Uint8Array(0);
+function Jt(i) {
+  const { data: e, width: t, height: n, channels: a, depth: s } = i, l = Math.ceil(s / 8) * a, h = Math.ceil(s / 8 * a * t), _ = new Uint8Array(n * h);
+  let r = on, o = 0, w, d;
+  for (let f = 0; f < n; f++) {
+    switch (w = e.subarray(o + 1, o + 1 + h), d = _.subarray(f * h, (f + 1) * h), e[o]) {
+      case 0:
+        ye(w, d, h);
+        break;
+      case 1:
+        ke(w, d, h, l);
+        break;
+      case 2:
+        Ee(w, d, r, h);
+        break;
+      case 3:
+        Ae(w, d, r, h, l);
+        break;
+      case 4:
+        Te(w, d, r, h, l);
+        break;
+      default:
+        throw new Error(`Unsupported filter: ${e[o]}`);
+    }
+    r = d, o += h + 1;
+  }
+  if (s === 16) {
+    const f = new Uint16Array(_.buffer);
+    if (rn)
+      for (let u = 0; u < f.length; u++)
+        f[u] = hn(f[u]);
+    return f;
+  } else
+    return _;
+}
+function hn(i) {
+  return (i & 255) << 8 | i >> 8 & 255;
+}
+const J = Uint8Array.of(137, 80, 78, 71, 13, 10, 26, 10);
+function Qt(i) {
+  if (!fn(i.readBytes(J.length)))
+    throw new Error("wrong PNG signature");
+}
+function fn(i) {
+  if (i.length < J.length)
+    return !1;
+  for (let e = 0; e < J.length; e++)
+    if (i[e] !== J[e])
+      return !1;
+  return !0;
+}
+const ln = "tEXt", cn = 0, me = new TextDecoder("latin1");
+function dn(i) {
+  if (_n(i), i.length === 0 || i.length > 79)
+    throw new Error("keyword length must be between 1 and 79");
+}
+const un = /^[\u0000-\u00FF]*$/;
+function _n(i) {
+  if (!un.test(i))
+    throw new Error("invalid latin1 text");
+}
+function pn(i, e, t) {
+  const n = ve(e);
+  i[n] = wn(e, t - n.length - 1);
+}
+function ve(i) {
+  for (i.mark(); i.readByte() !== cn; )
+    ;
+  const e = i.offset;
+  i.reset();
+  const t = me.decode(i.readBytes(e - i.offset - 1));
+  return i.skip(1), dn(t), t;
+}
+function wn(i, e) {
+  return me.decode(i.readBytes(e));
+}
+const I = {
+  UNKNOWN: -1,
+  GREYSCALE: 0,
+  TRUECOLOUR: 2,
+  INDEXED_COLOUR: 3,
+  GREYSCALE_ALPHA: 4,
+  TRUECOLOUR_ALPHA: 6
+}, lt = {
+  UNKNOWN: -1,
+  DEFLATE: 0
+}, te = {
+  UNKNOWN: -1,
+  ADAPTIVE: 0
+}, ct = {
+  UNKNOWN: -1,
+  NO_INTERLACE: 0,
+  ADAM7: 1
+}, V = {
+  NONE: 0,
+  BACKGROUND: 1,
+  PREVIOUS: 2
+}, dt = {
+  SOURCE: 0,
+  OVER: 1
+};
+class gn extends wt {
+  _checkCrc;
+  _inflator;
+  _png;
+  _apng;
+  _end;
+  _hasPalette;
+  _palette;
+  _hasTransparency;
+  _transparency;
+  _compressionMethod;
+  _filterMethod;
+  _interlaceMethod;
+  _colorType;
+  _isAnimated;
+  _numberOfFrames;
+  _numberOfPlays;
+  _frames;
+  _writingDataChunks;
+  constructor(e, t = {}) {
+    super(e);
+    const { checkCrc: n = !1 } = t;
+    this._checkCrc = n, this._inflator = new jt(), this._png = {
+      width: -1,
+      height: -1,
+      channels: -1,
+      data: new Uint8Array(0),
+      depth: 1,
+      text: {}
+    }, this._apng = {
+      width: -1,
+      height: -1,
+      channels: -1,
+      depth: 1,
+      numberOfFrames: 1,
+      numberOfPlays: 0,
+      text: {},
+      frames: []
+    }, this._end = !1, this._hasPalette = !1, this._palette = [], this._hasTransparency = !1, this._transparency = new Uint16Array(0), this._compressionMethod = lt.UNKNOWN, this._filterMethod = te.UNKNOWN, this._interlaceMethod = ct.UNKNOWN, this._colorType = I.UNKNOWN, this._isAnimated = !1, this._numberOfFrames = 1, this._numberOfPlays = 0, this._frames = [], this._writingDataChunks = !1, this.setBigEndian();
+  }
+  decode() {
+    for (Qt(this); !this._end; ) {
+      const e = this.readUint32(), t = this.readChars(4);
+      this.decodeChunk(e, t);
+    }
+    return this.decodeImage(), this._png;
+  }
+  decodeApng() {
+    for (Qt(this); !this._end; ) {
+      const e = this.readUint32(), t = this.readChars(4);
+      this.decodeApngChunk(e, t);
+    }
+    return this.decodeApngImage(), this._apng;
+  }
+  // https://www.w3.org/TR/PNG/#5Chunk-layout
+  decodeChunk(e, t) {
+    const n = this.offset;
+    switch (t) {
+      // 11.2 Critical chunks
+      case "IHDR":
+        this.decodeIHDR();
+        break;
+      case "PLTE":
+        this.decodePLTE(e);
+        break;
+      case "IDAT":
+        this.decodeIDAT(e);
+        break;
+      case "IEND":
+        this._end = !0;
+        break;
+      // 11.3 Ancillary chunks
+      case "tRNS":
+        this.decodetRNS(e);
+        break;
+      case "iCCP":
+        this.decodeiCCP(e);
+        break;
+      case ln:
+        pn(this._png.text, this, e);
+        break;
+      case "pHYs":
+        this.decodepHYs();
+        break;
+      default:
+        this.skip(e);
+        break;
+    }
+    if (this.offset - n !== e)
+      throw new Error(`Length mismatch while decoding chunk ${t}`);
+    this._checkCrc ? qt(this, e + 4, t) : this.skip(4);
+  }
+  decodeApngChunk(e, t) {
+    const n = this.offset;
+    switch (t !== "fdAT" && t !== "IDAT" && this._writingDataChunks && this.pushDataToFrame(), t) {
+      case "acTL":
+        this.decodeACTL();
+        break;
+      case "fcTL":
+        this.decodeFCTL();
+        break;
+      case "fdAT":
+        this.decodeFDAT(e);
+        break;
+      default:
+        this.decodeChunk(e, t), this.offset = n + e;
+        break;
+    }
+    if (this.offset - n !== e)
+      throw new Error(`Length mismatch while decoding chunk ${t}`);
+    this._checkCrc ? qt(this, e + 4, t) : this.skip(4);
+  }
+  // https://www.w3.org/TR/PNG/#11IHDR
+  decodeIHDR() {
+    const e = this._png;
+    e.width = this.readUint32(), e.height = this.readUint32(), e.depth = bn(this.readUint8());
+    const t = this.readUint8();
+    this._colorType = t;
+    let n;
+    switch (t) {
+      case I.GREYSCALE:
+        n = 1;
+        break;
+      case I.TRUECOLOUR:
+        n = 3;
+        break;
+      case I.INDEXED_COLOUR:
+        n = 1;
+        break;
+      case I.GREYSCALE_ALPHA:
+        n = 2;
+        break;
+      case I.TRUECOLOUR_ALPHA:
+        n = 4;
+        break;
+      // Kept for exhaustiveness.
+      // eslint-disable-next-line unicorn/no-useless-switch-case
+      case I.UNKNOWN:
+      default:
+        throw new Error(`Unknown color type: ${t}`);
+    }
+    if (this._png.channels = n, this._compressionMethod = this.readUint8(), this._compressionMethod !== lt.DEFLATE)
+      throw new Error(`Unsupported compression method: ${this._compressionMethod}`);
+    this._filterMethod = this.readUint8(), this._interlaceMethod = this.readUint8();
+  }
+  decodeACTL() {
+    this._numberOfFrames = this.readUint32(), this._numberOfPlays = this.readUint32(), this._isAnimated = !0;
+  }
+  decodeFCTL() {
+    const e = {
+      sequenceNumber: this.readUint32(),
+      width: this.readUint32(),
+      height: this.readUint32(),
+      xOffset: this.readUint32(),
+      yOffset: this.readUint32(),
+      delayNumber: this.readUint16(),
+      delayDenominator: this.readUint16(),
+      disposeOp: this.readUint8(),
+      blendOp: this.readUint8(),
+      data: new Uint8Array(0)
+    };
+    this._frames.push(e);
+  }
+  // https://www.w3.org/TR/PNG/#11PLTE
+  decodePLTE(e) {
+    if (e % 3 !== 0)
+      throw new RangeError(`PLTE field length must be a multiple of 3. Got ${e}`);
+    const t = e / 3;
+    this._hasPalette = !0;
+    const n = [];
+    this._palette = n;
+    for (let a = 0; a < t; a++)
+      n.push([this.readUint8(), this.readUint8(), this.readUint8()]);
+  }
+  // https://www.w3.org/TR/PNG/#11IDAT
+  decodeIDAT(e) {
+    this._writingDataChunks = !0;
+    const t = e, n = this.offset + this.byteOffset;
+    if (this._inflator.push(new Uint8Array(this.buffer, n, t)), this._inflator.err)
+      throw new Error(`Error while decompressing the data: ${this._inflator.err}`);
+    this.skip(e);
+  }
+  decodeFDAT(e) {
+    this._writingDataChunks = !0;
+    let t = e, n = this.offset + this.byteOffset;
+    if (n += 4, t -= 4, this._inflator.push(new Uint8Array(this.buffer, n, t)), this._inflator.err)
+      throw new Error(`Error while decompressing the data: ${this._inflator.err}`);
+    this.skip(e);
+  }
+  // https://www.w3.org/TR/PNG/#11tRNS
+  decodetRNS(e) {
+    switch (this._colorType) {
+      case I.GREYSCALE:
+      case I.TRUECOLOUR: {
+        if (e % 2 !== 0)
+          throw new RangeError(`tRNS chunk length must be a multiple of 2. Got ${e}`);
+        if (e / 2 > this._png.width * this._png.height)
+          throw new Error(`tRNS chunk contains more alpha values than there are pixels (${e / 2} vs ${this._png.width * this._png.height})`);
+        this._hasTransparency = !0, this._transparency = new Uint16Array(e / 2);
+        for (let t = 0; t < e / 2; t++)
+          this._transparency[t] = this.readUint16();
+        break;
+      }
+      case I.INDEXED_COLOUR: {
+        if (e > this._palette.length)
+          throw new Error(`tRNS chunk contains more alpha values than there are palette colors (${e} vs ${this._palette.length})`);
+        let t = 0;
+        for (; t < e; t++) {
+          const n = this.readByte();
+          this._palette[t].push(n);
+        }
+        for (; t < this._palette.length; t++)
+          this._palette[t].push(255);
+        break;
+      }
+      // Kept for exhaustiveness.
+      /* eslint-disable unicorn/no-useless-switch-case */
+      case I.UNKNOWN:
+      case I.GREYSCALE_ALPHA:
+      case I.TRUECOLOUR_ALPHA:
+      default:
+        throw new Error(`tRNS chunk is not supported for color type ${this._colorType}`);
+    }
+  }
+  // https://www.w3.org/TR/PNG/#11iCCP
+  decodeiCCP(e) {
+    const t = ve(this), n = this.readUint8();
+    if (n !== lt.DEFLATE)
+      throw new Error(`Unsupported iCCP compression method: ${n}`);
+    const a = this.readBytes(e - t.length - 2);
+    this._png.iccEmbeddedProfile = {
+      name: t,
+      profile: Yi(a)
+    };
+  }
+  // https://www.w3.org/TR/PNG/#11pHYs
+  decodepHYs() {
+    const e = this.readUint32(), t = this.readUint32(), n = this.readByte();
+    this._png.resolution = {
+      x: e,
+      y: t,
+      unit: n
+    };
+  }
+  decodeApngImage() {
+    this._apng.width = this._png.width, this._apng.height = this._png.height, this._apng.channels = this._png.channels, this._apng.depth = this._png.depth, this._apng.numberOfFrames = this._numberOfFrames, this._apng.numberOfPlays = this._numberOfPlays, this._apng.text = this._png.text, this._apng.resolution = this._png.resolution;
+    for (let e = 0; e < this._numberOfFrames; e++) {
+      const t = {
+        sequenceNumber: this._frames[e].sequenceNumber,
+        delayNumber: this._frames[e].delayNumber,
+        delayDenominator: this._frames[e].delayDenominator,
+        data: this._apng.depth === 8 ? new Uint8Array(this._apng.width * this._apng.height * this._apng.channels) : new Uint16Array(this._apng.width * this._apng.height * this._apng.channels)
+      }, n = this._frames.at(e);
+      if (n) {
+        if (n.data = Jt({
+          data: n.data,
+          width: n.width,
+          height: n.height,
+          channels: this._apng.channels,
+          depth: this._apng.depth
+        }), this._hasPalette && (this._apng.palette = this._palette), this._hasTransparency && (this._apng.transparency = this._transparency), e === 0 || n.xOffset === 0 && n.yOffset === 0 && n.width === this._png.width && n.height === this._png.height)
+          t.data = n.data;
+        else {
+          const a = this._apng.frames.at(e - 1);
+          this.disposeFrame(n, a, t), this.addFrameDataToCanvas(t, n);
+        }
+        this._apng.frames.push(t);
+      }
+    }
+    return this._apng;
+  }
+  disposeFrame(e, t, n) {
+    switch (e.disposeOp) {
+      case V.NONE:
+        break;
+      case V.BACKGROUND:
+        for (let a = 0; a < this._png.height; a++)
+          for (let s = 0; s < this._png.width; s++) {
+            const l = (a * e.width + s) * this._png.channels;
+            for (let h = 0; h < this._png.channels; h++)
+              n.data[l + h] = 0;
+          }
+        break;
+      case V.PREVIOUS:
+        n.data.set(t.data);
+        break;
+      default:
+        throw new Error("Unknown disposeOp");
+    }
+  }
+  addFrameDataToCanvas(e, t) {
+    const n = 1 << this._png.depth, a = (s, l) => {
+      const h = ((s + t.yOffset) * this._png.width + t.xOffset + l) * this._png.channels, _ = (s * t.width + l) * this._png.channels;
+      return { index: h, frameIndex: _ };
+    };
+    switch (t.blendOp) {
+      case dt.SOURCE:
+        for (let s = 0; s < t.height; s++)
+          for (let l = 0; l < t.width; l++) {
+            const { index: h, frameIndex: _ } = a(s, l);
+            for (let r = 0; r < this._png.channels; r++)
+              e.data[h + r] = t.data[_ + r];
+          }
+        break;
+      // https://www.w3.org/TR/png-3/#13Alpha-channel-processing
+      case dt.OVER:
+        for (let s = 0; s < t.height; s++)
+          for (let l = 0; l < t.width; l++) {
+            const { index: h, frameIndex: _ } = a(s, l);
+            for (let r = 0; r < this._png.channels; r++) {
+              const o = t.data[_ + this._png.channels - 1] / n, w = r % (this._png.channels - 1) === 0 ? 1 : t.data[_ + r], d = Math.floor(o * w + (1 - o) * e.data[h + r]);
+              e.data[h + r] += d;
+            }
+          }
+        break;
+      default:
+        throw new Error("Unknown blendOp");
+    }
+  }
+  decodeImage() {
+    if (this._inflator.err)
+      throw new Error(`Error while decompressing the data: ${this._inflator.err}`);
+    const e = this._isAnimated ? (this._frames?.at(0)).data : this._inflator.result;
+    if (this._filterMethod !== te.ADAPTIVE)
+      throw new Error(`Filter method ${this._filterMethod} not supported`);
+    if (this._interlaceMethod === ct.NO_INTERLACE)
+      this._png.data = Jt({
+        data: e,
+        width: this._png.width,
+        height: this._png.height,
+        channels: this._png.channels,
+        depth: this._png.depth
+      });
+    else if (this._interlaceMethod === ct.ADAM7)
+      this._png.data = en({
+        data: e,
+        width: this._png.width,
+        height: this._png.height,
+        channels: this._png.channels,
+        depth: this._png.depth
+      });
+    else
+      throw new Error(`Interlace method ${this._interlaceMethod} not supported`);
+    this._hasPalette && (this._png.palette = this._palette), this._hasTransparency && (this._png.transparency = this._transparency);
+  }
+  pushDataToFrame() {
+    const e = this._inflator.result, t = this._frames.at(-1);
+    t ? t.data = e : this._frames.push({
+      sequenceNumber: 0,
+      width: this._png.width,
+      height: this._png.height,
+      xOffset: 0,
+      yOffset: 0,
+      delayNumber: 0,
+      delayDenominator: 0,
+      disposeOp: V.NONE,
+      blendOp: dt.SOURCE,
+      data: e
+    }), this._inflator = new jt(), this._writingDataChunks = !1;
+  }
+}
+function bn(i) {
+  if (i !== 1 && i !== 2 && i !== 4 && i !== 8 && i !== 16)
+    throw new Error(`invalid bit depth: ${i}`);
+  return i;
+}
+function xn(i, e) {
+  return new gn(i, e).decode();
+}
+class yn {
+  bottomLeft;
+  ptWidth;
+  ptHeight;
+  xSpacing;
+  ySpacing;
+  elevs;
+  constructor(e, t, n, a, s, l) {
+    this.bottomLeft = t, this.ptWidth = n, this.ptHeight = a, this.elevs = e, this.xSpacing = s, this.ySpacing = l;
+  }
+  // Uses bilinear interpolation
+  // Based on Footnav code
+  // x,y must be in projection of the geometry with scaling factor 
+  // already applied
+  getHeight(e, t) {
+    let n = [e, t], a = Math.floor((n[0] - this.bottomLeft.e) / this.xSpacing), s = this.ptHeight - Math.ceil((n[1] - this.bottomLeft.n) / this.ySpacing), l, h, _, r, o, w, d, f = Number.NEGATIVE_INFINITY;
+    if (a >= 0 && s >= 0 && a < this.ptWidth - 1 && s < this.ptHeight - 1) {
+      r = this.elevs[s * this.ptWidth + a], o = this.elevs[s * this.ptWidth + a + 1], w = this.elevs[s * this.ptWidth + a + this.ptWidth], d = this.elevs[s * this.ptWidth + a + this.ptWidth + 1], l = this.bottomLeft[0] + a * this.xSpacing, l + this.xSpacing, h = this.bottomLeft[1] + (this.ptHeight - 1 - s) * this.ySpacing, _ = h - this.ySpacing;
+      let u = (n[0] - l) / this.xSpacing, U = r * (1 - u) + o * u, x = w * (1 - u) + d * u, g = (n[1] - _) / this.ySpacing;
+      f = x * (1 - g) + U * g;
+    }
+    return f;
+  }
+}
+class kn extends ee {
+  constructor(e) {
+    super(e);
+  }
+  async readTile(e) {
+    const n = await (await fetch(e)).arrayBuffer(), a = xn(n);
+    let s, l = 0;
+    const h = new Array(a.width * a.height);
+    for (let _ = 0; _ < a.height; _++)
+      for (let r = 0; r < a.width; r++)
+        s = (_ * a.width + r) * a.channels, h[l++] = Math.round(a.data[s] * 256 + a.data[s + 1] + a.data[s + 2] / 256 - 32768);
+    return { w: a.width, h: a.height, elevs: h };
+  }
+  getElevation(e) {
+    const t = this.getTile(e, this.tile.z), n = this.dataTiles[`${t.z}/${t.x}/${t.y}`];
+    return n ? n.getHeight(e[0], e[1]) : Number.NEGATIVE_INFINITY;
+  }
+  getElevationFromLonLat(e) {
+    return this.getElevation(this.sphMerc.project(e));
+  }
+  // Overridden to store each tile as a DEM object
+  rawTileToStoredTile(e, t) {
+    const n = e.getTopRight(), a = e.getBottomLeft(), s = (n.e - a.e) / (t.w - 1), l = (n.n - a.n) / (t.h - 1), h = new yn(
+      t.elevs,
+      a,
+      t.w,
+      t.h,
+      s,
+      l
+    );
+    return { tile: e, data: h };
+  }
+}
+class En extends ee {
+  constructor(e) {
+    super(e);
+  }
+  async readTile(e) {
+    return await (await fetch(e)).json();
+  }
+}
+class An {
+  e;
+  n;
+  constructor(e, t) {
+    this.e = e, this.n = t;
+  }
+}
+class Tn {
+  lon;
+  lat;
+  constructor(e, t) {
+    this.lon = e, this.lat = t;
+  }
+}
+export {
+  N as Constants,
+  yn as DEM,
+  kn as DemTiler,
+  An as EastNorth,
+  En as JsonTiler,
+  Tn as LonLat,
+  Ue as SphMercProjection,
+  q as Tile,
+  ee as Tiler
+};