maplibre-gl-components 0.16.2 → 0.17.0

package/dist/geotiff-Bzy-Zyc2.js

@@ -0,0 +1,1882 @@
+import { cn as it, on as at } from "./ControlGrid-C6zp03Vq.js";
+import "./basedecoder-BliCKuUS.js";
+import { a as nt, i as y, l as Q, o as G, s as x, t as ot, u as te } from "./globals-BKIWameS.js";
+var lt = "Cannot convert undefined or null to object";
+function A(e) {
+  return (t, ...r) => ct(e, t, r);
+}
+function B(e, t) {
+  return A(ge(e, t).get);
+}
+var { apply: ct, construct: Nr, defineProperty: Lr, get: Cr, getOwnPropertyDescriptor: ge, getPrototypeOf: se, has: zr, ownKeys: ht, set: Gr, setPrototypeOf: qr } = Reflect, { EPSILON: ft, MAX_SAFE_INTEGER: jr, isFinite: Hr, isNaN: Yr } = Number, { iterator: Y, species: $r, toStringTag: ut, for: Xr } = Symbol, ie = Object, { create: ye, defineProperty: dt, freeze: Kr, is: Zr } = ie, fe = ie.prototype, Jr = fe.__lookupGetter__ ? A(fe.__lookupGetter__) : (e, t) => {
+  if (e == null) throw It(lt);
+  let r = ie(e);
+  do {
+    const s = ge(r, t);
+    if (s !== void 0)
+      return gt(s, "get") ? s.get : void 0;
+  } while ((r = se(r)) !== null);
+}, gt = ie.hasOwn || A(fe.hasOwnProperty), De = Array, Qr = De.isArray, ae = De.prototype, Wr = A(ae.join), es = A(ae.push), ts = A(ae.toLocaleString), Oe = ae[Y], yt = A(Oe), { abs: rs, trunc: ss } = Math, pe = ArrayBuffer, is = pe.isView, Re = pe.prototype, as = A(Re.slice), ns = B(Re, "byteLength"), xe = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : null, os = xe && B(xe.prototype, "byteLength"), Me = se(Uint8Array), ls = Me.from, E = Me.prototype, cs = E[Y], hs = A(E.keys), fs = A(E.values), us = A(E.entries), ds = A(E.set), gs = A(E.reverse), ys = A(E.fill), ps = A(E.copyWithin), ws = A(E.sort), ms = A(E.slice), bs = A(E.subarray), vs = B(E, "buffer"), Is = B(E, "byteOffset"), As = B(E, "length"), Ts = B(E, ut), pt = Uint8Array, Be = Uint16Array, we = Uint32Array, wt = Float32Array, q = se([][Y]()), Ve = A(q.next), mt = A((function* () {
+})().next), bt = se(q), Ue = DataView.prototype, vt = A(Ue.getUint16), Ss = A(Ue.setUint16), It = TypeError, At = WeakSet, Ne = At.prototype, Es = A(Ne.add), _s = A(Ne.has), me = WeakMap, be = me.prototype, Le = A(be.get), xs = A(be.has), Tt = A(be.set), Ce = new me(), St = ye(null, {
+  next: { value: function() {
+    return Ve(Le(Ce, this));
+  } },
+  [Y]: { value: function() {
+    return this;
+  } }
+});
+function Et(e) {
+  if (e[Y] === Oe && q.next === Ve) return e;
+  const t = ye(St);
+  return Tt(Ce, t, yt(e)), t;
+}
+var _t = new me(), xt = ye(bt, { next: {
+  value: function() {
+    return mt(Le(_t, this));
+  },
+  writable: !0,
+  configurable: !0
+} });
+for (const e of ht(q))
+  e !== "next" && dt(xt, e, ge(q, e));
+var kt = 1 / ft, Pt = 6103515625e-14, ze = 9765625e-10, ks = ze * Pt, Ps = ze * kt, Ge = new pe(4), Ft = new wt(Ge), Dt = new we(Ge), F = new Be(512), D = new pt(512);
+for (let e = 0; e < 256; ++e) {
+  const t = e - 127;
+  t < -24 ? (F[e] = 0, F[e | 256] = 32768, D[e] = 24, D[e | 256] = 24) : t < -14 ? (F[e] = 1024 >> -t - 14, F[e | 256] = 1024 >> -t - 14 | 32768, D[e] = -t - 1, D[e | 256] = -t - 1) : t <= 15 ? (F[e] = t + 15 << 10, F[e | 256] = t + 15 << 10 | 32768, D[e] = 13, D[e | 256] = 13) : t < 128 ? (F[e] = 31744, F[e | 256] = 64512, D[e] = 24, D[e | 256] = 24) : (F[e] = 31744, F[e | 256] = 64512, D[e] = 13, D[e | 256] = 13);
+}
+var ve = new we(2048);
+for (let e = 1; e < 1024; ++e) {
+  let t = e << 13, r = 0;
+  for (; (t & 8388608) === 0; )
+    t <<= 1, r -= 8388608;
+  t &= -8388609, r += 947912704, ve[e] = t | r;
+}
+for (let e = 1024; e < 2048; ++e) ve[e] = 939524096 + (e - 1024 << 13);
+var V = new we(64);
+for (let e = 1; e < 31; ++e) V[e] = e << 23;
+V[31] = 1199570944;
+V[32] = 2147483648;
+for (let e = 33; e < 63; ++e) V[e] = 2147483648 + (e - 32 << 23);
+V[63] = 3347054592;
+var qe = new Be(64);
+for (let e = 1; e < 64; ++e) e !== 32 && (qe[e] = 1024);
+function Ot(e) {
+  const t = e >> 10;
+  return Dt[0] = ve[qe[t] + (e & 1023)] + V[t], Ft[0];
+}
+function je(e, t, ...r) {
+  return Ot(vt(e, t, ...Et(r)));
+}
+function le(e, t, r) {
+  const s = r && r.debug || !1;
+  s && console.log("[xml-utils] getting " + t + " in " + e);
+  const i = typeof e == "object" ? e.outer : e, a = i.slice(0, i.indexOf(">") + 1), o = ['"', "'"];
+  for (let n = 0; n < o.length; n++) {
+    const f = o[n], l = t + "\\=" + f + "([^" + f + "]*)" + f;
+    s && console.log("[xml-utils] pattern:", l);
+    const c = new RegExp(l).exec(a);
+    if (s && console.log("[xml-utils] match:", c), c) return c[1];
+  }
+}
+function Rt(e, t, r) {
+  const s = new RegExp(t).exec(e.slice(r));
+  return s ? r + s.index : -1;
+}
+function ke(e, t, r) {
+  const s = new RegExp(t).exec(e.slice(r));
+  return s ? r + s.index + s[0].length - 1 : -1;
+}
+function Pe(e, t) {
+  const r = new RegExp(t, "g"), s = e.match(r);
+  return s ? s.length : 0;
+}
+function Mt(e, t, r) {
+  const s = r && r.debug || !1, i = r && r.startIndex || 0;
+  s && console.log("[xml-utils] starting findTagByName with", t, " and ", r);
+  const a = Rt(e, `<${t}[ 
+>/]`, i);
+  if (s && console.log("[xml-utils] start:", a), a === -1) return;
+  const o = e.slice(a + t.length);
+  let n = ke(o, "^[^<]*[ /]>", 0);
+  const f = n !== -1 && o[n - 1] === "/";
+  if (s && console.log("[xml-utils] selfClosing:", f), f === !1) {
+    let d = 0, u = 1, g = 0;
+    for (; (n = ke(o, "[ /]" + t + ">", d)) !== -1; ) {
+      const p = o.substring(d, n + 1);
+      if (u += Pe(p, "<" + t + `[ 
+	>]`), g += Pe(p, "</" + t + ">"), g >= u) break;
+      d = n;
+    }
+  }
+  const l = a + t.length + n + 1;
+  if (s && console.log("[xml-utils] end:", l), l === -1) return;
+  const c = e.slice(a, l);
+  let h;
+  return f ? h = null : h = c.slice(c.indexOf(">") + 1, c.lastIndexOf("<")), {
+    inner: h,
+    outer: c,
+    start: a,
+    end: l
+  };
+}
+function Bt(e, t, r) {
+  const s = [], i = r && r.debug || !1, a = r && typeof r.nested == "boolean" ? r.nested : !0;
+  let o = r && r.startIndex || 0, n;
+  for (; n = Mt(e, t, {
+    debug: i,
+    startIndex: o
+  }); )
+    a ? o = n.start + 1 + t.length : o = n.end, s.push(n);
+  return i && console.log("findTagsByName found", s.length, "tags"), s;
+}
+function Vt(e, t) {
+  const { width: r, height: s } = e, i = new Uint8Array(r * s * 3);
+  let a;
+  for (let o = 0, n = 0; o < e.length; ++o, n += 3)
+    a = 256 - e[o] / t * 256, i[n] = a, i[n + 1] = a, i[n + 2] = a;
+  return i;
+}
+function Ut(e, t) {
+  const { width: r, height: s } = e, i = new Uint8Array(r * s * 3);
+  let a;
+  for (let o = 0, n = 0; o < e.length; ++o, n += 3)
+    a = e[o] / t * 256, i[n] = a, i[n + 1] = a, i[n + 2] = a;
+  return i;
+}
+function Nt(e, t) {
+  const { width: r, height: s } = e, i = new Uint8Array(r * s * 3), a = t.length / 3, o = t.length / 3 * 2;
+  for (let n = 0, f = 0; n < e.length; ++n, f += 3) {
+    const l = e[n];
+    i[f] = t[l] / 65536 * 256, i[f + 1] = t[l + a] / 65536 * 256, i[f + 2] = t[l + o] / 65536 * 256;
+  }
+  return i;
+}
+function Lt(e) {
+  const { width: t, height: r } = e, s = new Uint8Array(t * r * 3);
+  for (let i = 0, a = 0; i < e.length; i += 4, a += 3) {
+    const o = e[i], n = e[i + 1], f = e[i + 2], l = e[i + 3];
+    s[a] = 255 * ((255 - o) / 256) * ((255 - l) / 256), s[a + 1] = 255 * ((255 - n) / 256) * ((255 - l) / 256), s[a + 2] = 255 * ((255 - f) / 256) * ((255 - l) / 256);
+  }
+  return s;
+}
+function Ct(e) {
+  const { width: t, height: r } = e, s = new Uint8ClampedArray(t * r * 3);
+  for (let i = 0, a = 0; i < e.length; i += 3, a += 3) {
+    const o = e[i], n = e[i + 1], f = e[i + 2];
+    s[a] = o + 1.402 * (f - 128), s[a + 1] = o - 0.34414 * (n - 128) - 0.71414 * (f - 128), s[a + 2] = o + 1.772 * (n - 128);
+  }
+  return s;
+}
+var zt = 0.95047, Gt = 1, qt = 1.08883;
+function jt(e) {
+  const { width: t, height: r } = e, s = new Uint8Array(t * r * 3);
+  for (let i = 0, a = 0; i < e.length; i += 3, a += 3) {
+    const o = e[i + 0], n = e[i + 1] << 24 >> 24, f = e[i + 2] << 24 >> 24;
+    let l = (o + 16) / 116, c = n / 500 + l, h = l - f / 200, d, u, g;
+    c = zt * (c * c * c > 8856e-6 ? c * c * c : (c - 16 / 116) / 7.787), l = Gt * (l * l * l > 8856e-6 ? l * l * l : (l - 16 / 116) / 7.787), h = qt * (h * h * h > 8856e-6 ? h * h * h : (h - 16 / 116) / 7.787), d = c * 3.2406 + l * -1.5372 + h * -0.4986, u = c * -0.9689 + l * 1.8758 + h * 0.0415, g = c * 0.0557 + l * -0.204 + h * 1.057, d = d > 31308e-7 ? 1.055 * d ** (1 / 2.4) - 0.055 : 12.92 * d, u = u > 31308e-7 ? 1.055 * u ** (1 / 2.4) - 0.055 : 12.92 * u, g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : 12.92 * g, s[a] = Math.max(0, Math.min(1, d)) * 255, s[a + 1] = Math.max(0, Math.min(1, u)) * 255, s[a + 2] = Math.max(0, Math.min(1, g)) * 255;
+  }
+  return s;
+}
+var j = /* @__PURE__ */ new Map();
+async function ee(e) {
+  const t = !e.hasTag("StripOffsets");
+  return {
+    tileWidth: t ? await e.loadValue("TileWidth") : await e.loadValue("ImageWidth"),
+    tileHeight: t ? await e.loadValue("TileLength") : await e.loadValue("RowsPerStrip") || await e.loadValue("ImageLength"),
+    planarConfiguration: await e.loadValue("PlanarConfiguration"),
+    bitsPerSample: await e.loadValue("BitsPerSample"),
+    predictor: await e.loadValue("Predictor") || 1
+  };
+}
+function Ht(e, t, r = ee, s = !0) {
+  Array.isArray(e) || (e = [e]), e.forEach((i) => {
+    j.set(i, {
+      importFn: t,
+      decoderParameterFn: r,
+      preferWorker: s
+    });
+  });
+}
+async function Yt(e, t) {
+  if (!j.has(e)) throw new Error(`Unknown compression method identifier: ${e}`);
+  const { decoderParameterFn: r } = j.get(e);
+  return r(t);
+}
+async function $t(e, t) {
+  if (!j.has(e)) throw new Error(`Unknown compression method identifier: ${e}`);
+  const { importFn: r } = j.get(e);
+  return new (await r())(t);
+}
+var Xt = [
+  {
+    cases: [void 0, 1],
+    importFn: () => import("./raw-Brljg6vy.js").then((e) => e.default),
+    preferWorker: !1
+  },
+  {
+    cases: 5,
+    importFn: () => import("./lzw-DF5VHuii.js").then((e) => e.default)
+  },
+  {
+    cases: 6,
+    importFn: () => {
+      throw new Error("old style JPEG compression is not supported.");
+    }
+  },
+  {
+    cases: 7,
+    importFn: () => import("./jpeg-CJcNvScS.js").then((e) => e.default),
+    decoderParameterFn: async (e) => ({
+      ...await ee(e),
+      JPEGTables: await e.loadValue("JPEGTables")
+    })
+  },
+  {
+    cases: [8, 32946],
+    importFn: () => import("./deflate-DBL0msKQ.js").then((e) => e.default)
+  },
+  {
+    cases: 32773,
+    importFn: () => import("./packbits-CK8RPU_B.js").then((e) => e.default)
+  },
+  {
+    cases: 34887,
+    importFn: () => import("./lerc-2QwcA_K7.js").then(async (e) => (await e.zstd.init(), e)).then((e) => e.default),
+    decoderParameterFn: async (e) => ({
+      ...await ee(e),
+      LercParameters: await e.loadValue("LercParameters")
+    })
+  },
+  {
+    cases: 5e4,
+    importFn: () => import("./zstd-BwwN0X3K.js").then(async (e) => (await e.zstd.init(), e)).then((e) => e.default)
+  },
+  {
+    cases: 50001,
+    importFn: () => import("./webimage-rg-Z9Sbn.js").then((e) => e.default),
+    decoderParameterFn: async (e) => ({
+      ...await ee(e),
+      samplesPerPixel: Number(await e.loadValue("SamplesPerPixel")) || 4
+    }),
+    preferWorker: !1
+  }
+];
+for (const e of Xt) {
+  const { cases: t, importFn: r, decoderParameterFn: s, preferWorker: i } = e;
+  Ht(t, r, s, i);
+}
+function ne(e, t, r, s = 1) {
+  return new (Object.getPrototypeOf(e)).constructor(t * r * s);
+}
+function Kt(e, t, r, s, i) {
+  const a = t / s, o = r / i;
+  return e.map((n) => {
+    const f = ne(n, s, i);
+    for (let l = 0; l < i; ++l) {
+      const c = Math.min(Math.round(o * l), r - 1);
+      for (let h = 0; h < s; ++h) {
+        const d = Math.min(Math.round(a * h), t - 1), u = n[c * t + d];
+        f[l * s + h] = u;
+      }
+    }
+    return f;
+  });
+}
+function M(e, t, r) {
+  return (1 - r) * e + r * t;
+}
+function Zt(e, t, r, s, i) {
+  const a = t / s, o = r / i;
+  return e.map((n) => {
+    const f = ne(n, s, i);
+    for (let l = 0; l < i; ++l) {
+      const c = o * l, h = Math.floor(c), d = Math.min(Math.ceil(c), r - 1);
+      for (let u = 0; u < s; ++u) {
+        const g = a * u, p = g % 1, w = Math.floor(g), m = Math.min(Math.ceil(g), t - 1), b = n[h * t + w], I = n[h * t + m], S = n[d * t + w], v = n[d * t + m], T = M(M(b, I, p), M(S, v, p), c % 1);
+        f[l * s + u] = T;
+      }
+    }
+    return f;
+  });
+}
+function Jt(e, t, r, s, i, a = "nearest") {
+  switch (a.toLowerCase()) {
+    case "nearest":
+      return Kt(e, t, r, s, i);
+    case "bilinear":
+    case "linear":
+      return Zt(e, t, r, s, i);
+    default:
+      throw new Error(`Unsupported resampling method: '${a}'`);
+  }
+}
+function Qt(e, t, r, s, i, a) {
+  const o = t / s, n = r / i, f = ne(e, s, i, a);
+  for (let l = 0; l < i; ++l) {
+    const c = Math.min(Math.round(n * l), r - 1);
+    for (let h = 0; h < s; ++h) {
+      const d = Math.min(Math.round(o * h), t - 1);
+      for (let u = 0; u < a; ++u) {
+        const g = e[c * t * a + d * a + u];
+        f[l * s * a + h * a + u] = g;
+      }
+    }
+  }
+  return f;
+}
+function Wt(e, t, r, s, i, a) {
+  const o = t / s, n = r / i, f = ne(e, s, i, a);
+  for (let l = 0; l < i; ++l) {
+    const c = n * l, h = Math.floor(c), d = Math.min(Math.ceil(c), r - 1);
+    for (let u = 0; u < s; ++u) {
+      const g = o * u, p = g % 1, w = Math.floor(g), m = Math.min(Math.ceil(g), t - 1);
+      for (let b = 0; b < a; ++b) {
+        const I = e[h * t * a + w * a + b], S = e[h * t * a + m * a + b], v = e[d * t * a + w * a + b], T = e[d * t * a + m * a + b], k = M(M(I, S, p), M(v, T, p), c % 1);
+        f[l * s * a + u * a + b] = k;
+      }
+    }
+  }
+  return f;
+}
+function er(e, t, r, s, i, a, o = "nearest") {
+  switch (o.toLowerCase()) {
+    case "nearest":
+      return Qt(e, t, r, s, i, a);
+    case "bilinear":
+    case "linear":
+      return Wt(e, t, r, s, i, a);
+    default:
+      throw new Error(`Unsupported resampling method: '${o}'`);
+  }
+}
+function tr(e, t, r) {
+  let s = 0;
+  for (let i = t; i < r; ++i) s += e[i];
+  return s;
+}
+function ue(e, t, r) {
+  let s;
+  switch (e) {
+    case 1:
+      t <= 8 ? s = Uint8Array : t <= 16 ? s = Uint16Array : t <= 32 && (s = Uint32Array);
+      break;
+    case 2:
+      t === 8 ? s = Int8Array : t === 16 ? s = Int16Array : t === 32 && (s = Int32Array);
+      break;
+    case 3:
+      switch (t) {
+        case 16:
+        case 32:
+          s = Float32Array;
+          break;
+        case 64:
+          s = Float64Array;
+          break;
+        default:
+          break;
+      }
+      break;
+    default:
+      break;
+  }
+  if (s) {
+    if (typeof r == "number") return new s(r);
+    if (r instanceof ArrayBuffer) return new s(r);
+  }
+  throw Error("Unsupported data format/bitsPerSample");
+}
+function rr(e, t) {
+  return (e === 1 || e === 2) && t <= 32 && t % 8 === 0 ? !1 : !(e === 3 && (t === 16 || t === 32 || t === 64));
+}
+function sr(e, t, r, s, i, a, o) {
+  const n = new DataView(e), f = r === 2 ? o * a : o * a * s, l = r === 2 ? 1 : s, c = ue(t, i, f), h = parseInt("1".repeat(i), 2);
+  if (t === 1) {
+    let d;
+    r === 1 ? d = s * i : d = i;
+    let u = a * d;
+    (u & 7) !== 0 && (u = u + 7 & -8);
+    for (let g = 0; g < o; ++g) {
+      const p = g * u;
+      for (let w = 0; w < a; ++w) {
+        const m = p + w * l * i;
+        for (let b = 0; b < l; ++b) {
+          const I = m + b * i, S = (g * a + w) * l + b, v = Math.floor(I / 8), T = I % 8;
+          T + i <= 8 ? c[S] = n.getUint8(v) >> 8 - i - T & h : T + i <= 16 ? c[S] = n.getUint16(v) >> 16 - i - T & h : T + i <= 24 ? c[S] = (n.getUint16(v) << 8 | n.getUint8(v + 2)) >> 24 - i - T & h : c[S] = n.getUint32(v) >> 32 - i - T & h;
+        }
+      }
+    }
+  }
+  return c.buffer;
+}
+var ir = class {
+  constructor(e, t, r, s) {
+    this.fileDirectory = e, this.littleEndian = t, this.tiles = r ? [] : null, this.isTiled = !e.hasTag("StripOffsets");
+    const i = e.getValue("PlanarConfiguration") ?? 1;
+    if (i !== 1 && i !== 2) throw new Error("Invalid planar configuration.");
+    this.planarConfiguration = i, this.source = s;
+  }
+  getFileDirectory() {
+    return this.fileDirectory;
+  }
+  getGeoKeys() {
+    return this.fileDirectory.parseGeoKeyDirectory();
+  }
+  getWidth() {
+    return this.fileDirectory.getValue("ImageWidth") || 0;
+  }
+  getHeight() {
+    return this.fileDirectory.getValue("ImageLength") || 0;
+  }
+  getSamplesPerPixel() {
+    return this.fileDirectory.getValue("SamplesPerPixel") ?? 1;
+  }
+  getTileWidth() {
+    return this.isTiled ? this.fileDirectory.getValue("TileWidth") || 0 : this.getWidth();
+  }
+  getTileHeight() {
+    if (this.isTiled) return this.fileDirectory.getValue("TileLength") || 0;
+    const e = this.fileDirectory.hasTag("RowsPerStrip") && this.fileDirectory.getValue("RowsPerStrip");
+    return e ? Math.min(e, this.getHeight()) : this.getHeight();
+  }
+  getBlockWidth() {
+    return this.getTileWidth();
+  }
+  getBlockHeight(e) {
+    return this.isTiled || (e + 1) * this.getTileHeight() <= this.getHeight() ? this.getTileHeight() : this.getHeight() - e * this.getTileHeight();
+  }
+  getBytesPerPixel() {
+    let e = 0;
+    const t = this.fileDirectory.getValue("BitsPerSample") || [];
+    for (let r = 0; r < t.length; ++r) e += this.getSampleByteSize(r);
+    return e;
+  }
+  getSampleByteSize(e) {
+    const t = this.fileDirectory.getValue("BitsPerSample") || [];
+    if (e >= t.length) throw new RangeError(`Sample index ${e} is out of range.`);
+    return Math.ceil(t[e] / 8);
+  }
+  getReaderForSample(e) {
+    const t = this.fileDirectory.getValue("SampleFormat"), r = t ? t[e] : 1, s = (this.fileDirectory.getValue("BitsPerSample") || [])[e];
+    switch (r) {
+      case 1:
+        if (s <= 8) return DataView.prototype.getUint8;
+        if (s <= 16) return DataView.prototype.getUint16;
+        if (s <= 32) return DataView.prototype.getUint32;
+        break;
+      case 2:
+        if (s <= 8) return DataView.prototype.getInt8;
+        if (s <= 16) return DataView.prototype.getInt16;
+        if (s <= 32) return DataView.prototype.getInt32;
+        break;
+      case 3:
+        switch (s) {
+          case 16:
+            return function(i, a) {
+              return je(this, i, a);
+            };
+          case 32:
+            return DataView.prototype.getFloat32;
+          case 64:
+            return DataView.prototype.getFloat64;
+          default:
+            break;
+        }
+        break;
+      default:
+        break;
+    }
+    throw Error("Unsupported data format/bitsPerSample");
+  }
+  getSampleFormat(e = 0) {
+    const t = this.fileDirectory.getValue("SampleFormat");
+    return t ? t[e] : 1;
+  }
+  getBitsPerSample(e = 0) {
+    const t = this.fileDirectory.getValue("BitsPerSample");
+    return t ? t[e] : 0;
+  }
+  getArrayForSample(e, t) {
+    return ue(this.getSampleFormat(e), this.getBitsPerSample(e), t);
+  }
+  async getTileOrStrip(e, t, r, s, i) {
+    const a = Math.ceil(this.getWidth() / this.getTileWidth()), o = Math.ceil(this.getHeight() / this.getTileHeight());
+    let n;
+    const { tiles: f } = this;
+    if (this.planarConfiguration === 1 ? n = t * a + e : this.planarConfiguration === 2 && (n = r * a * o + t * a + e), n === void 0) throw new Error("Could not determine tile or strip index.");
+    let l, c;
+    if (this.isTiled ? (l = Number(await this.fileDirectory.loadValueIndexed("TileOffsets", n)), c = Number(await this.fileDirectory.loadValueIndexed("TileByteCounts", n))) : (l = Number(await this.fileDirectory.loadValueIndexed("StripOffsets", n)), c = Number(await this.fileDirectory.loadValueIndexed("StripByteCounts", n))), c === 0) {
+      const u = this.getBlockHeight(t) * this.getTileWidth(), g = this.planarConfiguration === 2 ? this.getSampleByteSize(r) : this.getBytesPerPixel(), p = new ArrayBuffer(u * g);
+      return this.getArrayForSample(r, p).fill(this.getGDALNoData() || 0), {
+        x: e,
+        y: t,
+        sample: r,
+        data: p
+      };
+    }
+    const h = (await this.source.fetch([{
+      offset: l,
+      length: c
+    }], i))[0];
+    let d;
+    return f === null || !f[n] ? (d = (async () => {
+      let u = await s.decode(h);
+      const g = this.getSampleFormat(), p = this.getBitsPerSample();
+      return rr(g, p) && (u = sr(u, g, this.planarConfiguration, this.getSamplesPerPixel(), p, this.getTileWidth(), this.getBlockHeight(t))), u;
+    })(), f !== null && (f[n] = d)) : d = f[n], {
+      x: e,
+      y: t,
+      sample: r,
+      data: await d
+    };
+  }
+  async _readRaster(e, t, r, s, i, a, o, n, f) {
+    const l = this.getTileWidth(), c = this.getTileHeight(), h = this.getWidth(), d = this.getHeight(), u = Math.max(Math.floor(e[0] / l), 0), g = Math.min(Math.ceil(e[2] / l), Math.ceil(h / l)), p = Math.max(Math.floor(e[1] / c), 0), w = Math.min(Math.ceil(e[3] / c), Math.ceil(d / c)), m = e[2] - e[0];
+    let b = this.getBytesPerPixel();
+    const I = [], S = [];
+    for (let _ = 0; _ < t.length; ++_) {
+      if (this.planarConfiguration === 1) {
+        const P = await this.fileDirectory.loadValue("BitsPerSample");
+        if (typeof P != "object") throw new Error("Expected BitsPerSample to be an array or typed array.");
+        I.push(tr(P, 0, t[_]) / 8);
+      } else I.push(0);
+      S.push(this.getReaderForSample(t[_]));
+    }
+    const v = [], { littleEndian: T } = this;
+    for (let _ = p; _ < w; ++_) for (let P = u; P < g; ++P) {
+      let $;
+      this.planarConfiguration === 1 && ($ = this.getTileOrStrip(P, _, 0, i, f));
+      for (let X = 0; X < t.length; ++X) {
+        const K = X, Ee = t[X];
+        if (this.planarConfiguration === 2 && (b = this.getSampleByteSize(Ee), $ = this.getTileOrStrip(P, _, Ee, i, f)), !$) throw new Error("Could not get tile or strip data.");
+        const Ke = $.then((U) => {
+          const Ze = U.data, Je = new DataView(Ze), oe = this.getBlockHeight(U.y), N = U.y * c, Z = U.x * l, Qe = N + oe, We = (U.x + 1) * l, et = S[K], tt = Math.min(oe, oe - (Qe - e[3]), d - N), rt = Math.min(l, l - (We - e[2]), h - Z);
+          for (let L = Math.max(0, e[1] - N); L < tt; ++L) for (let C = Math.max(0, e[0] - Z); C < rt; ++C) {
+            const st = (L * l + C) * b, _e = et.call(Je, st + I[K], T);
+            let J;
+            s ? (J = (L + N - e[1]) * m * t.length + (C + Z - e[0]) * t.length + K, r[J] = _e) : (J = (L + N - e[1]) * m + C + Z - e[0], r[K][J] = _e);
+          }
+        });
+        v.push(Ke);
+      }
+    }
+    if (await Promise.all(v), a && e[2] - e[0] !== a || o && e[3] - e[1] !== o) {
+      let _;
+      s ? _ = er(r, e[2] - e[0], e[3] - e[1], a, o, t.length, n) : _ = Jt(r, e[2] - e[0], e[3] - e[1], a, o, n);
+      const P = _;
+      return P.width = a ?? e[2] - e[0], P.height = o ?? e[3] - e[1], P;
+    }
+    const k = r;
+    return k.width = a || e[2] - e[0], k.height = o || e[3] - e[1], k;
+  }
+  async readRasters(e = {}) {
+    const { window: t, samples: r = [], pool: s = null, width: i, height: a, resampleMethod: o, fillValue: n, signal: f } = e, l = "interleave" in e && e.interleave, c = t || [
+      0,
+      0,
+      this.getWidth(),
+      this.getHeight()
+    ];
+    if (c[0] > c[2] || c[1] > c[3]) throw new Error("Invalid subsets");
+    const h = (c[2] - c[0]) * (c[3] - c[1]), d = this.getSamplesPerPixel();
+    if (!r || !r.length) for (let m = 0; m < d; ++m) r.push(m);
+    else for (let m = 0; m < r.length; ++m) if (r[m] >= d) return Promise.reject(/* @__PURE__ */ new RangeError(`Invalid sample index '${r[m]}'.`));
+    let u;
+    if (l) {
+      const { fileDirectory: m } = this, b = m.getValue("SampleFormat"), I = b ? Math.max.apply(null, Array.from(b)) : 1;
+      if (I !== 1 && I !== 2 && I !== 3) throw new Error("Unsupported sample format for interleaved data. Must be 1, 2, or 3.");
+      const S = m.getValue("BitsPerSample");
+      if (u = ue(I, S ? Math.max.apply(null, Array.from(S)) : 8, h * r.length), n) {
+        if (Array.isArray(n)) throw new Error("When reading interleaved data, fillValue must be a single number.");
+        u.fill(n);
+      }
+    } else {
+      u = [];
+      for (let m = 0; m < r.length; ++m) {
+        const b = this.getArrayForSample(r[m], h);
+        Array.isArray(n) && m < n.length ? b.fill(n[m]) : n && !Array.isArray(n) && b.fill(n), u.push(b);
+      }
+    }
+    const g = this.fileDirectory.getValue("Compression") || 1, p = await Yt(g, this.fileDirectory), w = s ? s.bindParameters(g, p) : await $t(g, p);
+    return await this._readRaster(c, r, u, l, w, i, a, o, f);
+  }
+  async readRGB(e = {}) {
+    const { window: t, pool: r = null, width: s, height: i, resampleMethod: a, enableAlpha: o = !1, signal: n } = e, f = ("interleave" in e && e.interleave) ?? !1, l = t || [
+      0,
+      0,
+      this.getWidth(),
+      this.getHeight()
+    ];
+    if (l[0] > l[2] || l[1] > l[3]) throw new Error("Invalid subsets");
+    const c = this.fileDirectory.getValue("PhotometricInterpretation");
+    if (c === x.RGB) {
+      let b = [
+        0,
+        1,
+        2
+      ];
+      const I = this.fileDirectory.getValue("ExtraSamples");
+      if (I && I[0] !== ot.Unspecified && o) {
+        b = [];
+        const S = this.fileDirectory.getValue("BitsPerSample") || [];
+        for (let v = 0; v < S.length; v += 1) b.push(v);
+      }
+      return this.readRasters({
+        window: t,
+        interleave: f,
+        samples: b,
+        pool: r,
+        width: s,
+        height: i,
+        resampleMethod: a,
+        signal: n
+      });
+    }
+    let h;
+    switch (c) {
+      case x.WhiteIsZero:
+      case x.BlackIsZero:
+      case x.Palette:
+        h = [0];
+        break;
+      case x.CMYK:
+        h = [
+          0,
+          1,
+          2,
+          3
+        ];
+        break;
+      case x.YCbCr:
+      case x.CIELab:
+        h = [
+          0,
+          1,
+          2
+        ];
+        break;
+      default:
+        throw new Error("Invalid or unsupported photometric interpretation.");
+    }
+    const d = {
+      window: l,
+      interleave: !0,
+      samples: h,
+      pool: r,
+      width: s,
+      height: i,
+      resampleMethod: a,
+      signal: n
+    }, { fileDirectory: u } = this, g = await this.readRasters(d), p = 2 ** this.getBitsPerSample(0);
+    let w;
+    switch (c) {
+      case x.WhiteIsZero:
+        w = Vt(g, p);
+        break;
+      case x.BlackIsZero:
+        w = Ut(g, p);
+        break;
+      case x.Palette:
+        w = Nt(g, await u.loadValue("ColorMap"));
+        break;
+      case x.CMYK:
+        w = Lt(g);
+        break;
+      case x.YCbCr:
+        w = Ct(g);
+        break;
+      case x.CIELab:
+        w = jt(g);
+        break;
+      default:
+        throw new Error("Unsupported photometric interpretation.");
+    }
+    if (!f) {
+      const b = new Uint8Array(w.length / 3), I = new Uint8Array(w.length / 3), S = new Uint8Array(w.length / 3);
+      for (let v = 0, T = 0; v < w.length; v += 3, ++T)
+        b[T] = w[v], I[T] = w[v + 1], S[T] = w[v + 2];
+      w = [
+        b,
+        I,
+        S
+      ];
+    }
+    const m = w;
+    return m.width = g.width, m.height = g.height, m;
+  }
+  async getTiePoints() {
+    if (!this.fileDirectory.hasTag("ModelTiepoint")) return [];
+    const e = await this.fileDirectory.loadValue("ModelTiepoint");
+    if (typeof e != "object") throw new Error("Expected ModelTiepoint to be an array or typed array.");
+    const t = [];
+    for (let r = 0; r < e.length; r += 6) t.push({
+      i: e[r],
+      j: e[r + 1],
+      k: e[r + 2],
+      x: e[r + 3],
+      y: e[r + 4],
+      z: e[r + 5]
+    });
+    return t;
+  }
+  async getGDALMetadata(e = null) {
+    const t = {};
+    if (!this.fileDirectory.hasTag("GDAL_METADATA")) return null;
+    let r = Bt(await this.fileDirectory.loadValue("GDAL_METADATA"), "Item");
+    e === null ? r = r.filter((s) => le(s, "sample") === void 0) : r = r.filter((s) => Number(le(s, "sample")) === e);
+    for (let s = 0; s < r.length; ++s) {
+      const i = r[s];
+      t[le(i, "name")] = i.inner;
+    }
+    return t;
+  }
+  getGDALNoData() {
+    const e = this.fileDirectory.hasTag("GDAL_NODATA") && this.fileDirectory.getValue("GDAL_NODATA");
+    return e ? Number(e.substring(0, e.length - 1)) : null;
+  }
+  getOrigin() {
+    const e = this.fileDirectory.getValue("ModelTiepoint"), t = this.fileDirectory.getValue("ModelTransformation");
+    if (e && e.length === 6) return [
+      e[3],
+      e[4],
+      e[5]
+    ];
+    if (t) return [
+      t[3],
+      t[7],
+      t[11]
+    ];
+    throw new Error("The image does not have an affine transformation.");
+  }
+  getResolution(e = null) {
+    const t = this.fileDirectory.getValue("ModelPixelScale"), r = this.fileDirectory.getValue("ModelTransformation");
+    if (t) return [
+      t[0],
+      -t[1],
+      t[2]
+    ];
+    if (r)
+      return r[1] === 0 && r[4] === 0 ? [
+        r[0],
+        -r[5],
+        r[10]
+      ] : [
+        Math.sqrt(r[0] * r[0] + r[4] * r[4]),
+        -Math.sqrt(r[1] * r[1] + r[5] * r[5]),
+        r[10]
+      ];
+    if (e) {
+      const [s, i, a] = e.getResolution();
+      return [
+        s * e.getWidth() / this.getWidth(),
+        i * e.getHeight() / this.getHeight(),
+        a * e.getWidth() / this.getWidth()
+      ];
+    }
+    throw new Error("The image does not have an affine transformation.");
+  }
+  pixelIsArea() {
+    return this.getGeoKeys()?.GTRasterTypeGeoKey === 1;
+  }
+  getBoundingBox(e = !1) {
+    const t = this.getHeight(), r = this.getWidth(), s = this.fileDirectory.getValue("ModelTransformation");
+    if (s && !e) {
+      const [i, a, , o, n, f, , l] = s, c = [
+        [0, 0],
+        [0, t],
+        [r, 0],
+        [r, t]
+      ].map(([u, g]) => [o + i * u + a * g, l + n * u + f * g]), h = c.map((u) => u[0]), d = c.map((u) => u[1]);
+      return [
+        Math.min(...h),
+        Math.min(...d),
+        Math.max(...h),
+        Math.max(...d)
+      ];
+    } else {
+      const i = this.getOrigin(), a = this.getResolution(), o = i[0], n = i[1], f = o + a[0] * r, l = n + a[1] * t;
+      return [
+        Math.min(o, f),
+        Math.min(n, l),
+        Math.max(o, f),
+        Math.max(n, l)
+      ];
+    }
+  }
+}, ar = class {
+  constructor(e) {
+    this._dataView = new DataView(e);
+  }
+  get buffer() {
+    return this._dataView.buffer;
+  }
+  getUint64(e, t) {
+    const r = this.getUint32(e, t), s = this.getUint32(e + 4, t);
+    let i;
+    if (t) {
+      if (i = r + 2 ** 32 * s, !Number.isSafeInteger(i)) throw new Error(`${i} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues`);
+      return i;
+    }
+    if (i = 2 ** 32 * r + s, !Number.isSafeInteger(i)) throw new Error(`${i} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues`);
+    return i;
+  }
+  getInt64(e, t) {
+    let r = 0;
+    const s = (this._dataView.getUint8(e + (t ? 7 : 0)) & 128) > 0;
+    let i = !0;
+    for (let a = 0; a < 8; a++) {
+      let o = this._dataView.getUint8(e + (t ? a : 7 - a));
+      s && (i ? o !== 0 && (o = ~(o - 1) & 255, i = !1) : o = ~o & 255), r += o * 256 ** a;
+    }
+    return s && (r = -r), r;
+  }
+  getUint8(e) {
+    return this._dataView.getUint8(e);
+  }
+  getInt8(e) {
+    return this._dataView.getInt8(e);
+  }
+  getUint16(e, t) {
+    return this._dataView.getUint16(e, t);
+  }
+  getInt16(e, t) {
+    return this._dataView.getInt16(e, t);
+  }
+  getUint32(e, t) {
+    return this._dataView.getUint32(e, t);
+  }
+  getInt32(e, t) {
+    return this._dataView.getInt32(e, t);
+  }
+  getFloat16(e, t) {
+    return je(this._dataView, e, t);
+  }
+  getFloat32(e, t) {
+    return this._dataView.getFloat32(e, t);
+  }
+  getFloat64(e, t) {
+    return this._dataView.getFloat64(e, t);
+  }
+}, re = class {
+  constructor(e, t, r, s) {
+    this._dataView = new DataView(e), this._sliceOffset = t, this._littleEndian = r, this._bigTiff = s;
+  }
+  get sliceOffset() {
+    return this._sliceOffset;
+  }
+  get sliceTop() {
+    return this._sliceOffset + this.buffer.byteLength;
+  }
+  get littleEndian() {
+    return this._littleEndian;
+  }
+  get bigTiff() {
+    return this._bigTiff;
+  }
+  get buffer() {
+    return this._dataView.buffer;
+  }
+  covers(e, t) {
+    return this.sliceOffset <= e && this.sliceTop >= e + t;
+  }
+  readUint8(e) {
+    return this._dataView.getUint8(e - this._sliceOffset);
+  }
+  readInt8(e) {
+    return this._dataView.getInt8(e - this._sliceOffset);
+  }
+  readUint16(e) {
+    return this._dataView.getUint16(e - this._sliceOffset, this._littleEndian);
+  }
+  readInt16(e) {
+    return this._dataView.getInt16(e - this._sliceOffset, this._littleEndian);
+  }
+  readUint32(e) {
+    return this._dataView.getUint32(e - this._sliceOffset, this._littleEndian);
+  }
+  readInt32(e) {
+    return this._dataView.getInt32(e - this._sliceOffset, this._littleEndian);
+  }
+  readFloat32(e) {
+    return this._dataView.getFloat32(e - this._sliceOffset, this._littleEndian);
+  }
+  readFloat64(e) {
+    return this._dataView.getFloat64(e - this._sliceOffset, this._littleEndian);
+  }
+  readUint64(e) {
+    const t = this.readUint32(e), r = this.readUint32(e + 4);
+    let s;
+    if (this._littleEndian) {
+      if (s = t + 2 ** 32 * r, !Number.isSafeInteger(s)) throw new Error(`${s} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues`);
+      return s;
+    }
+    if (s = 2 ** 32 * t + r, !Number.isSafeInteger(s)) throw new Error(`${s} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues`);
+    return s;
+  }
+  readInt64(e) {
+    let t = 0;
+    const r = (this._dataView.getUint8(e + (this._littleEndian ? 7 : 0)) & 128) > 0;
+    let s = !0;
+    for (let i = 0; i < 8; i++) {
+      let a = this._dataView.getUint8(e + (this._littleEndian ? i : 7 - i));
+      r && (s ? a !== 0 && (a = ~(a - 1) & 255, s = !1) : a = ~a & 255), t += a * 256 ** i;
+    }
+    return r && (t = -t), t;
+  }
+  readOffset(e) {
+    return this._bigTiff ? this.readUint64(e) : this.readUint32(e);
+  }
+}, nr = `\r
+\r
+`;
+function He(e) {
+  if (typeof Object.fromEntries < "u") return Object.fromEntries(e);
+  const t = {};
+  for (const [r, s] of e) t[r.toLowerCase()] = s;
+  return t;
+}
+function or(e) {
+  return He(e.split(`\r
+`).map((t) => {
+    const r = t.split(":").map((s) => s.trim());
+    return r[0] = r[0].toLowerCase(), r;
+  }));
+}
+function lr(e) {
+  if (!e) return {
+    type: null,
+    params: {}
+  };
+  const [t, ...r] = e.split(";").map((s) => s.trim());
+  return {
+    type: t,
+    params: He(r.map((s) => s.split("=")))
+  };
+}
+function de(e) {
+  let t = NaN, r = NaN, s = NaN;
+  return e && ([, t, r, s] = (e.match(/bytes (\d+)-(\d+)\/(\d+)/) || []).map(Number)), {
+    start: t,
+    end: r,
+    total: s
+  };
+}
+function cr(e, t) {
+  let r = -1;
+  const s = new TextDecoder("ascii"), i = [], a = `--${t}`, o = `${a}--`;
+  for (let n = 0; n < 10; ++n) s.decode(new Uint8Array(e, n, a.length)) === a && (r = n);
+  if (r === -1) throw new Error("Could not find initial boundary");
+  for (; r < e.byteLength; ) {
+    const n = s.decode(new Uint8Array(e, r, Math.min(a.length + 1024, e.byteLength - r)));
+    if (n.length === 0 || n.startsWith(o)) break;
+    if (!n.startsWith(a)) throw new Error("Part does not start with boundary");
+    const f = n.substr(a.length + 2);
+    if (f.length === 0) break;
+    const l = f.indexOf(nr), c = or(f.substr(0, l)), { start: h, end: d, total: u } = de(c["content-range"]), g = r + a.length + l + 4, p = d + 1 - h;
+    i.push({
+      headers: c,
+      data: e.slice(g, g + p),
+      offset: h,
+      length: p,
+      fileSize: u
+    }), r = g + p + 4;
+  }
+  return i;
+}
+var Ye = class {
+  async fetch(e, t) {
+    return Promise.all(e.map(async (r) => (await this.fetchSlice(r, t)).data));
+  }
+  async fetchSlice(e, t) {
+    throw new Error(`fetching of slice ${e} not possible, not implemented`);
+  }
+  get fileSize() {
+    return null;
+  }
+  async close() {
+  }
+}, hr = class extends Map {
+  constructor(e = {}) {
+    if (super(), !(e.maxSize && e.maxSize > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+    if (typeof e.maxAge == "number" && e.maxAge === 0) throw new TypeError("`maxAge` must be a number greater than 0");
+    this.maxSize = e.maxSize, this.maxAge = e.maxAge || Number.POSITIVE_INFINITY, this.onEviction = e.onEviction, this.cache = /* @__PURE__ */ new Map(), this.oldCache = /* @__PURE__ */ new Map(), this._size = 0;
+  }
+  _emitEvictions(e) {
+    if (typeof this.onEviction == "function")
+      for (const [t, r] of e) this.onEviction(t, r.value);
+  }
+  _deleteIfExpired(e, t) {
+    return typeof t.expiry == "number" && t.expiry <= Date.now() ? (typeof this.onEviction == "function" && this.onEviction(e, t.value), this.delete(e)) : !1;
+  }
+  _getOrDeleteIfExpired(e, t) {
+    if (this._deleteIfExpired(e, t) === !1) return t.value;
+  }
+  _getItemValue(e, t) {
+    return t.expiry ? this._getOrDeleteIfExpired(e, t) : t.value;
+  }
+  _peek(e, t) {
+    const r = t.get(e);
+    return this._getItemValue(e, r);
+  }
+  _set(e, t) {
+    this.cache.set(e, t), this._size++, this._size >= this.maxSize && (this._size = 0, this._emitEvictions(this.oldCache), this.oldCache = this.cache, this.cache = /* @__PURE__ */ new Map());
+  }
+  _moveToRecent(e, t) {
+    this.oldCache.delete(e), this._set(e, t);
+  }
+  *_entriesAscending() {
+    for (const e of this.oldCache) {
+      const [t, r] = e;
+      this.cache.has(t) || this._deleteIfExpired(t, r) === !1 && (yield e);
+    }
+    for (const e of this.cache) {
+      const [t, r] = e;
+      this._deleteIfExpired(t, r) === !1 && (yield e);
+    }
+  }
+  get(e) {
+    if (this.cache.has(e)) {
+      const t = this.cache.get(e);
+      return this._getItemValue(e, t);
+    }
+    if (this.oldCache.has(e)) {
+      const t = this.oldCache.get(e);
+      if (this._deleteIfExpired(e, t) === !1)
+        return this._moveToRecent(e, t), t.value;
+    }
+  }
+  set(e, t, { maxAge: r = this.maxAge } = {}) {
+    const s = typeof r == "number" && r !== Number.POSITIVE_INFINITY ? Date.now() + r : void 0;
+    return this.cache.has(e) ? this.cache.set(e, {
+      value: t,
+      expiry: s
+    }) : this._set(e, {
+      value: t,
+      expiry: s
+    }), this;
+  }
+  has(e) {
+    return this.cache.has(e) ? !this._deleteIfExpired(e, this.cache.get(e)) : this.oldCache.has(e) ? !this._deleteIfExpired(e, this.oldCache.get(e)) : !1;
+  }
+  peek(e) {
+    if (this.cache.has(e)) return this._peek(e, this.cache);
+    if (this.oldCache.has(e)) return this._peek(e, this.oldCache);
+  }
+  delete(e) {
+    const t = this.cache.delete(e);
+    return t && this._size--, this.oldCache.delete(e) || t;
+  }
+  clear() {
+    this.cache.clear(), this.oldCache.clear(), this._size = 0;
+  }
+  resize(e) {
+    if (!(e && e > 0)) throw new TypeError("`maxSize` must be a number greater than 0");
+    const t = [...this._entriesAscending()], r = t.length - e;
+    r < 0 ? (this.cache = new Map(t), this.oldCache = /* @__PURE__ */ new Map(), this._size = t.length) : (r > 0 && this._emitEvictions(t.slice(0, r)), this.oldCache = new Map(t.slice(r)), this.cache = /* @__PURE__ */ new Map(), this._size = 0), this.maxSize = e;
+  }
+  *keys() {
+    for (const [e] of this) yield e;
+  }
+  *values() {
+    for (const [, e] of this) yield e;
+  }
+  *[Symbol.iterator]() {
+    for (const e of this.cache) {
+      const [t, r] = e;
+      this._deleteIfExpired(t, r) === !1 && (yield [t, r.value]);
+    }
+    for (const e of this.oldCache) {
+      const [t, r] = e;
+      this.cache.has(t) || this._deleteIfExpired(t, r) === !1 && (yield [t, r.value]);
+    }
+  }
+  *entriesDescending() {
+    let e = [...this.cache];
+    for (let t = e.length - 1; t >= 0; --t) {
+      const [r, s] = e[t];
+      this._deleteIfExpired(r, s) === !1 && (yield [r, s.value]);
+    }
+    e = [...this.oldCache];
+    for (let t = e.length - 1; t >= 0; --t) {
+      const [r, s] = e[t];
+      this.cache.has(r) || this._deleteIfExpired(r, s) === !1 && (yield [r, s.value]);
+    }
+  }
+  *entriesAscending() {
+    for (const [e, t] of this._entriesAscending()) yield [e, t.value];
+  }
+  get size() {
+    if (!this._size) return this.oldCache.size;
+    let e = 0;
+    for (const t of this.oldCache.keys()) this.cache.has(t) || e++;
+    return Math.min(this._size + e, this.maxSize);
+  }
+  entries() {
+    return this.entriesAscending();
+  }
+  forEach(e, t = this) {
+    for (const [r, s] of this.entriesAscending()) e.call(t, s, r, this);
+  }
+  get [Symbol.toStringTag]() {
+    return JSON.stringify([...this.entriesAscending()]);
+  }
+};
+async function fr(e) {
+  return new Promise((t) => setTimeout(t, e));
+}
+function ur(e, t) {
+  const r = Array.isArray(e) ? e : Array.from(e), s = Array.isArray(t) ? t : Array.from(t);
+  return r.map((i, a) => [i, s[a]]);
+}
+var H = class $e extends Error {
+  constructor(...t) {
+    super(...t), Error.captureStackTrace && Error.captureStackTrace(this, $e), this.name = "AbortError", this.signal = void 0;
+  }
+}, dr = class extends Error {
+  constructor(e, t) {
+    super(t), this.errors = e, this.message = t, this.name = "AggregateError";
+  }
+}, gr = dr, yr = class {
+  constructor(e, t, r) {
+    this.offset = e, this.length = t, this.data = r;
+  }
+  get top() {
+    return this.offset + this.length;
+  }
+}, Fe = class {
+  constructor(e, t, r) {
+    this.offset = e, this.length = t, this.blockIds = r;
+  }
+}, pr = class extends Ye {
+  constructor(e, { blockSize: t = 65536, cacheSize: r = 100 } = {}) {
+    super(), this.source = e, this.blockSize = t, this.blockCache = new hr({
+      maxSize: r,
+      onEviction: (s, i) => {
+        this.evictedBlocks.set(s, i);
+      }
+    }), this.evictedBlocks = /* @__PURE__ */ new Map(), this.blockRequests = /* @__PURE__ */ new Map(), this.blockIdsToFetch = /* @__PURE__ */ new Set(), this.abortedBlockIds = /* @__PURE__ */ new Set();
+  }
+  get fileSize() {
+    return this.source.fileSize;
+  }
+  async fetch(e, t) {
+    const r = [], s = [], i = [];
+    this.evictedBlocks.clear();
+    for (const { offset: h, length: d } of e) {
+      let u = h + d;
+      const { fileSize: g } = this;
+      g !== null && (u = Math.min(u, g));
+      const p = Math.floor(h / this.blockSize) * this.blockSize;
+      for (let w = p; w < u; w += this.blockSize) {
+        const m = Math.floor(w / this.blockSize);
+        !this.blockCache.has(m) && !this.blockRequests.has(m) && (this.blockIdsToFetch.add(m), s.push(m)), this.blockRequests.has(m) && r.push(this.blockRequests.get(m)), i.push(m);
+      }
+    }
+    await fr(), this.fetchBlocks(t);
+    const a = [];
+    for (const h of s) this.blockRequests.has(h) && a.push(this.blockRequests.get(h));
+    await Promise.allSettled(r), await Promise.allSettled(a);
+    const o = [], n = i.filter((h) => this.abortedBlockIds.has(h) || !this.blockCache.has(h));
+    if (n.forEach((h) => this.blockIdsToFetch.add(h)), n.length > 0 && t && !t.aborted) {
+      this.fetchBlocks();
+      for (const h of n) {
+        const d = this.blockRequests.get(h);
+        if (!d) throw new Error(`Block ${h} is not in the block requests`);
+        o.push(d);
+      }
+      await Promise.allSettled(o);
+    }
+    if (t && t.aborted) throw new H("Request was aborted");
+    const f = i.map((h) => this.blockCache.get(h) || this.evictedBlocks.get(h)), l = f.filter((h) => !h);
+    if (l.length) throw new gr(l, "Request failed");
+    const c = new Map(ur(i, f));
+    return this.readSliceData(e, c);
+  }
+  fetchBlocks(e) {
+    if (this.blockIdsToFetch.size > 0) {
+      const t = this.groupBlocks(this.blockIdsToFetch), r = t.map(async (s) => ({
+        ...s,
+        ...await this.source.fetchSlice(s, e)
+      }));
+      for (let s = 0; s < t.length; ++s) {
+        const i = t[s];
+        for (const a of i.blockIds) this.blockRequests.set(a, (async () => {
+          try {
+            const o = (await Promise.all(r))[s], n = a * this.blockSize, f = n - o.offset, l = Math.min(f + this.blockSize, o.data.byteLength), c = o.data.slice(f, l), h = new yr(n, c.byteLength, c);
+            this.blockCache.set(a, h), this.abortedBlockIds.delete(a);
+          } catch (o) {
+            if (o instanceof H && o.name === "AbortError")
+              o.signal = e, this.blockCache.delete(a), this.abortedBlockIds.add(a);
+            else throw o;
+          } finally {
+            this.blockRequests.delete(a);
+          }
+        })());
+      }
+      this.blockIdsToFetch.clear();
+    }
+  }
+  groupBlocks(e) {
+    const t = Array.from(e).sort((a, o) => a - o);
+    if (t.length === 0) return [];
+    let r = [], s = null;
+    const i = [];
+    for (const a of t) s === null || s + 1 === a ? (r.push(a), s = a) : (i.push(new Fe(r[0] * this.blockSize, r.length * this.blockSize, r)), r = [a], s = a);
+    return i.push(new Fe(r[0] * this.blockSize, r.length * this.blockSize, r)), i;
+  }
+  readSliceData(e, t) {
+    return e.map((r) => {
+      let s = r.offset + r.length;
+      this.fileSize !== null && (s = Math.min(this.fileSize, s));
+      const i = Math.floor(r.offset / this.blockSize), a = Math.floor((s - 1) / this.blockSize), o = new ArrayBuffer(r.length), n = new Uint8Array(o);
+      for (let f = i; f <= a; ++f) {
+        const l = t.get(f);
+        if (!l) continue;
+        const c = l.offset - r.offset, h = l.top - s;
+        let d = 0, u = 0, g;
+        c < 0 ? d = -c : c > 0 && (u = c), h < 0 ? g = l.length - d : g = s - l.offset - d;
+        const p = new Uint8Array(l.data, d, g);
+        n.set(p, u);
+      }
+      return o;
+    });
+  }
+}, Ie = class {
+  get ok() {
+    return this.status >= 200 && this.status <= 299;
+  }
+  get status() {
+    throw new Error("not implemented");
+  }
+  getHeader(e) {
+    throw new Error("not implemented");
+  }
+  async getData() {
+    throw new Error("not implemented");
+  }
+}, Ae = class {
+  constructor(e) {
+    this.url = e;
+  }
+  async request(e) {
+    throw new Error("request is not implemented");
+  }
+}, wr = class extends Ie {
+  constructor(e) {
+    super(), this.response = e;
+  }
+  get status() {
+    return this.response.status;
+  }
+  getHeader(e) {
+    return this.response.headers.get(e) || void 0;
+  }
+  async getData() {
+    return this.response.arrayBuffer ? await this.response.arrayBuffer() : (await this.response.buffer()).buffer;
+  }
+}, mr = class extends Ae {
+  constructor(e, t) {
+    super(e), this.credentials = t;
+  }
+  async request({ headers: e, signal: t } = {}) {
+    return new wr(await fetch(this.url, {
+      headers: e,
+      credentials: this.credentials,
+      signal: t
+    }));
+  }
+}, br = class extends Ie {
+  constructor(e, t) {
+    super(), this.xhr = e, this.data = t;
+  }
+  get status() {
+    return this.xhr.status;
+  }
+  getHeader(e) {
+    return this.xhr.getResponseHeader(e) || void 0;
+  }
+  async getData() {
+    return this.data;
+  }
+}, vr = class extends Ae {
+  constructRequest(e, t) {
+    return new Promise((r, s) => {
+      const i = new XMLHttpRequest();
+      i.open("GET", this.url), i.responseType = "arraybuffer";
+      for (const [a, o] of Object.entries(e)) i.setRequestHeader(a, o);
+      i.onload = () => {
+        const a = i.response;
+        r(new br(i, a));
+      }, i.onerror = s, i.onabort = () => s(new H("Request aborted")), i.send(), t && (t.aborted && i.abort(), t.addEventListener("abort", () => i.abort()));
+    });
+  }
+  async request({ headers: e = {}, signal: t = void 0 } = {}) {
+    return await this.constructRequest(e, t);
+  }
+}, Ir = /* @__PURE__ */ at(((e, t) => {
+  t.exports = {};
+})), ce = /* @__PURE__ */ it(Ir(), 1), Ar = class extends Ie {
+  constructor(e, t) {
+    super(), this.response = e, this.dataPromise = t;
+  }
+  get status() {
+    return this.response.statusCode;
+  }
+  getHeader(e) {
+    const t = this.response.headers[e];
+    return Array.isArray(t) ? t.join(", ") : t;
+  }
+  async getData() {
+    return await this.dataPromise;
+  }
+}, Tr = class extends Ae {
+  constructor(e) {
+    super(e), this.parsedUrl = ce.default.parse(this.url), this.httpApi = (this.parsedUrl.protocol === "http:", ce.default);
+  }
+  constructRequest(e, t) {
+    return new Promise((r, s) => {
+      const i = this.httpApi.get({
+        ...this.parsedUrl,
+        headers: e
+      }, (a) => {
+        r(new Ar(a, new Promise((o) => {
+          const n = [];
+          a.on("data", (f) => {
+            n.push(f);
+          }), a.on("end", () => {
+            const f = Buffer.concat(n).buffer;
+            o(f);
+          }), a.on("error", s);
+        })));
+      });
+      i.on("error", s), t && (t.aborted && i.destroy(new H("Request aborted")), t.addEventListener("abort", () => i.destroy(new H("Request aborted"))));
+    });
+  }
+  async request({ headers: e = {}, signal: t = void 0 } = {}) {
+    return await this.constructRequest(e, t);
+  }
+}, Te = class extends Ye {
+  constructor(e, { headers: t, maxRanges: r = 0, allowFullFile: s } = {}) {
+    super(), this.client = e, this.headers = t, this.maxRanges = r, this.allowFullFile = s, this._fileSize = null;
+  }
+  async fetch(e, t) {
+    return this.maxRanges >= e.length ? this.fetchSlices(e, t).then((r) => r.map((s) => s.data)) : (this.maxRanges > 0 && e.length > 1, Promise.all(e.map(async (r) => (await this.fetchSlice(r, t)).data)));
+  }
+  async fetchSlices(e, t) {
+    const r = await this.client.request({
+      headers: {
+        ...this.headers,
+        Range: `bytes=${e.map(({ offset: s, length: i }) => `${s}-${s + i - 1}`).join(",")}`
+      },
+      signal: t
+    });
+    if (r.ok) if (r.status === 206) {
+      const { type: s, params: i } = lr(r.getHeader("content-type"));
+      if (s === "multipart/byteranges") {
+        const c = cr(await r.getData(), i.boundary);
+        return this._fileSize = c[0].fileSize || null, c;
+      }
+      const a = await r.getData(), { start: o, end: n, total: f } = de(r.getHeader("content-range"));
+      this._fileSize = f || null;
+      const l = [{
+        data: a,
+        offset: o,
+        length: n + 1 - o
+      }];
+      if (e.length > 1) {
+        const c = await Promise.all(e.slice(1).map((h) => this.fetchSlice(h, t)));
+        return l.concat(c);
+      }
+      return l;
+    } else {
+      if (!this.allowFullFile) throw new Error("Server responded with full file");
+      const s = await r.getData();
+      return this._fileSize = s.byteLength, [{
+        data: s,
+        offset: 0,
+        length: s.byteLength
+      }];
+    }
+    else throw new Error("Error fetching data.");
+  }
+  async fetchSlice(e, t) {
+    const { offset: r, length: s } = e, i = await this.client.request({
+      headers: {
+        ...this.headers,
+        Range: `bytes=${r}-${r + s - 1}`
+      },
+      signal: t
+    });
+    if (i.ok) if (i.status === 206) {
+      const a = await i.getData(), { total: o } = de(i.getHeader("content-range"));
+      return this._fileSize = o || null, {
+        data: a,
+        offset: r,
+        length: s
+      };
+    } else {
+      if (!this.allowFullFile) throw new Error("Server responded with full file");
+      const a = await i.getData();
+      return this._fileSize = a.byteLength, {
+        data: a,
+        offset: 0,
+        length: a.byteLength
+      };
+    }
+    else throw new Error("Error fetching data.");
+  }
+  get fileSize() {
+    return this._fileSize;
+  }
+};
+function Se(e, { blockSize: t, cacheSize: r }) {
+  return t === void 0 ? e : new pr(e, {
+    blockSize: t,
+    cacheSize: r
+  });
+}
+function Sr(e, { headers: t = {}, credentials: r, maxRanges: s = 0, allowFullFile: i = !1, ...a } = {}) {
+  return Se(new Te(new mr(e, r), {
+    headers: t,
+    maxRanges: s,
+    allowFullFile: i
+  }), a);
+}
+function Er(e, { headers: t = {}, maxRanges: r = 0, allowFullFile: s = !1, ...i } = {}) {
+  return Se(new Te(new vr(e), {
+    headers: t,
+    maxRanges: r,
+    allowFullFile: s
+  }), i);
+}
+function _r(e, { headers: t = {}, maxRanges: r = 0, allowFullFile: s = !1, ...i } = {}) {
+  return Se(new Te(new Tr(e), {
+    headers: t,
+    maxRanges: r,
+    allowFullFile: s
+  }), i);
+}
+function xr(e, { forceXHR: t = !1, ...r } = {}) {
+  return typeof fetch == "function" && !t ? Sr(e, r) : typeof XMLHttpRequest < "u" ? Er(e, r) : _r(e, r);
+}
+function O(e, t) {
+  switch (e) {
+    case y.BYTE:
+    case y.ASCII:
+    case y.UNDEFINED:
+      return new Uint8Array(t);
+    case y.SBYTE:
+      return new Int8Array(t);
+    case y.SHORT:
+      return new Uint16Array(t);
+    case y.SSHORT:
+      return new Int16Array(t);
+    case y.LONG:
+    case y.IFD:
+      return new Uint32Array(t);
+    case y.SLONG:
+      return new Int32Array(t);
+    case y.LONG8:
+    case y.IFD8:
+      return new Array(t);
+    case y.SLONG8:
+      return new Array(t);
+    case y.RATIONAL:
+      return new Uint32Array(t * 2);
+    case y.SRATIONAL:
+      return new Int32Array(t * 2);
+    case y.FLOAT:
+      return new Float32Array(t);
+    case y.DOUBLE:
+      return new Float64Array(t);
+    default:
+      throw new RangeError(`Invalid field type: ${e}`);
+  }
+}
+function R(e, t) {
+  switch (t) {
+    case y.BYTE:
+    case y.ASCII:
+    case y.UNDEFINED:
+      return e.readUint8;
+    case y.SBYTE:
+      return e.readInt8;
+    case y.SHORT:
+      return e.readUint16;
+    case y.SSHORT:
+      return e.readInt16;
+    case y.LONG:
+    case y.IFD:
+      return e.readUint32;
+    case y.SLONG:
+      return e.readInt32;
+    case y.LONG8:
+    case y.IFD8:
+      return e.readUint64;
+    case y.SLONG8:
+      return e.readInt64;
+    case y.RATIONAL:
+      return e.readUint32;
+    case y.SRATIONAL:
+      return e.readInt32;
+    case y.FLOAT:
+      return e.readFloat32;
+    case y.DOUBLE:
+      return e.readFloat64;
+    default:
+      throw new RangeError(`Invalid field type: ${t}`);
+  }
+}
+function z(e = null, t, r, s, i, a, o = !1) {
+  const n = G(s), f = e || O(s, i), l = s === y.RATIONAL || s === y.SRATIONAL;
+  if (l) for (let c = 0; c < i; c += 2)
+    f[c] = t.call(r, a + c * n), f[c + 1] = t.call(r, a + (c * n + 4));
+  else for (let c = 0; c < i; ++c) f[c] = t.call(r, a + c * n);
+  return s === y.ASCII ? new TextDecoder("utf-8").decode(f) : i === 1 && !o && !l ? f[0] : f;
+}
+var kr = class {
+  constructor(e, t, r, s, i) {
+    this.source = e, this.arrayOffset = t, this.littleEndian = r, this.fieldType = s, this.length = i, this.data = O(s, i), this.itemSize = G(s), this.maskBitmap = new Uint8Array(Math.ceil(i / 8)), this.fetchIndexPromises = /* @__PURE__ */ new Map(), this.fullFetchPromise = null;
+  }
+  async loadAll() {
+    return this.fullFetchPromise || (this.fullFetchPromise = this.source.fetch([{
+      offset: this.arrayOffset,
+      length: this.itemSize * this.length
+    }]).then((e) => {
+      const t = new re(e[0], this.arrayOffset, !0, !1), r = z(this.data, R(t, this.fieldType), t, this.fieldType, this.length, this.arrayOffset, !0);
+      return this.maskBitmap.fill(255), this.fetchIndexPromises.clear(), r;
+    })), this.fullFetchPromise;
+  }
+  async get(e) {
+    if (e < 0 || e >= this.data.length) throw new RangeError(`Index ${e} out of bounds for length ${this.data.length}`);
+    const t = Math.floor(e / 8), r = 1 << e % 8, s = this.arrayOffset + e * this.itemSize;
+    if ((this.maskBitmap[t] & r) === 0) {
+      if (!this.fetchIndexPromises.has(e)) {
+        const i = this.source.fetch([{
+          offset: s,
+          length: this.itemSize
+        }]).then((a) => {
+          const o = new re(a[0], this.arrayOffset + e * this.itemSize, !0, !1), n = R(o, this.fieldType).call(o, s);
+          return this.data[e] = n, this.maskBitmap[t] |= r, this.fetchIndexPromises.delete(e), n;
+        });
+        this.fetchIndexPromises.set(e, i);
+      }
+      return this.fetchIndexPromises.get(e);
+    }
+    return this.data[e];
+  }
+}, Pr = class {
+  constructor(e, t, r, s) {
+    this.actualizedFields = e, this.deferredFields = t, this.deferredFieldsBeingResolved = /* @__PURE__ */ new Map(), this.deferredArrays = r, this.nextIFDByteOffset = s;
+  }
+  hasTag(e) {
+    const t = Q(e);
+    return this.actualizedFields.has(t) || this.deferredFields.has(t) || this.deferredArrays.has(t);
+  }
+  getValue(e) {
+    const t = Q(e);
+    if (this.deferredFields.has(t) || this.deferredArrays.has(t)) {
+      const r = te[t]?.name || `Tag${t}`;
+      throw new Error(`Field '${r}' (${t}) is deferred. Use loadValue() to load it asynchronously.`);
+    }
+    if (this.actualizedFields.has(t))
+      return this.actualizedFields.get(t);
+  }
+  async loadValue(e) {
+    const t = Q(e);
+    if (this.actualizedFields.has(t)) return this.actualizedFields.get(t);
+    if (this.deferredFieldsBeingResolved.has(t)) return this.deferredFieldsBeingResolved.get(t);
+    const r = this.deferredFields.get(t);
+    if (r) {
+      this.deferredFields.delete(t);
+      const i = (async () => {
+        try {
+          const a = await r();
+          return this.actualizedFields.set(t, a), a;
+        } finally {
+          this.deferredFieldsBeingResolved.delete(t);
+        }
+      })();
+      return this.deferredFieldsBeingResolved.set(t, i), i;
+    }
+    const s = this.deferredArrays.get(t);
+    if (s) return s.loadAll();
+  }
+  async loadValueIndexed(e, t) {
+    const r = Q(e);
+    if (this.actualizedFields.has(r)) return this.actualizedFields.get(r)[t];
+    if (this.deferredArrays.has(r)) return this.deferredArrays.get(r).get(t);
+    if (this.hasTag(r)) {
+      const s = await this.loadValue(r);
+      if (s && typeof s != "number") return s[t];
+    }
+  }
+  parseGeoKeyDirectory() {
+    const e = this.getValue("GeoKeyDirectory");
+    if (!e) return null;
+    const t = {};
+    for (let r = 4; r <= e[3] * 4; r += 4) {
+      const s = nt[e[r]], i = e[r + 1] || null, a = e[r + 2], o = e[r + 3];
+      let n = null;
+      if (!i) n = o;
+      else {
+        if (n = this.getValue(i), typeof n > "u" || n === null) throw new Error(`Could not get value of geoKey '${s}'.`);
+        typeof n == "string" ? n = n.substring(o, o + a - 1) : n.subarray && (n = n.subarray(o, o + a), a === 1 && (n = n[0]));
+      }
+      t[s] = n;
+    }
+    return t;
+  }
+  toObject() {
+    const e = {};
+    for (const [t, r] of this.actualizedFields.entries()) {
+      const s = typeof t == "number" ? te[t] : void 0, i = s ? s.name : `Tag${t}`;
+      e[i] = r;
+    }
+    return e;
+  }
+}, Fr = class {
+  constructor(e, t, r, s = !1) {
+    this.source = e, this.littleEndian = t, this.bigTiff = r, this.eager = s;
+  }
+  async getSlice(e, t) {
+    const r = this.bigTiff ? 4048 : 1024;
+    return new re((await this.source.fetch([{
+      offset: e,
+      length: typeof t < "u" ? t : r
+    }]))[0], e, this.littleEndian, this.bigTiff);
+  }
+  async parseFileDirectoryAt(e) {
+    const t = this.bigTiff ? 20 : 12, r = this.bigTiff ? 8 : 2;
+    let s = await this.getSlice(e);
+    const i = this.bigTiff ? s.readUint64(e) : s.readUint16(e), a = i * (t + (this.bigTiff ? 16 : 6));
+    s.covers(e, a) || (s = await this.getSlice(e, a));
+    const o = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), f = /* @__PURE__ */ new Map();
+    let l = e + (this.bigTiff ? 8 : 2);
+    for (let c = 0; c < i; l += t, ++c) {
+      const h = s.readUint16(l), d = s.readUint16(l + 2), u = this.bigTiff ? s.readUint64(l + 4) : s.readUint32(l + 4);
+      let g = null, p = null, w = null;
+      const m = G(d), b = l + (this.bigTiff ? 12 : 8), I = te[h]?.isArray, S = te[h]?.eager || this.eager;
+      if (m * u <= (this.bigTiff ? 8 : 4)) g = z(O(d, u), R(s, d), s, d, u, b, I);
+      else {
+        const v = s.readOffset(b), T = G(d) * u;
+        if (s.covers(v, T)) g = z(O(d, u), R(s, d), s, d, u, v, I);
+        else if (S) {
+          const k = await this.getSlice(v, T);
+          g = z(O(d, u), R(k, d), k, d, u, v, I);
+        } else I ? w = new kr(this.source, v, this.littleEndian, d, u) : p = async () => {
+          const k = await this.getSlice(v, T);
+          return z(O(d, u), R(k, d), k, d, u, v, I);
+        };
+      }
+      g !== null ? o.set(h, g) : p !== null ? n.set(h, p) : w !== null && f.set(h, w);
+    }
+    return new Pr(o, n, f, s.readOffset(e + r + t * i));
+  }
+};
+function he(e, t, r, s) {
+  let i = null, a = null;
+  const o = G(t);
+  switch (t) {
+    case y.BYTE:
+    case y.ASCII:
+    case y.UNDEFINED:
+      i = new Uint8Array(r), a = e.readUint8;
+      break;
+    case y.SBYTE:
+      i = new Int8Array(r), a = e.readInt8;
+      break;
+    case y.SHORT:
+      i = new Uint16Array(r), a = e.readUint16;
+      break;
+    case y.SSHORT:
+      i = new Int16Array(r), a = e.readInt16;
+      break;
+    case y.LONG:
+    case y.IFD:
+      i = new Uint32Array(r), a = e.readUint32;
+      break;
+    case y.SLONG:
+      i = new Int32Array(r), a = e.readInt32;
+      break;
+    case y.LONG8:
+    case y.IFD8:
+      i = new Array(r), a = e.readUint64;
+      break;
+    case y.SLONG8:
+      i = new Array(r), a = e.readInt64;
+      break;
+    case y.RATIONAL:
+      i = new Uint32Array(r * 2), a = e.readUint32;
+      break;
+    case y.SRATIONAL:
+      i = new Int32Array(r * 2), a = e.readInt32;
+      break;
+    case y.FLOAT:
+      i = new Float32Array(r), a = e.readFloat32;
+      break;
+    case y.DOUBLE:
+      i = new Float64Array(r), a = e.readFloat64;
+      break;
+    default:
+  }
+  if (i === null || a === null) throw new RangeError(`Invalid field type: ${t}`);
+  if (t === y.RATIONAL || t === y.SRATIONAL) for (let n = 0; n < r; n += 2)
+    i[n] = a.call(e, s + n * o), i[n + 1] = a.call(e, s + (n * o + 4));
+  else for (let n = 0; n < r; ++n) i[n] = a.call(e, s + n * o);
+  return t === y.ASCII ? new TextDecoder("utf-8").decode(i) : i;
+}
+var W = class extends Error {
+  constructor(e) {
+    super(`No image at index ${e}`), this.index = e;
+  }
+}, Dr = class {
+  async getImage(e = 0) {
+    throw new Error("Not implemented");
+  }
+  async getImageCount() {
+    throw new Error("Not implemented");
+  }
+  async readRasters(e = {}) {
+    const { window: t, width: r, height: s } = e;
+    let { resX: i, resY: a, bbox: o } = e;
+    const n = await this.getImage();
+    let f = n;
+    const l = await this.getImageCount(), c = n.getBoundingBox();
+    if (t && o) throw new Error('Both "bbox" and "window" passed.');
+    if (r || s) {
+      if (t) {
+        const [u, g] = n.getOrigin(), [p, w] = n.getResolution();
+        o = [
+          u + t[0] * p,
+          g + t[1] * w,
+          u + t[2] * p,
+          g + t[3] * w
+        ];
+      }
+      const d = o || c;
+      if (r) {
+        if (i) throw new Error("Both width and resX passed");
+        i = (d[2] - d[0]) / r;
+      }
+      if (s) {
+        if (a) throw new Error("Both width and resY passed");
+        a = (d[3] - d[1]) / s;
+      }
+    }
+    if (i || a) {
+      const d = [];
+      for (let u = 0; u < l; ++u) {
+        const g = await this.getImage(u), p = g.fileDirectory.getValue("SubfileType"), w = g.fileDirectory.getValue("NewSubfileType");
+        (u === 0 || p === 2 || (w || 0) & 1) && d.push(g);
+      }
+      d.sort((u, g) => u.getWidth() - g.getWidth());
+      for (let u = 0; u < d.length; ++u) {
+        const g = d[u], p = (c[2] - c[0]) / g.getWidth(), w = (c[3] - c[1]) / g.getHeight();
+        if (f = g, i && i > p || a && a > w) break;
+      }
+    }
+    let h = t;
+    if (o) {
+      const [d, u] = n.getOrigin(), [g, p] = f.getResolution(n);
+      h = [
+        Math.round((o[0] - d) / g),
+        Math.round((o[1] - u) / p),
+        Math.round((o[2] - d) / g),
+        Math.round((o[3] - u) / p)
+      ], h = [
+        Math.min(h[0], h[2]),
+        Math.min(h[1], h[3]),
+        Math.max(h[0], h[2]),
+        Math.max(h[1], h[3])
+      ];
+    }
+    return f.readRasters({
+      ...e,
+      window: h
+    });
+  }
+}, Or = class Xe extends Dr {
+  constructor(t, r, s, i, a = {}) {
+    super(), this.source = t, this.parser = new Fr(t, r, s, !1), this.littleEndian = r, this.bigTiff = s, this.firstIFDOffset = i, this.cache = a.cache || !1, this.ifdRequests = [], this.ghostValues = null;
+  }
+  async getSlice(t, r) {
+    const s = this.bigTiff ? 4048 : 1024;
+    return new re((await this.source.fetch([{
+      offset: t,
+      length: typeof r < "u" ? r : s
+    }]))[0], t, this.littleEndian, this.bigTiff);
+  }
+  async requestIFD(t) {
+    if (this.ifdRequests[t]) return this.ifdRequests[t];
+    if (t === 0)
+      return this.ifdRequests[t] = this.parser.parseFileDirectoryAt(this.firstIFDOffset), this.ifdRequests[t];
+    if (!this.ifdRequests[t - 1]) try {
+      this.ifdRequests[t - 1] = this.requestIFD(t - 1);
+    } catch (r) {
+      throw r instanceof W ? new W(t) : r;
+    }
+    return this.ifdRequests[t] = (async () => {
+      const r = this.ifdRequests[t - 1];
+      if (!r) throw new Error("Previous IFD request missing");
+      const s = await r;
+      if (s.nextIFDByteOffset === 0) throw new W(t);
+      return this.parser.parseFileDirectoryAt(s.nextIFDByteOffset);
+    })(), this.ifdRequests[t];
+  }
+  async getImage(t = 0) {
+    return new ir(await this.requestIFD(t), this.littleEndian, this.cache, this.source);
+  }
+  async getImageCount() {
+    let t = 0, r = !0;
+    for (; r; ) try {
+      await this.requestIFD(t), ++t;
+    } catch (s) {
+      if (s instanceof W) r = !1;
+      else throw s;
+    }
+    return t;
+  }
+  async getGhostValues() {
+    const t = this.bigTiff ? 16 : 8;
+    if (this.ghostValues !== null) return this.ghostValues;
+    const r = "GDAL_STRUCTURAL_METADATA_SIZE=", s = 130;
+    let i = await this.getSlice(t, s);
+    if (r === he(i, y.ASCII, 30, t)) {
+      const a = he(i, y.ASCII, s, t).split(`
+`)[0], o = Number(a.split("=")[1].split(" ")[0]) + a.length;
+      o > s && (i = await this.getSlice(t, o));
+      const n = he(i, y.ASCII, o, t), f = {};
+      n.split(`
+`).filter((l) => l.length > 0).map((l) => l.split("=")).forEach(([l, c]) => {
+        f[l] = c;
+      }), this.ghostValues = f;
+    }
+    return this.ghostValues;
+  }
+  static async fromSource(t, r, s) {
+    const i = (await t.fetch([{
+      offset: 0,
+      length: 1024
+    }], s))[0], a = new ar(i), o = a.getUint16(0, !1);
+    let n;
+    if (o === 18761) n = !0;
+    else if (o === 19789) n = !1;
+    else throw new TypeError("Invalid byte order value.");
+    const f = a.getUint16(2, n);
+    let l;
+    if (f === 42) l = !1;
+    else if (f === 43) {
+      if (l = !0, a.getUint16(4, n) !== 8) throw new Error("Unsupported offset byte-size.");
+    } else throw new TypeError("Invalid magic number.");
+    const c = l ? a.getUint64(8, n) : a.getUint32(4, n);
+    return new Xe(t, n, l, c, r);
+  }
+  close() {
+    return typeof this.source.close == "function" ? this.source.close() : !1;
+  }
+};
+async function Fs(e, t = {}, r) {
+  return Or.fromSource(xr(e, t), void 0, r);
+}
+export {
+  Fs as fromUrl
+};