@gisfun/maplibre-gl-components 0.15.0-alpha.0

package/dist/geotiff-o_Fq1Na4.js

@@ -0,0 +1,3108 @@
+import { g as Ve } from "./ControlGrid-rVNG7B9O.js";
+const L = {};
+function T(r) {
+  return (e, ...t) => Ot(r, e, t);
+}
+function z(r, e) {
+  return T(
+    je(
+      r,
+      e
+    ).get
+  );
+}
+const {
+  apply: Ot,
+  getOwnPropertyDescriptor: je,
+  getPrototypeOf: De,
+  ownKeys: Pt
+} = Reflect, {
+  iterator: J,
+  toStringTag: Ct
+} = Symbol, Ft = Object, {
+  create: Ee,
+  defineProperty: kt
+} = Ft, Rt = Array, Bt = Rt.prototype, He = Bt[J], Mt = T(He), Ye = ArrayBuffer, Gt = Ye.prototype;
+z(Gt, "byteLength");
+const Ge = typeof SharedArrayBuffer < "u" ? SharedArrayBuffer : null;
+Ge && z(Ge.prototype, "byteLength");
+const $e = De(Uint8Array);
+$e.from;
+const E = $e.prototype;
+E[J];
+T(E.keys);
+T(
+  E.values
+);
+T(
+  E.entries
+);
+T(E.set);
+T(
+  E.reverse
+);
+T(E.fill);
+T(
+  E.copyWithin
+);
+T(E.sort);
+T(E.slice);
+T(
+  E.subarray
+);
+z(
+  E,
+  "buffer"
+);
+z(
+  E,
+  "byteOffset"
+);
+z(
+  E,
+  "length"
+);
+z(
+  E,
+  Ct
+);
+const Ut = Uint8Array, Xe = Uint16Array, Oe = Uint32Array, _t = Float32Array, Z = De([][J]()), Ze = T(Z.next), vt = T((function* () {
+})().next), Lt = De(Z), Nt = DataView.prototype, Kt = T(
+  Nt.getUint16
+), Pe = WeakMap, Je = Pe.prototype, Qe = T(Je.get), zt = T(Je.set), We = new Pe(), qt = Ee(null, {
+  next: {
+    value: function() {
+      const e = Qe(We, this);
+      return Ze(e);
+    }
+  },
+  [J]: {
+    value: function() {
+      return this;
+    }
+  }
+});
+function Vt(r) {
+  if (r[J] === He && Z.next === Ze)
+    return r;
+  const e = Ee(qt);
+  return zt(We, e, Mt(r)), e;
+}
+const jt = new Pe(), Ht = Ee(Lt, {
+  next: {
+    value: function() {
+      const e = Qe(jt, this);
+      return vt(e);
+    },
+    writable: !0,
+    configurable: !0
+  }
+});
+for (const r of Pt(Z))
+  r !== "next" && kt(Ht, r, je(Z, r));
+const et = new Ye(4), Yt = new _t(et), $t = new Oe(et), R = new Xe(512), B = new Ut(512);
+for (let r = 0; r < 256; ++r) {
+  const e = r - 127;
+  e < -24 ? (R[r] = 0, R[r | 256] = 32768, B[r] = 24, B[r | 256] = 24) : e < -14 ? (R[r] = 1024 >> -e - 14, R[r | 256] = 1024 >> -e - 14 | 32768, B[r] = -e - 1, B[r | 256] = -e - 1) : e <= 15 ? (R[r] = e + 15 << 10, R[r | 256] = e + 15 << 10 | 32768, B[r] = 13, B[r | 256] = 13) : e < 128 ? (R[r] = 31744, R[r | 256] = 64512, B[r] = 24, B[r | 256] = 24) : (R[r] = 31744, R[r | 256] = 64512, B[r] = 13, B[r | 256] = 13);
+}
+const Ce = new Oe(2048);
+for (let r = 1; r < 1024; ++r) {
+  let e = r << 13, t = 0;
+  for (; (e & 8388608) === 0; )
+    e <<= 1, t -= 8388608;
+  e &= -8388609, t += 947912704, Ce[r] = e | t;
+}
+for (let r = 1024; r < 2048; ++r)
+  Ce[r] = 939524096 + (r - 1024 << 13);
+const q = new Oe(64);
+for (let r = 1; r < 31; ++r)
+  q[r] = r << 23;
+q[31] = 1199570944;
+q[32] = 2147483648;
+for (let r = 33; r < 63; ++r)
+  q[r] = 2147483648 + (r - 32 << 23);
+q[63] = 3347054592;
+const tt = new Xe(64);
+for (let r = 1; r < 64; ++r)
+  r !== 32 && (tt[r] = 1024);
+function Xt(r) {
+  const e = r >> 10;
+  return $t[0] = Ce[tt[e] + (r & 1023)] + q[e], Yt[0];
+}
+function rt(r, e, ...t) {
+  return Xt(
+    Kt(r, e, ...Vt(t))
+  );
+}
+var ie = { exports: {} }, Ue;
+function Zt() {
+  if (Ue) return ie.exports;
+  Ue = 1;
+  function r(e, t, s) {
+    const i = s && s.debug || !1;
+    i && console.log("[xml-utils] getting " + t + " in " + e);
+    const n = typeof e == "object" ? e.outer : e, a = n.slice(0, n.indexOf(">") + 1), o = ['"', "'"];
+    for (let c = 0; c < o.length; c++) {
+      const l = o[c], f = t + "\\=" + l + "([^" + l + "]*)" + l;
+      i && console.log("[xml-utils] pattern:", f);
+      const u = new RegExp(f).exec(a);
+      if (i && console.log("[xml-utils] match:", u), u) return u[1];
+    }
+  }
+  return ie.exports = r, ie.exports.default = r, ie.exports;
+}
+var Jt = Zt();
+const Se = /* @__PURE__ */ Ve(Jt);
+var ne = { exports: {} }, oe = { exports: {} }, ae = { exports: {} }, _e;
+function Qt() {
+  if (_e) return ae.exports;
+  _e = 1;
+  function r(e, t, s) {
+    const n = new RegExp(t).exec(e.slice(s));
+    return n ? s + n.index : -1;
+  }
+  return ae.exports = r, ae.exports.default = r, ae.exports;
+}
+var ce = { exports: {} }, ve;
+function Wt() {
+  if (ve) return ce.exports;
+  ve = 1;
+  function r(e, t, s) {
+    const n = new RegExp(t).exec(e.slice(s));
+    return n ? s + n.index + n[0].length - 1 : -1;
+  }
+  return ce.exports = r, ce.exports.default = r, ce.exports;
+}
+var le = { exports: {} }, Le;
+function er() {
+  if (Le) return le.exports;
+  Le = 1;
+  function r(e, t) {
+    const s = new RegExp(t, "g"), i = e.match(s);
+    return i ? i.length : 0;
+  }
+  return le.exports = r, le.exports.default = r, le.exports;
+}
+var Ne;
+function tr() {
+  if (Ne) return oe.exports;
+  Ne = 1;
+  const r = Qt(), e = Wt(), t = er();
+  function s(i, n, a) {
+    const o = a && a.debug || !1, c = !(a && typeof a.nested === !1), l = a && a.startIndex || 0;
+    o && console.log("[xml-utils] starting findTagByName with", n, " and ", a);
+    const f = r(i, `<${n}[ 
+>/]`, l);
+    if (o && console.log("[xml-utils] start:", f), f === -1) return;
+    const h = i.slice(f + n.length);
+    let u = e(h, "^[^<]*[ /]>", 0);
+    const d = u !== -1 && h[u - 1] === "/";
+    if (o && console.log("[xml-utils] selfClosing:", d), d === !1)
+      if (c) {
+        let x = 0, w = 1, S = 0;
+        for (; (u = e(h, "[ /]" + n + ">", x)) !== -1; ) {
+          const I = h.substring(x, u + 1);
+          if (w += t(I, "<" + n + `[ 
+	>]`), S += t(I, "</" + n + ">"), S >= w) break;
+          x = u;
+        }
+      } else
+        u = e(h, "[ /]" + n + ">", 0);
+    const g = f + n.length + u + 1;
+    if (o && console.log("[xml-utils] end:", g), g === -1) return;
+    const y = i.slice(f, g);
+    let p;
+    return d ? p = null : p = y.slice(y.indexOf(">") + 1, y.lastIndexOf("<")), { inner: p, outer: y, start: f, end: g };
+  }
+  return oe.exports = s, oe.exports.default = s, oe.exports;
+}
+var Ke;
+function rr() {
+  if (Ke) return ne.exports;
+  Ke = 1;
+  const r = tr();
+  function e(t, s, i) {
+    const n = [], a = i && i.debug || !1, o = i && typeof i.nested == "boolean" ? i.nested : !0;
+    let c = i && i.startIndex || 0, l;
+    for (; l = r(t, s, { debug: a, startIndex: c }); )
+      o ? c = l.start + 1 + s.length : c = l.end, n.push(l);
+    return a && console.log("findTagsByName found", n.length, "tags"), n;
+  }
+  return ne.exports = e, ne.exports.default = e, ne.exports;
+}
+var sr = rr();
+const ir = /* @__PURE__ */ Ve(sr), U = {
+  // TIFF Baseline
+  315: "Artist",
+  258: "BitsPerSample",
+  265: "CellLength",
+  264: "CellWidth",
+  320: "ColorMap",
+  259: "Compression",
+  33432: "Copyright",
+  306: "DateTime",
+  338: "ExtraSamples",
+  266: "FillOrder",
+  289: "FreeByteCounts",
+  288: "FreeOffsets",
+  291: "GrayResponseCurve",
+  290: "GrayResponseUnit",
+  316: "HostComputer",
+  270: "ImageDescription",
+  257: "ImageLength",
+  256: "ImageWidth",
+  271: "Make",
+  281: "MaxSampleValue",
+  280: "MinSampleValue",
+  272: "Model",
+  254: "NewSubfileType",
+  274: "Orientation",
+  262: "PhotometricInterpretation",
+  284: "PlanarConfiguration",
+  296: "ResolutionUnit",
+  278: "RowsPerStrip",
+  277: "SamplesPerPixel",
+  305: "Software",
+  279: "StripByteCounts",
+  273: "StripOffsets",
+  255: "SubfileType",
+  263: "Threshholding",
+  282: "XResolution",
+  283: "YResolution",
+  // TIFF Extended
+  326: "BadFaxLines",
+  327: "CleanFaxData",
+  343: "ClipPath",
+  328: "ConsecutiveBadFaxLines",
+  433: "Decode",
+  434: "DefaultImageColor",
+  269: "DocumentName",
+  336: "DotRange",
+  321: "HalftoneHints",
+  346: "Indexed",
+  347: "JPEGTables",
+  285: "PageName",
+  297: "PageNumber",
+  317: "Predictor",
+  319: "PrimaryChromaticities",
+  532: "ReferenceBlackWhite",
+  339: "SampleFormat",
+  340: "SMinSampleValue",
+  341: "SMaxSampleValue",
+  559: "StripRowCounts",
+  330: "SubIFDs",
+  292: "T4Options",
+  293: "T6Options",
+  325: "TileByteCounts",
+  323: "TileLength",
+  324: "TileOffsets",
+  322: "TileWidth",
+  301: "TransferFunction",
+  318: "WhitePoint",
+  344: "XClipPathUnits",
+  286: "XPosition",
+  529: "YCbCrCoefficients",
+  531: "YCbCrPositioning",
+  530: "YCbCrSubSampling",
+  345: "YClipPathUnits",
+  287: "YPosition",
+  // EXIF
+  37378: "ApertureValue",
+  40961: "ColorSpace",
+  36868: "DateTimeDigitized",
+  36867: "DateTimeOriginal",
+  34665: "Exif IFD",
+  36864: "ExifVersion",
+  33434: "ExposureTime",
+  41728: "FileSource",
+  37385: "Flash",
+  40960: "FlashpixVersion",
+  33437: "FNumber",
+  42016: "ImageUniqueID",
+  37384: "LightSource",
+  37500: "MakerNote",
+  37377: "ShutterSpeedValue",
+  37510: "UserComment",
+  // IPTC
+  33723: "IPTC",
+  // ICC
+  34675: "ICC Profile",
+  // XMP
+  700: "XMP",
+  // GDAL
+  42112: "GDAL_METADATA",
+  42113: "GDAL_NODATA",
+  // Photoshop
+  34377: "Photoshop",
+  // GeoTiff
+  33550: "ModelPixelScale",
+  33922: "ModelTiepoint",
+  34264: "ModelTransformation",
+  34735: "GeoKeyDirectory",
+  34736: "GeoDoubleParams",
+  34737: "GeoAsciiParams",
+  // LERC
+  50674: "LercParameters"
+}, F = {};
+for (const r in U)
+  U.hasOwnProperty(r) && (F[U[r]] = parseInt(r, 10));
+const ue = {
+  256: "SHORT",
+  257: "SHORT",
+  258: "SHORT",
+  259: "SHORT",
+  262: "SHORT",
+  273: "LONG",
+  274: "SHORT",
+  277: "SHORT",
+  278: "LONG",
+  279: "LONG",
+  282: "RATIONAL",
+  283: "RATIONAL",
+  284: "SHORT",
+  286: "SHORT",
+  287: "RATIONAL",
+  296: "SHORT",
+  297: "SHORT",
+  305: "ASCII",
+  306: "ASCII",
+  338: "SHORT",
+  339: "SHORT",
+  513: "LONG",
+  514: "LONG",
+  1024: "SHORT",
+  1025: "SHORT",
+  2048: "SHORT",
+  2049: "ASCII",
+  3072: "SHORT",
+  3073: "ASCII",
+  33550: "DOUBLE",
+  33922: "DOUBLE",
+  34264: "DOUBLE",
+  34665: "LONG",
+  34735: "SHORT",
+  34736: "DOUBLE",
+  34737: "ASCII",
+  42113: "ASCII"
+}, st = [
+  F.BitsPerSample,
+  F.ExtraSamples,
+  F.SampleFormat,
+  F.StripByteCounts,
+  F.StripOffsets,
+  F.StripRowCounts,
+  F.TileByteCounts,
+  F.TileOffsets,
+  F.SubIFDs
+], X = {
+  1: "BYTE",
+  2: "ASCII",
+  3: "SHORT",
+  4: "LONG",
+  5: "RATIONAL",
+  6: "SBYTE",
+  7: "UNDEFINED",
+  8: "SSHORT",
+  9: "SLONG",
+  10: "SRATIONAL",
+  11: "FLOAT",
+  12: "DOUBLE",
+  // IFD offset, suggested by https://owl.phy.queensu.ca/~phil/exiftool/standards.html
+  13: "IFD",
+  // introduced by BigTIFF
+  16: "LONG8",
+  17: "SLONG8",
+  18: "IFD8"
+}, m = {};
+for (const r in X)
+  X.hasOwnProperty(r) && (m[X[r]] = parseInt(r, 10));
+const P = {
+  WhiteIsZero: 0,
+  BlackIsZero: 1,
+  RGB: 2,
+  Palette: 3,
+  TransparencyMask: 4,
+  CMYK: 5,
+  YCbCr: 6,
+  CIELab: 8,
+  ICCLab: 9
+}, it = {
+  Unspecified: 0,
+  Assocalpha: 1,
+  Unassalpha: 2
+}, nr = {
+  Version: 0,
+  AddCompression: 1
+}, or = {
+  None: 0,
+  Deflate: 1,
+  Zstandard: 2
+}, N = {
+  1024: "GTModelTypeGeoKey",
+  1025: "GTRasterTypeGeoKey",
+  1026: "GTCitationGeoKey",
+  2048: "GeographicTypeGeoKey",
+  2049: "GeogCitationGeoKey",
+  2050: "GeogGeodeticDatumGeoKey",
+  2051: "GeogPrimeMeridianGeoKey",
+  2052: "GeogLinearUnitsGeoKey",
+  2053: "GeogLinearUnitSizeGeoKey",
+  2054: "GeogAngularUnitsGeoKey",
+  2055: "GeogAngularUnitSizeGeoKey",
+  2056: "GeogEllipsoidGeoKey",
+  2057: "GeogSemiMajorAxisGeoKey",
+  2058: "GeogSemiMinorAxisGeoKey",
+  2059: "GeogInvFlatteningGeoKey",
+  2060: "GeogAzimuthUnitsGeoKey",
+  2061: "GeogPrimeMeridianLongGeoKey",
+  2062: "GeogTOWGS84GeoKey",
+  3072: "ProjectedCSTypeGeoKey",
+  3073: "PCSCitationGeoKey",
+  3074: "ProjectionGeoKey",
+  3075: "ProjCoordTransGeoKey",
+  3076: "ProjLinearUnitsGeoKey",
+  3077: "ProjLinearUnitSizeGeoKey",
+  3078: "ProjStdParallel1GeoKey",
+  3079: "ProjStdParallel2GeoKey",
+  3080: "ProjNatOriginLongGeoKey",
+  3081: "ProjNatOriginLatGeoKey",
+  3082: "ProjFalseEastingGeoKey",
+  3083: "ProjFalseNorthingGeoKey",
+  3084: "ProjFalseOriginLongGeoKey",
+  3085: "ProjFalseOriginLatGeoKey",
+  3086: "ProjFalseOriginEastingGeoKey",
+  3087: "ProjFalseOriginNorthingGeoKey",
+  3088: "ProjCenterLongGeoKey",
+  3089: "ProjCenterLatGeoKey",
+  3090: "ProjCenterEastingGeoKey",
+  3091: "ProjCenterNorthingGeoKey",
+  3092: "ProjScaleAtNatOriginGeoKey",
+  3093: "ProjScaleAtCenterGeoKey",
+  3094: "ProjAzimuthAngleGeoKey",
+  3095: "ProjStraightVertPoleLongGeoKey",
+  3096: "ProjRectifiedGridAngleGeoKey",
+  4096: "VerticalCSTypeGeoKey",
+  4097: "VerticalCitationGeoKey",
+  4098: "VerticalDatumGeoKey",
+  4099: "VerticalUnitsGeoKey"
+}, nt = {};
+for (const r in N)
+  N.hasOwnProperty(r) && (nt[N[r]] = parseInt(r, 10));
+const ar = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  ExtraSamplesValues: it,
+  LercAddCompression: or,
+  LercParameters: nr,
+  arrayFields: st,
+  fieldTagNames: U,
+  fieldTagTypes: ue,
+  fieldTags: F,
+  fieldTypeNames: X,
+  fieldTypes: m,
+  geoKeyNames: N,
+  geoKeys: nt,
+  photometricInterpretations: P
+}, Symbol.toStringTag, { value: "Module" }));
+function ot(r, e) {
+  const { width: t, height: s } = r, i = new Uint8Array(t * s * 3);
+  let n;
+  for (let a = 0, o = 0; a < r.length; ++a, o += 3)
+    n = 256 - r[a] / e * 256, i[o] = n, i[o + 1] = n, i[o + 2] = n;
+  return i;
+}
+function at(r, e) {
+  const { width: t, height: s } = r, i = new Uint8Array(t * s * 3);
+  let n;
+  for (let a = 0, o = 0; a < r.length; ++a, o += 3)
+    n = r[a] / e * 256, i[o] = n, i[o + 1] = n, i[o + 2] = n;
+  return i;
+}
+function ct(r, e) {
+  const { width: t, height: s } = r, i = new Uint8Array(t * s * 3), n = e.length / 3, a = e.length / 3 * 2;
+  for (let o = 0, c = 0; o < r.length; ++o, c += 3) {
+    const l = r[o];
+    i[c] = e[l] / 65536 * 256, i[c + 1] = e[l + n] / 65536 * 256, i[c + 2] = e[l + a] / 65536 * 256;
+  }
+  return i;
+}
+function lt(r) {
+  const { width: e, height: t } = r, s = new Uint8Array(e * t * 3);
+  for (let i = 0, n = 0; i < r.length; i += 4, n += 3) {
+    const a = r[i], o = r[i + 1], c = r[i + 2], l = r[i + 3];
+    s[n] = 255 * ((255 - a) / 256) * ((255 - l) / 256), s[n + 1] = 255 * ((255 - o) / 256) * ((255 - l) / 256), s[n + 2] = 255 * ((255 - c) / 256) * ((255 - l) / 256);
+  }
+  return s;
+}
+function ft(r) {
+  const { width: e, height: t } = r, s = new Uint8ClampedArray(e * t * 3);
+  for (let i = 0, n = 0; i < r.length; i += 3, n += 3) {
+    const a = r[i], o = r[i + 1], c = r[i + 2];
+    s[n] = a + 1.402 * (c - 128), s[n + 1] = a - 0.34414 * (o - 128) - 0.71414 * (c - 128), s[n + 2] = a + 1.772 * (o - 128);
+  }
+  return s;
+}
+const cr = 0.95047, lr = 1, fr = 1.08883;
+function ht(r) {
+  const { width: e, height: t } = r, s = new Uint8Array(e * t * 3);
+  for (let i = 0, n = 0; i < r.length; i += 3, n += 3) {
+    const a = r[i + 0], o = r[i + 1] << 24 >> 24, c = r[i + 2] << 24 >> 24;
+    let l = (a + 16) / 116, f = o / 500 + l, h = l - c / 200, u, d, g;
+    f = cr * (f * f * f > 8856e-6 ? f * f * f : (f - 16 / 116) / 7.787), l = lr * (l * l * l > 8856e-6 ? l * l * l : (l - 16 / 116) / 7.787), h = fr * (h * h * h > 8856e-6 ? h * h * h : (h - 16 / 116) / 7.787), u = f * 3.2406 + l * -1.5372 + h * -0.4986, d = f * -0.9689 + l * 1.8758 + h * 0.0415, g = f * 0.0557 + l * -0.204 + h * 1.057, u = u > 31308e-7 ? 1.055 * u ** (1 / 2.4) - 0.055 : 12.92 * u, d = d > 31308e-7 ? 1.055 * d ** (1 / 2.4) - 0.055 : 12.92 * d, g = g > 31308e-7 ? 1.055 * g ** (1 / 2.4) - 0.055 : 12.92 * g, s[n] = Math.max(0, Math.min(1, u)) * 255, s[n + 1] = Math.max(0, Math.min(1, d)) * 255, s[n + 2] = Math.max(0, Math.min(1, g)) * 255;
+  }
+  return s;
+}
+const hr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  fromBlackIsZero: at,
+  fromCIELab: ht,
+  fromCMYK: lt,
+  fromPalette: ct,
+  fromWhiteIsZero: ot,
+  fromYCbCr: ft
+}, Symbol.toStringTag, { value: "Module" })), ut = /* @__PURE__ */ new Map();
+function G(r, e) {
+  Array.isArray(r) || (r = [r]), r.forEach((t) => ut.set(t, e));
+}
+async function Fe(r) {
+  const e = ut.get(r.Compression);
+  if (!e)
+    throw new Error(`Unknown compression method identifier: ${r.Compression}`);
+  const t = await e();
+  return new t(r);
+}
+G([void 0, 1], () => import("./raw-DUslI1gr.js").then((r) => r.default));
+G(5, () => import("./lzw-BZniWIYG.js").then((r) => r.default));
+G(6, () => {
+  throw new Error("old style JPEG compression is not supported.");
+});
+G(7, () => import("./jpeg-CF9OGQg_.js").then((r) => r.default));
+G([8, 32946], () => import("./deflate-BA1jZeSX.js").then((r) => r.default));
+G(32773, () => import("./packbits-DWY5O-FG.js").then((r) => r.default));
+G(
+  34887,
+  () => import("./lerc-7LlQoT6u.js").then(async (r) => (await r.zstd.init(), r)).then((r) => r.default)
+);
+G(50001, () => import("./webimage-ibSPOLHJ.js").then((r) => r.default));
+function ge(r, e, t, s = 1) {
+  return new (Object.getPrototypeOf(r)).constructor(e * t * s);
+}
+function ur(r, e, t, s, i) {
+  const n = e / s, a = t / i;
+  return r.map((o) => {
+    const c = ge(o, s, i);
+    for (let l = 0; l < i; ++l) {
+      const f = Math.min(Math.round(a * l), t - 1);
+      for (let h = 0; h < s; ++h) {
+        const u = Math.min(Math.round(n * h), e - 1), d = o[f * e + u];
+        c[l * s + h] = d;
+      }
+    }
+    return c;
+  });
+}
+function K(r, e, t) {
+  return (1 - t) * r + t * e;
+}
+function gr(r, e, t, s, i) {
+  const n = e / s, a = t / i;
+  return r.map((o) => {
+    const c = ge(o, s, i);
+    for (let l = 0; l < i; ++l) {
+      const f = a * l, h = Math.floor(f), u = Math.min(Math.ceil(f), t - 1);
+      for (let d = 0; d < s; ++d) {
+        const g = n * d, y = g % 1, p = Math.floor(g), x = Math.min(Math.ceil(g), e - 1), w = o[h * e + p], S = o[h * e + x], I = o[u * e + p], b = o[u * e + x], O = K(
+          K(w, S, y),
+          K(I, b, y),
+          f % 1
+        );
+        c[l * s + d] = O;
+      }
+    }
+    return c;
+  });
+}
+function dr(r, e, t, s, i, n = "nearest") {
+  switch (n.toLowerCase()) {
+    case "nearest":
+      return ur(r, e, t, s, i);
+    case "bilinear":
+    case "linear":
+      return gr(r, e, t, s, i);
+    default:
+      throw new Error(`Unsupported resampling method: '${n}'`);
+  }
+}
+function yr(r, e, t, s, i, n) {
+  const a = e / s, o = t / i, c = ge(r, s, i, n);
+  for (let l = 0; l < i; ++l) {
+    const f = Math.min(Math.round(o * l), t - 1);
+    for (let h = 0; h < s; ++h) {
+      const u = Math.min(Math.round(a * h), e - 1);
+      for (let d = 0; d < n; ++d) {
+        const g = r[f * e * n + u * n + d];
+        c[l * s * n + h * n + d] = g;
+      }
+    }
+  }
+  return c;
+}
+function pr(r, e, t, s, i, n) {
+  const a = e / s, o = t / i, c = ge(r, s, i, n);
+  for (let l = 0; l < i; ++l) {
+    const f = o * l, h = Math.floor(f), u = Math.min(Math.ceil(f), t - 1);
+    for (let d = 0; d < s; ++d) {
+      const g = a * d, y = g % 1, p = Math.floor(g), x = Math.min(Math.ceil(g), e - 1);
+      for (let w = 0; w < n; ++w) {
+        const S = r[h * e * n + p * n + w], I = r[h * e * n + x * n + w], b = r[u * e * n + p * n + w], O = r[u * e * n + x * n + w], V = K(
+          K(S, I, y),
+          K(b, O, y),
+          f % 1
+        );
+        c[l * s * n + d * n + w] = V;
+      }
+    }
+  }
+  return c;
+}
+function wr(r, e, t, s, i, n, a = "nearest") {
+  switch (a.toLowerCase()) {
+    case "nearest":
+      return yr(
+        r,
+        e,
+        t,
+        s,
+        i,
+        n
+      );
+    case "bilinear":
+    case "linear":
+      return pr(
+        r,
+        e,
+        t,
+        s,
+        i,
+        n
+      );
+    default:
+      throw new Error(`Unsupported resampling method: '${a}'`);
+  }
+}
+function mr(r, e, t) {
+  let s = 0;
+  for (let i = e; i < t; ++i)
+    s += r[i];
+  return s;
+}
+function Ie(r, e, t) {
+  switch (r) {
+    case 1:
+      if (e <= 8)
+        return new Uint8Array(t);
+      if (e <= 16)
+        return new Uint16Array(t);
+      if (e <= 32)
+        return new Uint32Array(t);
+      break;
+    case 2:
+      if (e === 8)
+        return new Int8Array(t);
+      if (e === 16)
+        return new Int16Array(t);
+      if (e === 32)
+        return new Int32Array(t);
+      break;
+    case 3:
+      switch (e) {
+        case 16:
+        case 32:
+          return new Float32Array(t);
+        case 64:
+          return new Float64Array(t);
+      }
+      break;
+  }
+  throw Error("Unsupported data format/bitsPerSample");
+}
+function xr(r, e) {
+  return (r === 1 || r === 2) && e <= 32 && e % 8 === 0 ? !1 : !(r === 3 && (e === 16 || e === 32 || e === 64));
+}
+function Sr(r, e, t, s, i, n, a) {
+  const o = new DataView(r), c = t === 2 ? a * n : a * n * s, l = t === 2 ? 1 : s, f = Ie(e, i, c), h = parseInt("1".repeat(i), 2);
+  if (e === 1) {
+    let u;
+    t === 1 ? u = s * i : u = i;
+    let d = n * u;
+    (d & 7) !== 0 && (d = d + 7 & -8);
+    for (let g = 0; g < a; ++g) {
+      const y = g * d;
+      for (let p = 0; p < n; ++p) {
+        const x = y + p * l * i;
+        for (let w = 0; w < l; ++w) {
+          const S = x + w * i, I = (g * n + p) * l + w, b = Math.floor(S / 8), O = S % 8;
+          if (O + i <= 8)
+            f[I] = o.getUint8(b) >> 8 - i - O & h;
+          else if (O + i <= 16)
+            f[I] = o.getUint16(b) >> 16 - i - O & h;
+          else if (O + i <= 24) {
+            const V = o.getUint16(b) << 8 | o.getUint8(b + 2);
+            f[I] = V >> 24 - i - O & h;
+          } else
+            f[I] = o.getUint32(b) >> 32 - i - O & h;
+        }
+      }
+    }
+  }
+  return f.buffer;
+}
+class ke {
+  /**
+   * @constructor
+   * @param {Object} fileDirectory The parsed file directory
+   * @param {Object} geoKeys The parsed geo-keys
+   * @param {DataView} dataView The DataView for the underlying file.
+   * @param {Boolean} littleEndian Whether the file is encoded in little or big endian
+   * @param {Boolean} cache Whether or not decoded tiles shall be cached
+   * @param {import('./source/basesource').BaseSource} source The datasource to read from
+   */
+  constructor(e, t, s, i, n, a) {
+    this.fileDirectory = e, this.geoKeys = t, this.dataView = s, this.littleEndian = i, this.tiles = n ? {} : null, this.isTiled = !e.StripOffsets;
+    const o = e.PlanarConfiguration;
+    if (this.planarConfiguration = typeof o > "u" ? 1 : o, this.planarConfiguration !== 1 && this.planarConfiguration !== 2)
+      throw new Error("Invalid planar configuration.");
+    this.source = a;
+  }
+  /**
+   * Returns the associated parsed file directory.
+   * @returns {Object} the parsed file directory
+   */
+  getFileDirectory() {
+    return this.fileDirectory;
+  }
+  /**
+   * Returns the associated parsed geo keys.
+   * @returns {Object} the parsed geo keys
+   */
+  getGeoKeys() {
+    return this.geoKeys;
+  }
+  /**
+   * Returns the width of the image.
+   * @returns {Number} the width of the image
+   */
+  getWidth() {
+    return this.fileDirectory.ImageWidth;
+  }
+  /**
+   * Returns the height of the image.
+   * @returns {Number} the height of the image
+   */
+  getHeight() {
+    return this.fileDirectory.ImageLength;
+  }
+  /**
+   * Returns the number of samples per pixel.
+   * @returns {Number} the number of samples per pixel
+   */
+  getSamplesPerPixel() {
+    return typeof this.fileDirectory.SamplesPerPixel < "u" ? this.fileDirectory.SamplesPerPixel : 1;
+  }
+  /**
+   * Returns the width of each tile.
+   * @returns {Number} the width of each tile
+   */
+  getTileWidth() {
+    return this.isTiled ? this.fileDirectory.TileWidth : this.getWidth();
+  }
+  /**
+   * Returns the height of each tile.
+   * @returns {Number} the height of each tile
+   */
+  getTileHeight() {
+    return this.isTiled ? this.fileDirectory.TileLength : typeof this.fileDirectory.RowsPerStrip < "u" ? Math.min(this.fileDirectory.RowsPerStrip, 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();
+  }
+  /**
+   * Calculates the number of bytes for each pixel across all samples. Only full
+   * bytes are supported, an exception is thrown when this is not the case.
+   * @returns {Number} the bytes per pixel
+   */
+  getBytesPerPixel() {
+    let e = 0;
+    for (let t = 0; t < this.fileDirectory.BitsPerSample.length; ++t)
+      e += this.getSampleByteSize(t);
+    return e;
+  }
+  getSampleByteSize(e) {
+    if (e >= this.fileDirectory.BitsPerSample.length)
+      throw new RangeError(`Sample index ${e} is out of range.`);
+    return Math.ceil(this.fileDirectory.BitsPerSample[e] / 8);
+  }
+  getReaderForSample(e) {
+    const t = this.fileDirectory.SampleFormat ? this.fileDirectory.SampleFormat[e] : 1, s = this.fileDirectory.BitsPerSample[e];
+    switch (t) {
+      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, n) {
+              return rt(this, i, n);
+            };
+          case 32:
+            return DataView.prototype.getFloat32;
+          case 64:
+            return DataView.prototype.getFloat64;
+        }
+        break;
+    }
+    throw Error("Unsupported data format/bitsPerSample");
+  }
+  getSampleFormat(e = 0) {
+    return this.fileDirectory.SampleFormat ? this.fileDirectory.SampleFormat[e] : 1;
+  }
+  getBitsPerSample(e = 0) {
+    return this.fileDirectory.BitsPerSample[e];
+  }
+  getArrayForSample(e, t) {
+    const s = this.getSampleFormat(e), i = this.getBitsPerSample(e);
+    return Ie(s, i, t);
+  }
+  /**
+   * Returns the decoded strip or tile.
+   * @param {Number} x the strip or tile x-offset
+   * @param {Number} y the tile y-offset (0 for stripped images)
+   * @param {Number} sample the sample to get for separated samples
+   * @param {import("./geotiff").Pool|import("./geotiff").BaseDecoder} poolOrDecoder the decoder or decoder pool
+   * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
+   *                               to be aborted
+   * @returns {Promise.<ArrayBuffer>}
+   */
+  async getTileOrStrip(e, t, s, i, n) {
+    const a = Math.ceil(this.getWidth() / this.getTileWidth()), o = Math.ceil(this.getHeight() / this.getTileHeight());
+    let c;
+    const { tiles: l } = this;
+    this.planarConfiguration === 1 ? c = t * a + e : this.planarConfiguration === 2 && (c = s * a * o + t * a + e);
+    let f, h;
+    this.isTiled ? (f = this.fileDirectory.TileOffsets[c], h = this.fileDirectory.TileByteCounts[c]) : (f = this.fileDirectory.StripOffsets[c], h = this.fileDirectory.StripByteCounts[c]);
+    const u = (await this.source.fetch([{ offset: f, length: h }], n))[0];
+    let d;
+    return l === null || !l[c] ? (d = (async () => {
+      let g = await i.decode(this.fileDirectory, u);
+      const y = this.getSampleFormat(), p = this.getBitsPerSample();
+      return xr(y, p) && (g = Sr(
+        g,
+        y,
+        this.planarConfiguration,
+        this.getSamplesPerPixel(),
+        p,
+        this.getTileWidth(),
+        this.getBlockHeight(t)
+      )), g;
+    })(), l !== null && (l[c] = d)) : d = l[c], { x: e, y: t, sample: s, data: await d };
+  }
+  /**
+   * Internal read function.
+   * @private
+   * @param {Array} imageWindow The image window in pixel coordinates
+   * @param {Array} samples The selected samples (0-based indices)
+   * @param {TypedArray|TypedArray[]} valueArrays The array(s) to write into
+   * @param {Boolean} interleave Whether or not to write in an interleaved manner
+   * @param {import("./geotiff").Pool|AbstractDecoder} poolOrDecoder the decoder or decoder pool
+   * @param {number} width the width of window to be read into
+   * @param {number} height the height of window to be read into
+   * @param {number} resampleMethod the resampling method to be used when interpolating
+   * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
+   *                               to be aborted
+   * @returns {Promise<ReadRasterResult>}
+   */
+  async _readRaster(e, t, s, i, n, a, o, c, l) {
+    const f = this.getTileWidth(), h = this.getTileHeight(), u = this.getWidth(), d = this.getHeight(), g = Math.max(Math.floor(e[0] / f), 0), y = Math.min(
+      Math.ceil(e[2] / f),
+      Math.ceil(u / f)
+    ), p = Math.max(Math.floor(e[1] / h), 0), x = Math.min(
+      Math.ceil(e[3] / h),
+      Math.ceil(d / h)
+    ), w = e[2] - e[0];
+    let S = this.getBytesPerPixel();
+    const I = [], b = [];
+    for (let D = 0; D < t.length; ++D)
+      this.planarConfiguration === 1 ? I.push(mr(this.fileDirectory.BitsPerSample, 0, t[D]) / 8) : I.push(0), b.push(this.getReaderForSample(t[D]));
+    const O = [], { littleEndian: V } = this;
+    for (let D = p; D < x; ++D)
+      for (let W = g; W < y; ++W) {
+        let me;
+        this.planarConfiguration === 1 && (me = this.getTileOrStrip(W, D, 0, n, l));
+        for (let ee = 0; ee < t.length; ++ee) {
+          const te = ee, Be = t[ee];
+          this.planarConfiguration === 2 && (S = this.getSampleByteSize(Be), me = this.getTileOrStrip(W, D, Be, n, l));
+          const mt = me.then((j) => {
+            const xt = j.data, St = new DataView(xt), xe = this.getBlockHeight(j.y), H = j.y * h, re = j.x * f, It = H + xe, bt = (j.x + 1) * f, Tt = b[te], At = Math.min(xe, xe - (It - e[3]), d - H), Dt = Math.min(f, f - (bt - e[2]), u - re);
+            for (let Y = Math.max(0, e[1] - H); Y < At; ++Y)
+              for (let $ = Math.max(0, e[0] - re); $ < Dt; ++$) {
+                const Et = (Y * f + $) * S, Me = Tt.call(
+                  St,
+                  Et + I[te],
+                  V
+                );
+                let se;
+                i ? (se = (Y + H - e[1]) * w * t.length + ($ + re - e[0]) * t.length + te, s[se] = Me) : (se = (Y + H - e[1]) * w + $ + re - e[0], s[te][se] = Me);
+              }
+          });
+          O.push(mt);
+        }
+      }
+    if (await Promise.all(O), a && e[2] - e[0] !== a || o && e[3] - e[1] !== o) {
+      let D;
+      return i ? D = wr(
+        s,
+        e[2] - e[0],
+        e[3] - e[1],
+        a,
+        o,
+        t.length,
+        c
+      ) : D = dr(
+        s,
+        e[2] - e[0],
+        e[3] - e[1],
+        a,
+        o,
+        c
+      ), D.width = a, D.height = o, D;
+    }
+    return s.width = a || e[2] - e[0], s.height = o || e[3] - e[1], s;
+  }
+  /**
+   * Reads raster data from the image. This function reads all selected samples
+   * into separate arrays of the correct type for that sample or into a single
+   * combined array when `interleave` is set. When provided, only a subset
+   * of the raster is read for each sample.
+   *
+   * @param {ReadRasterOptions} [options={}] optional parameters
+   * @returns {Promise<ReadRasterResult>} the decoded arrays as a promise
+   */
+  async readRasters({
+    window: e,
+    samples: t = [],
+    interleave: s,
+    pool: i = null,
+    width: n,
+    height: a,
+    resampleMethod: o,
+    fillValue: c,
+    signal: l
+  } = {}) {
+    const f = e || [0, 0, this.getWidth(), this.getHeight()];
+    if (f[0] > f[2] || f[1] > f[3])
+      throw new Error("Invalid subsets");
+    const h = f[2] - f[0], u = f[3] - f[1], d = h * u, g = this.getSamplesPerPixel();
+    if (!t || !t.length)
+      for (let w = 0; w < g; ++w)
+        t.push(w);
+    else
+      for (let w = 0; w < t.length; ++w)
+        if (t[w] >= g)
+          return Promise.reject(new RangeError(`Invalid sample index '${t[w]}'.`));
+    let y;
+    if (s) {
+      const w = this.fileDirectory.SampleFormat ? Math.max.apply(null, this.fileDirectory.SampleFormat) : 1, S = Math.max.apply(null, this.fileDirectory.BitsPerSample);
+      y = Ie(w, S, d * t.length), c && y.fill(c);
+    } else {
+      y = [];
+      for (let w = 0; w < t.length; ++w) {
+        const S = this.getArrayForSample(t[w], d);
+        Array.isArray(c) && w < c.length ? S.fill(c[w]) : c && !Array.isArray(c) && S.fill(c), y.push(S);
+      }
+    }
+    const p = i || await Fe(this.fileDirectory);
+    return await this._readRaster(
+      f,
+      t,
+      y,
+      s,
+      p,
+      n,
+      a,
+      o,
+      l
+    );
+  }
+  /**
+   * Reads raster data from the image as RGB. The result is always an
+   * interleaved typed array.
+   * Colorspaces other than RGB will be transformed to RGB, color maps expanded.
+   * When no other method is applicable, the first sample is used to produce a
+   * grayscale image.
+   * When provided, only a subset of the raster is read for each sample.
+   *
+   * @param {Object} [options] optional parameters
+   * @param {Array<number>} [options.window] the subset to read data from in pixels.
+   * @param {boolean} [options.interleave=true] whether the data shall be read
+   *                                             in one single array or separate
+   *                                             arrays.
+   * @param {import("./geotiff").Pool} [options.pool=null] The optional decoder pool to use.
+   * @param {number} [options.width] The desired width of the output. When the width is no the
+   *                                 same as the images, resampling will be performed.
+   * @param {number} [options.height] The desired height of the output. When the width is no the
+   *                                  same as the images, resampling will be performed.
+   * @param {string} [options.resampleMethod='nearest'] The desired resampling method.
+   * @param {boolean} [options.enableAlpha=false] Enable reading alpha channel if present.
+   * @param {AbortSignal} [options.signal] An AbortSignal that may be signalled if the request is
+   *                                       to be aborted
+   * @returns {Promise<ReadRasterResult>} the RGB array as a Promise
+   */
+  async readRGB({
+    window: e,
+    interleave: t = !0,
+    pool: s = null,
+    width: i,
+    height: n,
+    resampleMethod: a,
+    enableAlpha: o = !1,
+    signal: c
+  } = {}) {
+    const l = e || [0, 0, this.getWidth(), this.getHeight()];
+    if (l[0] > l[2] || l[1] > l[3])
+      throw new Error("Invalid subsets");
+    const f = this.fileDirectory.PhotometricInterpretation;
+    if (f === P.RGB) {
+      let x = [0, 1, 2];
+      if (this.fileDirectory.ExtraSamples !== it.Unspecified && o) {
+        x = [];
+        for (let w = 0; w < this.fileDirectory.BitsPerSample.length; w += 1)
+          x.push(w);
+      }
+      return this.readRasters({
+        window: e,
+        interleave: t,
+        samples: x,
+        pool: s,
+        width: i,
+        height: n,
+        resampleMethod: a,
+        signal: c
+      });
+    }
+    let h;
+    switch (f) {
+      case P.WhiteIsZero:
+      case P.BlackIsZero:
+      case P.Palette:
+        h = [0];
+        break;
+      case P.CMYK:
+        h = [0, 1, 2, 3];
+        break;
+      case P.YCbCr:
+      case P.CIELab:
+        h = [0, 1, 2];
+        break;
+      default:
+        throw new Error("Invalid or unsupported photometric interpretation.");
+    }
+    const u = {
+      window: l,
+      interleave: !0,
+      samples: h,
+      pool: s,
+      width: i,
+      height: n,
+      resampleMethod: a,
+      signal: c
+    }, { fileDirectory: d } = this, g = await this.readRasters(u), y = 2 ** this.fileDirectory.BitsPerSample[0];
+    let p;
+    switch (f) {
+      case P.WhiteIsZero:
+        p = ot(g, y);
+        break;
+      case P.BlackIsZero:
+        p = at(g, y);
+        break;
+      case P.Palette:
+        p = ct(g, d.ColorMap);
+        break;
+      case P.CMYK:
+        p = lt(g);
+        break;
+      case P.YCbCr:
+        p = ft(g);
+        break;
+      case P.CIELab:
+        p = ht(g);
+        break;
+      default:
+        throw new Error("Unsupported photometric interpretation.");
+    }
+    if (!t) {
+      const x = new Uint8Array(p.length / 3), w = new Uint8Array(p.length / 3), S = new Uint8Array(p.length / 3);
+      for (let I = 0, b = 0; I < p.length; I += 3, ++b)
+        x[b] = p[I], w[b] = p[I + 1], S[b] = p[I + 2];
+      p = [x, w, S];
+    }
+    return p.width = g.width, p.height = g.height, p;
+  }
+  /**
+   * Returns an array of tiepoints.
+   * @returns {Object[]}
+   */
+  getTiePoints() {
+    if (!this.fileDirectory.ModelTiepoint)
+      return [];
+    const e = [];
+    for (let t = 0; t < this.fileDirectory.ModelTiepoint.length; t += 6)
+      e.push({
+        i: this.fileDirectory.ModelTiepoint[t],
+        j: this.fileDirectory.ModelTiepoint[t + 1],
+        k: this.fileDirectory.ModelTiepoint[t + 2],
+        x: this.fileDirectory.ModelTiepoint[t + 3],
+        y: this.fileDirectory.ModelTiepoint[t + 4],
+        z: this.fileDirectory.ModelTiepoint[t + 5]
+      });
+    return e;
+  }
+  /**
+   * Returns the parsed GDAL metadata items.
+   *
+   * If sample is passed to null, dataset-level metadata will be returned.
+   * Otherwise only metadata specific to the provided sample will be returned.
+   *
+   * @param {number} [sample=null] The sample index.
+   * @returns {Object}
+   */
+  getGDALMetadata(e = null) {
+    const t = {};
+    if (!this.fileDirectory.GDAL_METADATA)
+      return null;
+    const s = this.fileDirectory.GDAL_METADATA;
+    let i = ir(s, "Item");
+    e === null ? i = i.filter((n) => Se(n, "sample") === void 0) : i = i.filter((n) => Number(Se(n, "sample")) === e);
+    for (let n = 0; n < i.length; ++n) {
+      const a = i[n];
+      t[Se(a, "name")] = a.inner;
+    }
+    return t;
+  }
+  /**
+   * Returns the GDAL nodata value
+   * @returns {number|null}
+   */
+  getGDALNoData() {
+    if (!this.fileDirectory.GDAL_NODATA)
+      return null;
+    const e = this.fileDirectory.GDAL_NODATA;
+    return Number(e.substring(0, e.length - 1));
+  }
+  /**
+   * Returns the image origin as a XYZ-vector. When the image has no affine
+   * transformation, then an exception is thrown.
+   * @returns {Array<number>} The origin as a vector
+   */
+  getOrigin() {
+    const e = this.fileDirectory.ModelTiepoint, t = this.fileDirectory.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.");
+  }
+  /**
+   * Returns the image resolution as a XYZ-vector. When the image has no affine
+   * transformation, then an exception is thrown.
+   * @param {GeoTIFFImage} [referenceImage=null] A reference image to calculate the resolution from
+   *                                             in cases when the current image does not have the
+   *                                             required tags on its own.
+   * @returns {Array<number>} The resolution as a vector
+   */
+  getResolution(e = null) {
+    const t = this.fileDirectory.ModelPixelScale, s = this.fileDirectory.ModelTransformation;
+    if (t)
+      return [
+        t[0],
+        -t[1],
+        t[2]
+      ];
+    if (s)
+      return s[1] === 0 && s[4] === 0 ? [
+        s[0],
+        -s[5],
+        s[10]
+      ] : [
+        Math.sqrt(s[0] * s[0] + s[4] * s[4]),
+        -Math.sqrt(s[1] * s[1] + s[5] * s[5]),
+        s[10]
+      ];
+    if (e) {
+      const [i, n, a] = e.getResolution();
+      return [
+        i * e.getWidth() / this.getWidth(),
+        n * e.getHeight() / this.getHeight(),
+        a * e.getWidth() / this.getWidth()
+      ];
+    }
+    throw new Error("The image does not have an affine transformation.");
+  }
+  /**
+   * Returns whether or not the pixels of the image depict an area (or point).
+   * @returns {Boolean} Whether the pixels are a point
+   */
+  pixelIsArea() {
+    return this.geoKeys.GTRasterTypeGeoKey === 1;
+  }
+  /**
+   * Returns the image bounding box as an array of 4 values: min-x, min-y,
+   * max-x and max-y. When the image has no affine transformation, then an
+   * exception is thrown.
+   * @param {boolean} [tilegrid=false] If true return extent for a tilegrid
+   *                                   without adjustment for ModelTransformation.
+   * @returns {Array<number>} The bounding box
+   */
+  getBoundingBox(e = !1) {
+    const t = this.getHeight(), s = this.getWidth();
+    if (this.fileDirectory.ModelTransformation && !e) {
+      const [i, n, a, o, c, l, f, h] = this.fileDirectory.ModelTransformation, d = [
+        [0, 0],
+        [0, t],
+        [s, 0],
+        [s, t]
+      ].map(([p, x]) => [
+        o + i * p + n * x,
+        h + c * p + l * x
+      ]), g = d.map((p) => p[0]), y = d.map((p) => p[1]);
+      return [
+        Math.min(...g),
+        Math.min(...y),
+        Math.max(...g),
+        Math.max(...y)
+      ];
+    } else {
+      const i = this.getOrigin(), n = this.getResolution(), a = i[0], o = i[1], c = a + n[0] * s, l = o + n[1] * t;
+      return [
+        Math.min(a, c),
+        Math.min(o, l),
+        Math.max(a, c),
+        Math.max(o, l)
+      ];
+    }
+  }
+}
+class Ir {
+  constructor(e) {
+    this._dataView = new DataView(e);
+  }
+  get buffer() {
+    return this._dataView.buffer;
+  }
+  getUint64(e, t) {
+    const s = this.getUint32(e, t), i = this.getUint32(e + 4, t);
+    let n;
+    if (t) {
+      if (n = s + 2 ** 32 * i, !Number.isSafeInteger(n))
+        throw new Error(
+          `${n} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues`
+        );
+      return n;
+    }
+    if (n = 2 ** 32 * s + i, !Number.isSafeInteger(n))
+      throw new Error(
+        `${n} exceeds MAX_SAFE_INTEGER. Precision may be lost. Please report if you get this message to https://github.com/geotiffjs/geotiff.js/issues`
+      );
+    return n;
+  }
+  // adapted from https://stackoverflow.com/a/55338384/8060591
+  getInt64(e, t) {
+    let s = 0;
+    const i = (this._dataView.getUint8(e + (t ? 7 : 0)) & 128) > 0;
+    let n = !0;
+    for (let a = 0; a < 8; a++) {
+      let o = this._dataView.getUint8(e + (t ? a : 7 - a));
+      i && (n ? o !== 0 && (o = ~(o - 1) & 255, n = !1) : o = ~o & 255), s += o * 256 ** a;
+    }
+    return i && (s = -s), s;
+  }
+  getUint8(e, t) {
+    return this._dataView.getUint8(e, t);
+  }
+  getInt8(e, t) {
+    return this._dataView.getInt8(e, t);
+  }
+  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 rt(this._dataView, e, t);
+  }
+  getFloat32(e, t) {
+    return this._dataView.getFloat32(e, t);
+  }
+  getFloat64(e, t) {
+    return this._dataView.getFloat64(e, t);
+  }
+}
+class br {
+  constructor(e, t, s, i) {
+    this._dataView = new DataView(e), this._sliceOffset = t, this._littleEndian = s, this._bigTiff = i;
+  }
+  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,
+      this._littleEndian
+    );
+  }
+  readInt8(e) {
+    return this._dataView.getInt8(
+      e - this._sliceOffset,
+      this._littleEndian
+    );
+  }
+  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), s = this.readUint32(e + 4);
+    let i;
+    if (this._littleEndian) {
+      if (i = t + 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 * t + 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;
+  }
+  // adapted from https://stackoverflow.com/a/55338384/8060591
+  readInt64(e) {
+    let t = 0;
+    const s = (this._dataView.getUint8(e + (this._littleEndian ? 7 : 0)) & 128) > 0;
+    let i = !0;
+    for (let n = 0; n < 8; n++) {
+      let a = this._dataView.getUint8(
+        e + (this._littleEndian ? n : 7 - n)
+      );
+      s && (i ? a !== 0 && (a = ~(a - 1) & 255, i = !1) : a = ~a & 255), t += a * 256 ** n;
+    }
+    return s && (t = -t), t;
+  }
+  readOffset(e) {
+    return this._bigTiff ? this.readUint64(e) : this.readUint32(e);
+  }
+}
+const Tr = typeof navigator < "u" && navigator.hardwareConcurrency || 2;
+class Ar {
+  /**
+   * @constructor
+   * @param {Number} [size] The size of the pool. Defaults to the number of CPUs
+   *                      available. When this parameter is `null` or 0, then the
+   *                      decoding will be done in the main thread.
+   * @param {function(): Worker} [createWorker] A function that creates the decoder worker.
+   * Defaults to a worker with all decoders that ship with geotiff.js. The `createWorker()`
+   * function is expected to return a `Worker` compatible with Web Workers. For code that
+   * runs in Node, [web-worker](https://www.npmjs.com/package/web-worker) is a good choice.
+   *
+   * A worker that uses a custom lzw decoder would look like this `my-custom-worker.js` file:
+   * ```js
+   * import { addDecoder, getDecoder } from 'geotiff';
+   * addDecoder(5, () => import ('./my-custom-lzw').then((m) => m.default));
+   * self.addEventListener('message', async (e) => {
+   *   const { id, fileDirectory, buffer } = e.data;
+   *   const decoder = await getDecoder(fileDirectory);
+   *   const decoded = await decoder.decode(fileDirectory, buffer);
+   *   self.postMessage({ decoded, id }, [decoded]);
+   * });
+   * ```
+   * The way the above code is built into a worker by the `createWorker()` function
+   * depends on the used bundler. For most bundlers, something like this will work:
+   * ```js
+   * function createWorker() {
+   *   return new Worker(new URL('./my-custom-worker.js', import.meta.url));
+   * }
+   * ```
+   */
+  constructor(e = Tr, t) {
+    this.workers = null, this._awaitingDecoder = null, this.size = e, this.messageId = 0, e && (this._awaitingDecoder = t ? Promise.resolve(t) : new Promise((s) => {
+      import("./decoder-CLokFc0V.js").then((i) => {
+        s(i.create);
+      });
+    }), this._awaitingDecoder.then((s) => {
+      this._awaitingDecoder = null, this.workers = [];
+      for (let i = 0; i < e; i++)
+        this.workers.push({ worker: s(), idle: !0 });
+    }));
+  }
+  /**
+   * Decode the given block of bytes with the set compression method.
+   * @param {ArrayBuffer} buffer the array buffer of bytes to decode.
+   * @returns {Promise<ArrayBuffer>} the decoded result as a `Promise`
+   */
+  async decode(e, t) {
+    return this._awaitingDecoder && await this._awaitingDecoder, this.size === 0 ? Fe(e).then((s) => s.decode(e, t)) : new Promise((s) => {
+      const i = this.workers.find((o) => o.idle) || this.workers[Math.floor(Math.random() * this.size)];
+      i.idle = !1;
+      const n = this.messageId++, a = (o) => {
+        o.data.id === n && (i.idle = !0, s(o.data.decoded), i.worker.removeEventListener("message", a));
+      };
+      i.worker.addEventListener("message", a), i.worker.postMessage({ fileDirectory: e, buffer: t, id: n }, [t]);
+    });
+  }
+  destroy() {
+    this.workers && (this.workers.forEach((e) => {
+      e.worker.terminate();
+    }), this.workers = null);
+  }
+}
+const ze = `\r
+\r
+`;
+function gt(r) {
+  if (typeof Object.fromEntries < "u")
+    return Object.fromEntries(r);
+  const e = {};
+  for (const [t, s] of r)
+    e[t.toLowerCase()] = s;
+  return e;
+}
+function Dr(r) {
+  const e = r.split(`\r
+`).map((t) => {
+    const s = t.split(":").map((i) => i.trim());
+    return s[0] = s[0].toLowerCase(), s;
+  });
+  return gt(e);
+}
+function Er(r) {
+  const [e, ...t] = r.split(";").map((i) => i.trim()), s = t.map((i) => i.split("="));
+  return { type: e, params: gt(s) };
+}
+function be(r) {
+  let e, t, s;
+  return r && ([, e, t, s] = r.match(/bytes (\d+)-(\d+)\/(\d+)/), e = parseInt(e, 10), t = parseInt(t, 10), s = parseInt(s, 10)), { start: e, end: t, total: s };
+}
+function Or(r, e) {
+  let t = null;
+  const s = new TextDecoder("ascii"), i = [], n = `--${e}`, a = `${n}--`;
+  for (let o = 0; o < 10; ++o)
+    s.decode(
+      new Uint8Array(r, o, n.length)
+    ) === n && (t = o);
+  if (t === null)
+    throw new Error("Could not find initial boundary");
+  for (; t < r.byteLength; ) {
+    const o = s.decode(
+      new Uint8Array(
+        r,
+        t,
+        Math.min(n.length + 1024, r.byteLength - t)
+      )
+    );
+    if (o.length === 0 || o.startsWith(a))
+      break;
+    if (!o.startsWith(n))
+      throw new Error("Part does not start with boundary");
+    const c = o.substr(n.length + 2);
+    if (c.length === 0)
+      break;
+    const l = c.indexOf(ze), f = Dr(c.substr(0, l)), { start: h, end: u, total: d } = be(f["content-range"]), g = t + n.length + l + ze.length, y = parseInt(u, 10) + 1 - parseInt(h, 10);
+    i.push({
+      headers: f,
+      data: r.slice(g, g + y),
+      offset: h,
+      length: y,
+      fileSize: d
+    }), t = g + y + 4;
+  }
+  return i;
+}
+class Q {
+  /**
+   *
+   * @param {Slice[]} slices
+   * @returns {ArrayBuffer[]}
+   */
+  async fetch(e, t = void 0) {
+    return Promise.all(
+      e.map((s) => this.fetchSlice(s, t))
+    );
+  }
+  /**
+   *
+   * @param {Slice} slice
+   * @returns {ArrayBuffer}
+   */
+  async fetchSlice(e) {
+    throw new Error(`fetching of slice ${e} not possible, not implemented`);
+  }
+  /**
+   * Returns the filesize if already determined and null otherwise
+   */
+  get fileSize() {
+    return null;
+  }
+  async close() {
+  }
+}
+class Pr 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;
+  }
+  // TODO: Use private class methods when targeting Node.js 16.
+  _emitEvictions(e) {
+    if (typeof this.onEviction == "function")
+      for (const [t, s] of e)
+        this.onEviction(t, s.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 s = t.get(e);
+    return this._getItemValue(e, s);
+  }
+  _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, s] = e;
+      this.cache.has(t) || this._deleteIfExpired(t, s) === !1 && (yield e);
+    }
+    for (const e of this.cache) {
+      const [t, s] = e;
+      this._deleteIfExpired(t, s) === !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: s = this.maxAge } = {}) {
+    const i = typeof s == "number" && s !== Number.POSITIVE_INFINITY ? Date.now() + s : void 0;
+    return this.cache.has(e) ? this.cache.set(e, {
+      value: t,
+      expiry: i
+    }) : this._set(e, { value: t, expiry: i }), 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()], s = t.length - e;
+    s < 0 ? (this.cache = new Map(t), this.oldCache = /* @__PURE__ */ new Map(), this._size = t.length) : (s > 0 && this._emitEvictions(t.slice(0, s)), this.oldCache = new Map(t.slice(s)), 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, s] = e;
+      this._deleteIfExpired(t, s) === !1 && (yield [t, s.value]);
+    }
+    for (const e of this.oldCache) {
+      const [t, s] = e;
+      this.cache.has(t) || this._deleteIfExpired(t, s) === !1 && (yield [t, s.value]);
+    }
+  }
+  *entriesDescending() {
+    let e = [...this.cache];
+    for (let t = e.length - 1; t >= 0; --t) {
+      const s = e[t], [i, n] = s;
+      this._deleteIfExpired(i, n) === !1 && (yield [i, n.value]);
+    }
+    e = [...this.oldCache];
+    for (let t = e.length - 1; t >= 0; --t) {
+      const s = e[t], [i, n] = s;
+      this.cache.has(i) || this._deleteIfExpired(i, n) === !1 && (yield [i, n.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 [s, i] of this.entriesAscending())
+      e.call(t, i, s, this);
+  }
+  get [Symbol.toStringTag]() {
+    return JSON.stringify([...this.entriesAscending()]);
+  }
+}
+function dt(r, e) {
+  for (const t in e)
+    e.hasOwnProperty(t) && (r[t] = e[t]);
+}
+function yt(r, e) {
+  return r.length < e.length ? !1 : r.substr(r.length - e.length) === e;
+}
+function Cr(r, e) {
+  const { length: t } = r;
+  for (let s = 0; s < t; s++)
+    e(r[s], s);
+}
+function Re(r) {
+  const e = {};
+  for (const t in r)
+    if (r.hasOwnProperty(t)) {
+      const s = r[t];
+      e[s] = t;
+    }
+  return e;
+}
+function C(r, e) {
+  const t = [];
+  for (let s = 0; s < r; s++)
+    t.push(e(s));
+  return t;
+}
+async function Fr(r) {
+  return new Promise((e) => setTimeout(e, r));
+}
+function kr(r, e) {
+  const t = Array.isArray(r) ? r : Array.from(r), s = Array.isArray(e) ? e : Array.from(e);
+  return t.map((i, n) => [i, s[n]]);
+}
+class _ extends Error {
+  constructor(e) {
+    super(e), Error.captureStackTrace && Error.captureStackTrace(this, _), this.name = "AbortError";
+  }
+}
+class Rr extends Error {
+  constructor(e, t) {
+    super(t), this.errors = e, this.message = t, this.name = "AggregateError";
+  }
+}
+const Br = Rr;
+class Mr {
+  /**
+   *
+   * @param {number} offset
+   * @param {number} length
+   * @param {ArrayBuffer} [data]
+   */
+  constructor(e, t, s = null) {
+    this.offset = e, this.length = t, this.data = s;
+  }
+  /**
+   * @returns {number} the top byte border
+   */
+  get top() {
+    return this.offset + this.length;
+  }
+}
+class qe {
+  /**
+   *
+   * @param {number} offset
+   * @param {number} length
+   * @param {number[]} blockIds
+   */
+  constructor(e, t, s) {
+    this.offset = e, this.length = t, this.blockIds = s;
+  }
+}
+class Gr extends Q {
+  /**
+   *
+   * @param {BaseSource} source The underlying source that shall be blocked and cached
+   * @param {object} options
+   * @param {number} [options.blockSize]
+   * @param {number} [options.cacheSize]
+   */
+  constructor(e, { blockSize: t = 65536, cacheSize: s = 100 } = {}) {
+    super(), this.source = e, this.blockSize = t, this.blockCache = new Pr({
+      maxSize: s,
+      onEviction: (i, n) => {
+        this.evictedBlocks.set(i, n);
+      }
+    }), 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;
+  }
+  /**
+   *
+   * @param {import("./basesource").Slice[]} slices
+   */
+  async fetch(e, t) {
+    const s = [], i = [], n = [];
+    this.evictedBlocks.clear();
+    for (const { offset: u, length: d } of e) {
+      let g = u + d;
+      const { fileSize: y } = this;
+      y !== null && (g = Math.min(g, y));
+      const p = Math.floor(u / this.blockSize) * this.blockSize;
+      for (let x = p; x < g; x += this.blockSize) {
+        const w = Math.floor(x / this.blockSize);
+        !this.blockCache.has(w) && !this.blockRequests.has(w) && (this.blockIdsToFetch.add(w), i.push(w)), this.blockRequests.has(w) && s.push(this.blockRequests.get(w)), n.push(w);
+      }
+    }
+    await Fr(), this.fetchBlocks(t);
+    const a = [];
+    for (const u of i)
+      this.blockRequests.has(u) && a.push(this.blockRequests.get(u));
+    await Promise.allSettled(s), await Promise.allSettled(a);
+    const o = [], c = n.filter((u) => this.abortedBlockIds.has(u) || !this.blockCache.has(u));
+    if (c.forEach((u) => this.blockIdsToFetch.add(u)), c.length > 0 && t && !t.aborted) {
+      this.fetchBlocks(null);
+      for (const u of c) {
+        const d = this.blockRequests.get(u);
+        if (!d)
+          throw new Error(`Block ${u} is not in the block requests`);
+        o.push(d);
+      }
+      await Promise.allSettled(o);
+    }
+    if (t && t.aborted)
+      throw new _("Request was aborted");
+    const l = n.map((u) => this.blockCache.get(u) || this.evictedBlocks.get(u)), f = l.filter((u) => !u);
+    if (f.length)
+      throw new Br(f, "Request failed");
+    const h = new Map(kr(n, l));
+    return this.readSliceData(e, h);
+  }
+  /**
+   *
+   * @param {AbortSignal} signal
+   */
+  fetchBlocks(e) {
+    if (this.blockIdsToFetch.size > 0) {
+      const t = this.groupBlocks(this.blockIdsToFetch), s = this.source.fetch(t, e);
+      for (let i = 0; i < t.length; ++i) {
+        const n = t[i];
+        for (const a of n.blockIds)
+          this.blockRequests.set(a, (async () => {
+            try {
+              const o = (await s)[i], c = a * this.blockSize, l = c - o.offset, f = Math.min(l + this.blockSize, o.data.byteLength), h = o.data.slice(l, f), u = new Mr(
+                c,
+                h.byteLength,
+                h,
+                a
+              );
+              this.blockCache.set(a, u), this.abortedBlockIds.delete(a);
+            } catch (o) {
+              if (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();
+    }
+  }
+  /**
+   *
+   * @param {Set} blockIds
+   * @returns {BlockGroup[]}
+   */
+  groupBlocks(e) {
+    const t = Array.from(e).sort((a, o) => a - o);
+    if (t.length === 0)
+      return [];
+    let s = [], i = null;
+    const n = [];
+    for (const a of t)
+      i === null || i + 1 === a ? (s.push(a), i = a) : (n.push(new qe(
+        s[0] * this.blockSize,
+        s.length * this.blockSize,
+        s
+      )), s = [a], i = a);
+    return n.push(new qe(
+      s[0] * this.blockSize,
+      s.length * this.blockSize,
+      s
+    )), n;
+  }
+  /**
+   *
+   * @param {import("./basesource").Slice[]} slices
+   * @param {Map} blocks
+   */
+  readSliceData(e, t) {
+    return e.map((s) => {
+      let i = s.offset + s.length;
+      this.fileSize !== null && (i = Math.min(this.fileSize, i));
+      const n = Math.floor(s.offset / this.blockSize), a = Math.floor(i / this.blockSize), o = new ArrayBuffer(s.length), c = new Uint8Array(o);
+      for (let l = n; l <= a; ++l) {
+        const f = t.get(l), h = f.offset - s.offset, u = f.top - i;
+        let d = 0, g = 0, y;
+        h < 0 ? d = -h : h > 0 && (g = h), u < 0 ? y = f.length - d : y = i - f.offset - d;
+        const p = new Uint8Array(f.data, d, y);
+        c.set(p, g);
+      }
+      return o;
+    });
+  }
+}
+class de {
+  /**
+   * Returns whether the response has an ok'ish status code
+   */
+  get ok() {
+    return this.status >= 200 && this.status <= 299;
+  }
+  /**
+   * Returns the status code of the response
+   */
+  get status() {
+    throw new Error("not implemented");
+  }
+  /**
+   * Returns the value of the specified header
+   * @param {string} headerName the header name
+   * @returns {string} the header value
+   */
+  getHeader(e) {
+    throw new Error("not implemented");
+  }
+  /**
+   * @returns {ArrayBuffer} the response data of the request
+   */
+  async getData() {
+    throw new Error("not implemented");
+  }
+}
+class ye {
+  constructor(e) {
+    this.url = e;
+  }
+  /**
+   * Send a request with the options
+   * @param {{headers: HeadersInit, signal: AbortSignal}} [options={}]
+   * @returns {Promise<BaseResponse>}
+   */
+  async request({ headers: e, signal: t } = {}) {
+    throw new Error("request is not implemented");
+  }
+}
+class Ur extends de {
+  /**
+   * BaseResponse facade for fetch API Response
+   * @param {Response} response
+   */
+  constructor(e) {
+    super(), this.response = e;
+  }
+  get status() {
+    return this.response.status;
+  }
+  getHeader(e) {
+    return this.response.headers.get(e);
+  }
+  async getData() {
+    return this.response.arrayBuffer ? await this.response.arrayBuffer() : (await this.response.buffer()).buffer;
+  }
+}
+class _r extends ye {
+  constructor(e, t) {
+    super(e), this.credentials = t;
+  }
+  /**
+   * @param {{headers: HeadersInit, signal: AbortSignal}} [options={}]
+   * @returns {Promise<FetchResponse>}
+   */
+  async request({ headers: e, signal: t } = {}) {
+    const s = await fetch(this.url, {
+      headers: e,
+      credentials: this.credentials,
+      signal: t
+    });
+    return new Ur(s);
+  }
+}
+class vr extends de {
+  /**
+   * BaseResponse facade for XMLHttpRequest
+   * @param {XMLHttpRequest} xhr
+   * @param {ArrayBuffer} data
+   */
+  constructor(e, t) {
+    super(), this.xhr = e, this.data = t;
+  }
+  get status() {
+    return this.xhr.status;
+  }
+  getHeader(e) {
+    return this.xhr.getResponseHeader(e);
+  }
+  async getData() {
+    return this.data;
+  }
+}
+class Lr extends ye {
+  constructRequest(e, t) {
+    return new Promise((s, i) => {
+      const n = new XMLHttpRequest();
+      n.open("GET", this.url), n.responseType = "arraybuffer";
+      for (const [a, o] of Object.entries(e))
+        n.setRequestHeader(a, o);
+      n.onload = () => {
+        const a = n.response;
+        s(new vr(n, a));
+      }, n.onerror = i, n.onabort = () => i(new _("Request aborted")), n.send(), t && (t.aborted && n.abort(), t.addEventListener("abort", () => n.abort()));
+    });
+  }
+  async request({ headers: e, signal: t } = {}) {
+    return await this.constructRequest(e, t);
+  }
+}
+class Nr extends de {
+  /**
+   * BaseResponse facade for node HTTP/HTTPS API Response
+   * @param {http.ServerResponse} response
+   */
+  constructor(e, t) {
+    super(), this.response = e, this.dataPromise = t;
+  }
+  get status() {
+    return this.response.statusCode;
+  }
+  getHeader(e) {
+    return this.response.headers[e];
+  }
+  async getData() {
+    return await this.dataPromise;
+  }
+}
+class Kr extends ye {
+  constructor(e) {
+    super(e), this.parsedUrl = L.parse(this.url), this.httpApi = (this.parsedUrl.protocol === "http:", L);
+  }
+  constructRequest(e, t) {
+    return new Promise((s, i) => {
+      const n = this.httpApi.get(
+        {
+          ...this.parsedUrl,
+          headers: e
+        },
+        (a) => {
+          const o = new Promise((c) => {
+            const l = [];
+            a.on("data", (f) => {
+              l.push(f);
+            }), a.on("end", () => {
+              const f = Buffer.concat(l).buffer;
+              c(f);
+            }), a.on("error", i);
+          });
+          s(new Nr(a, o));
+        }
+      );
+      n.on("error", i), t && (t.aborted && n.destroy(new _("Request aborted")), t.addEventListener("abort", () => n.destroy(new _("Request aborted"))));
+    });
+  }
+  async request({ headers: e, signal: t } = {}) {
+    return await this.constructRequest(e, t);
+  }
+}
+class pe extends Q {
+  /**
+   *
+   * @param {BaseClient} client
+   * @param {object} headers
+   * @param {numbers} maxRanges
+   * @param {boolean} allowFullFile
+   */
+  constructor(e, t, s, i) {
+    super(), this.client = e, this.headers = t, this.maxRanges = s, this.allowFullFile = i, this._fileSize = null;
+  }
+  /**
+   *
+   * @param {Slice[]} slices
+   */
+  async fetch(e, t) {
+    return this.maxRanges >= e.length ? this.fetchSlices(e, t) : (this.maxRanges > 0 && e.length > 1, Promise.all(
+      e.map((s) => this.fetchSlice(s, t))
+    ));
+  }
+  async fetchSlices(e, t) {
+    const s = await this.client.request({
+      headers: {
+        ...this.headers,
+        Range: `bytes=${e.map(({ offset: i, length: n }) => `${i}-${i + n}`).join(",")}`
+      },
+      signal: t
+    });
+    if (s.ok)
+      if (s.status === 206) {
+        const { type: i, params: n } = Er(s.getHeader("content-type"));
+        if (i === "multipart/byteranges") {
+          const h = Or(await s.getData(), n.boundary);
+          return this._fileSize = h[0].fileSize || null, h;
+        }
+        const a = await s.getData(), { start: o, end: c, total: l } = be(s.getHeader("content-range"));
+        this._fileSize = l || null;
+        const f = [{
+          data: a,
+          offset: o,
+          length: c - o
+        }];
+        if (e.length > 1) {
+          const h = await Promise.all(e.slice(1).map((u) => this.fetchSlice(u, t)));
+          return f.concat(h);
+        }
+        return f;
+      } else {
+        if (!this.allowFullFile)
+          throw new Error("Server responded with full file");
+        const i = await s.getData();
+        return this._fileSize = i.byteLength, [{
+          data: i,
+          offset: 0,
+          length: i.byteLength
+        }];
+      }
+    else throw new Error("Error fetching data.");
+  }
+  async fetchSlice(e, t) {
+    const { offset: s, length: i } = e, n = await this.client.request({
+      headers: {
+        ...this.headers,
+        Range: `bytes=${s}-${s + i}`
+      },
+      signal: t
+    });
+    if (n.ok)
+      if (n.status === 206) {
+        const a = await n.getData(), { total: o } = be(n.getHeader("content-range"));
+        return this._fileSize = o || null, {
+          data: a,
+          offset: s,
+          length: i
+        };
+      } else {
+        if (!this.allowFullFile)
+          throw new Error("Server responded with full file");
+        const a = await n.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 we(r, { blockSize: e, cacheSize: t }) {
+  return e === null ? r : new Gr(r, { blockSize: e, cacheSize: t });
+}
+function zr(r, { headers: e = {}, credentials: t, maxRanges: s = 0, allowFullFile: i = !1, ...n } = {}) {
+  const a = new _r(r, t), o = new pe(a, e, s, i);
+  return we(o, n);
+}
+function qr(r, { headers: e = {}, maxRanges: t = 0, allowFullFile: s = !1, ...i } = {}) {
+  const n = new Lr(r), a = new pe(n, e, t, s);
+  return we(a, i);
+}
+function Vr(r, { headers: e = {}, maxRanges: t = 0, allowFullFile: s = !1, ...i } = {}) {
+  const n = new Kr(r), a = new pe(n, e, t, s);
+  return we(a, i);
+}
+function jr(r, { headers: e = {}, maxRanges: t = 0, allowFullFile: s = !1, ...i } = {}) {
+  const n = new pe(r, e, t, s);
+  return we(n, i);
+}
+function Te(r, { forceXHR: e = !1, ...t } = {}) {
+  return typeof fetch == "function" && !e ? zr(r, t) : typeof XMLHttpRequest < "u" ? qr(r, t) : Vr(r, t);
+}
+class Hr extends Q {
+  constructor(e) {
+    super(), this.arrayBuffer = e;
+  }
+  fetchSlice(e, t) {
+    if (t && t.aborted)
+      throw new _("Request aborted");
+    return this.arrayBuffer.slice(e.offset, e.offset + e.length);
+  }
+}
+function Yr(r) {
+  return new Hr(r);
+}
+class $r extends Q {
+  constructor(e) {
+    super(), this.file = e;
+  }
+  async fetchSlice(e, t) {
+    return new Promise((s, i) => {
+      const n = this.file.slice(e.offset, e.offset + e.length), a = new FileReader();
+      a.onload = (o) => s(o.target.result), a.onerror = i, a.onabort = i, a.readAsArrayBuffer(n), t && t.addEventListener("abort", () => a.abort());
+    });
+  }
+}
+function Xr(r) {
+  return new $r(r);
+}
+function Zr(r) {
+  return new Promise((e, t) => {
+    L.close(r, (s) => {
+      s ? t(s) : e();
+    });
+  });
+}
+function Jr(r, e, t = void 0) {
+  return new Promise((s, i) => {
+    L.open(r, e, t, (n, a) => {
+      n ? i(n) : s(a);
+    });
+  });
+}
+function Qr(...r) {
+  return new Promise((e, t) => {
+    L.read(...r, (s, i, n) => {
+      s ? t(s) : e({ bytesRead: i, buffer: n });
+    });
+  });
+}
+class Wr extends Q {
+  constructor(e) {
+    super(), this.path = e, this.openRequest = Jr(e, "r");
+  }
+  async fetchSlice(e) {
+    const t = await this.openRequest, { buffer: s } = await Qr(
+      t,
+      Buffer.alloc(e.length),
+      0,
+      e.length,
+      e.offset
+    );
+    return s.buffer;
+  }
+  async close() {
+    const e = await this.openRequest;
+    await Zr(e);
+  }
+}
+function es(r) {
+  return new Wr(r);
+}
+const ts = Re(U), rs = Re(N), M = {};
+dt(M, ts);
+dt(M, rs);
+const ss = Re(X), he = 1e3, A = {
+  nextZero: (r, e) => {
+    let t = e;
+    for (; r[t] !== 0; )
+      t++;
+    return t;
+  },
+  readUshort: (r, e) => r[e] << 8 | r[e + 1],
+  readShort: (r, e) => {
+    const t = A.ui8;
+    return t[0] = r[e + 1], t[1] = r[e + 0], A.i16[0];
+  },
+  readInt: (r, e) => {
+    const t = A.ui8;
+    return t[0] = r[e + 3], t[1] = r[e + 2], t[2] = r[e + 1], t[3] = r[e + 0], A.i32[0];
+  },
+  readUint: (r, e) => {
+    const t = A.ui8;
+    return t[0] = r[e + 3], t[1] = r[e + 2], t[2] = r[e + 1], t[3] = r[e + 0], A.ui32[0];
+  },
+  readASCII: (r, e, t) => t.map((s) => String.fromCharCode(r[e + s])).join(""),
+  readFloat: (r, e) => {
+    const t = A.ui8;
+    return C(4, (s) => {
+      t[s] = r[e + 3 - s];
+    }), A.fl32[0];
+  },
+  readDouble: (r, e) => {
+    const t = A.ui8;
+    return C(8, (s) => {
+      t[s] = r[e + 7 - s];
+    }), A.fl64[0];
+  },
+  writeUshort: (r, e, t) => {
+    r[e] = t >> 8 & 255, r[e + 1] = t & 255;
+  },
+  writeUint: (r, e, t) => {
+    r[e] = t >> 24 & 255, r[e + 1] = t >> 16 & 255, r[e + 2] = t >> 8 & 255, r[e + 3] = t >> 0 & 255;
+  },
+  writeASCII: (r, e, t) => {
+    C(t.length, (s) => {
+      r[e + s] = t.charCodeAt(s);
+    });
+  },
+  ui8: new Uint8Array(8)
+};
+A.fl64 = new Float64Array(A.ui8.buffer);
+A.writeDouble = (r, e, t) => {
+  A.fl64[0] = t, C(8, (s) => {
+    r[e + s] = A.ui8[7 - s];
+  });
+};
+const is = (r, e, t, s) => {
+  let i = t;
+  const n = Object.keys(s).filter((o) => o != null && o !== "undefined");
+  r.writeUshort(e, i, n.length), i += 2;
+  let a = i + 12 * n.length + 4;
+  for (const o of n) {
+    let c = null;
+    typeof o == "number" ? c = o : typeof o == "string" && (c = parseInt(o, 10));
+    const l = ue[c], f = ss[l];
+    if (l == null || l === void 0 || typeof l > "u")
+      throw new Error(`unknown type of tag: ${c}`);
+    let h = s[o];
+    if (h === void 0)
+      throw new Error(`failed to get value for key ${o}`);
+    l === "ASCII" && typeof h == "string" && yt(h, "\0") === !1 && (h += "\0");
+    const u = h.length;
+    r.writeUshort(e, i, c), i += 2, r.writeUshort(e, i, f), i += 2, r.writeUint(e, i, u), i += 4;
+    let d = [-1, 1, 1, 2, 4, 8, 0, 0, 0, 0, 0, 0, 8][f] * u, g = i;
+    d > 4 && (r.writeUint(e, i, a), g = a), l === "ASCII" ? r.writeASCII(e, g, h) : l === "SHORT" ? C(u, (y) => {
+      r.writeUshort(e, g + 2 * y, h[y]);
+    }) : l === "LONG" ? C(u, (y) => {
+      r.writeUint(e, g + 4 * y, h[y]);
+    }) : l === "RATIONAL" ? C(u, (y) => {
+      r.writeUint(e, g + 8 * y, Math.round(h[y] * 1e4)), r.writeUint(e, g + 8 * y + 4, 1e4);
+    }) : l === "DOUBLE" && C(u, (y) => {
+      r.writeDouble(e, g + 8 * y, h[y]);
+    }), d > 4 && (d += d & 1, a += d), i += 4;
+  }
+  return [i, a];
+}, ns = (r) => {
+  const e = new Uint8Array(he);
+  let t = 4;
+  const s = A;
+  e[0] = 77, e[1] = 77, e[3] = 42;
+  let i = 8;
+  if (s.writeUint(e, t, i), t += 4, r.forEach((a, o) => {
+    const c = is(s, e, i, a);
+    i = c[1], o < r.length - 1 && s.writeUint(e, c[0], i);
+  }), e.slice)
+    return e.slice(0, i).buffer;
+  const n = new Uint8Array(i);
+  for (let a = 0; a < i; a++)
+    n[a] = e[a];
+  return n.buffer;
+}, os = (r, e, t, s) => {
+  if (t == null)
+    throw new Error(`you passed into encodeImage a width of type ${t}`);
+  if (e == null)
+    throw new Error(`you passed into encodeImage a width of type ${e}`);
+  const i = {
+    256: [e],
+    // ImageWidth
+    257: [t],
+    // ImageLength
+    273: [he],
+    // strips offset
+    278: [t],
+    // RowsPerStrip
+    305: "geotiff.js"
+    // no array for ASCII(Z)
+  };
+  if (s)
+    for (const l in s)
+      s.hasOwnProperty(l) && (i[l] = s[l]);
+  const n = new Uint8Array(ns([i])), a = new Uint8Array(r), o = i[277], c = new Uint8Array(he + e * t * o);
+  return C(n.length, (l) => {
+    c[l] = n[l];
+  }), Cr(a, (l, f) => {
+    c[he + f] = l;
+  }), c.buffer;
+}, as = (r) => {
+  const e = {};
+  for (const t in r)
+    t !== "StripOffsets" && (M[t] || console.error(t, "not in name2code:", Object.keys(M)), e[M[t]] = r[t]);
+  return e;
+}, cs = (r) => Array.isArray(r) ? r : [r], ls = [
+  ["Compression", 1],
+  // no compression
+  ["PlanarConfiguration", 1],
+  ["ExtraSamples", 0]
+];
+function fs(r, e) {
+  const t = typeof r[0] == "number";
+  let s, i, n, a;
+  t ? (s = e.height || e.ImageLength, n = e.width || e.ImageWidth, i = r.length / (s * n), a = r) : (i = r.length, s = r[0].length, n = r[0][0].length, a = [], C(s, (f) => {
+    C(n, (h) => {
+      C(i, (u) => {
+        a.push(r[u][f][h]);
+      });
+    });
+  })), e.ImageLength = s, delete e.height, e.ImageWidth = n, delete e.width, e.BitsPerSample || (e.BitsPerSample = C(i, () => 8)), ls.forEach((f) => {
+    const h = f[0];
+    if (!e[h]) {
+      const u = f[1];
+      e[h] = u;
+    }
+  }), e.PhotometricInterpretation || (e.PhotometricInterpretation = e.BitsPerSample.length === 3 ? 2 : 1), e.SamplesPerPixel || (e.SamplesPerPixel = [i]), e.StripByteCounts || (e.StripByteCounts = [i * s * n]), e.ModelPixelScale || (e.ModelPixelScale = [360 / n, 180 / s, 0]), e.SampleFormat || (e.SampleFormat = C(i, () => 1)), !e.hasOwnProperty("GeographicTypeGeoKey") && !e.hasOwnProperty("ProjectedCSTypeGeoKey") && (e.GeographicTypeGeoKey = 4326, e.ModelTiepoint = [0, 0, 0, -180, 90, 0], e.GeogCitationGeoKey = "WGS 84", e.GTModelTypeGeoKey = 2);
+  const o = Object.keys(e).filter((f) => yt(f, "GeoKey")).sort((f, h) => M[f] - M[h]);
+  if (!e.GeoAsciiParams) {
+    let f = "";
+    o.forEach((h) => {
+      const u = Number(M[h]);
+      ue[u] === "ASCII" && (f += `${e[h].toString()}\0`);
+    }), f.length > 0 && (e.GeoAsciiParams = f);
+  }
+  if (!e.GeoKeyDirectory) {
+    const h = [1, 1, 0, o.length];
+    o.forEach((u) => {
+      const d = Number(M[u]);
+      h.push(d);
+      let g, y, p;
+      ue[d] === "SHORT" ? (g = 1, y = 0, p = e[u]) : u === "GeogCitationGeoKey" ? (g = e.GeoAsciiParams.length, y = Number(M.GeoAsciiParams), p = 0) : console.log(`[geotiff.js] couldn't get TIFFTagLocation for ${u}`), h.push(y), h.push(g), h.push(p);
+    }), e.GeoKeyDirectory = h;
+  }
+  for (const f of o)
+    e.hasOwnProperty(f) && delete e[f];
+  [
+    "Compression",
+    "ExtraSamples",
+    "GeographicTypeGeoKey",
+    "GTModelTypeGeoKey",
+    "GTRasterTypeGeoKey",
+    "ImageLength",
+    // synonym of ImageHeight
+    "ImageWidth",
+    "Orientation",
+    "PhotometricInterpretation",
+    "ProjectedCSTypeGeoKey",
+    "PlanarConfiguration",
+    "ResolutionUnit",
+    "SamplesPerPixel",
+    "XPosition",
+    "YPosition",
+    "RowsPerStrip"
+  ].forEach((f) => {
+    e[f] && (e[f] = cs(e[f]));
+  });
+  const c = as(e);
+  return os(a, n, s, c);
+}
+class hs {
+  log() {
+  }
+  debug() {
+  }
+  info() {
+  }
+  warn() {
+  }
+  error() {
+  }
+  time() {
+  }
+  timeEnd() {
+  }
+}
+function us(r = new hs()) {
+}
+function gs(r, e) {
+  let t = r.length - e, s = 0;
+  do {
+    for (let i = e; i > 0; i--)
+      r[s + e] += r[s], s++;
+    t -= e;
+  } while (t > 0);
+}
+function ds(r, e, t) {
+  let s = 0, i = r.length;
+  const n = i / t;
+  for (; i > e; ) {
+    for (let o = e; o > 0; --o)
+      r[s + e] += r[s], ++s;
+    i -= e;
+  }
+  const a = r.slice();
+  for (let o = 0; o < n; ++o)
+    for (let c = 0; c < t; ++c)
+      r[t * o + c] = a[(t - c - 1) * n + o];
+}
+function ys(r, e, t, s, i, n) {
+  if (e === 1)
+    return r;
+  for (let c = 0; c < i.length; ++c) {
+    if (i[c] % 8 !== 0)
+      throw new Error("When decoding with predictor, only multiple of 8 bits are supported.");
+    if (i[c] !== i[0])
+      throw new Error("When decoding with predictor, all samples must have the same size.");
+  }
+  const a = i[0] / 8, o = n === 2 ? 1 : i.length;
+  for (let c = 0; c < s && !(c * o * t * a >= r.byteLength); ++c) {
+    let l;
+    if (e === 2) {
+      switch (i[0]) {
+        case 8:
+          l = new Uint8Array(
+            r,
+            c * o * t * a,
+            o * t * a
+          );
+          break;
+        case 16:
+          l = new Uint16Array(
+            r,
+            c * o * t * a,
+            o * t * a / 2
+          );
+          break;
+        case 32:
+          l = new Uint32Array(
+            r,
+            c * o * t * a,
+            o * t * a / 4
+          );
+          break;
+        default:
+          throw new Error(`Predictor 2 not allowed with ${i[0]} bits per sample.`);
+      }
+      gs(l, o);
+    } else e === 3 && (l = new Uint8Array(
+      r,
+      c * o * t * a,
+      o * t * a
+    ), ds(l, o, a));
+  }
+  return r;
+}
+class ps {
+  async decode(e, t) {
+    const s = await this.decodeBlock(t), i = e.Predictor || 1;
+    if (i !== 1) {
+      const n = !e.StripOffsets, a = n ? e.TileWidth : e.ImageWidth, o = n ? e.TileLength : e.RowsPerStrip || e.ImageLength;
+      return ys(
+        s,
+        i,
+        a,
+        o,
+        e.BitsPerSample,
+        e.PlanarConfiguration
+      );
+    }
+    return s;
+  }
+}
+function Ae(r) {
+  switch (r) {
+    case m.BYTE:
+    case m.ASCII:
+    case m.SBYTE:
+    case m.UNDEFINED:
+      return 1;
+    case m.SHORT:
+    case m.SSHORT:
+      return 2;
+    case m.LONG:
+    case m.SLONG:
+    case m.FLOAT:
+    case m.IFD:
+      return 4;
+    case m.RATIONAL:
+    case m.SRATIONAL:
+    case m.DOUBLE:
+    case m.LONG8:
+    case m.SLONG8:
+    case m.IFD8:
+      return 8;
+    default:
+      throw new RangeError(`Invalid field type: ${r}`);
+  }
+}
+function ws(r) {
+  const e = r.GeoKeyDirectory;
+  if (!e)
+    return null;
+  const t = {};
+  for (let s = 4; s <= e[3] * 4; s += 4) {
+    const i = N[e[s]], n = e[s + 1] ? U[e[s + 1]] : null, a = e[s + 2], o = e[s + 3];
+    let c = null;
+    if (!n)
+      c = o;
+    else {
+      if (c = r[n], typeof c > "u" || c === null)
+        throw new Error(`Could not get value of geoKey '${i}'.`);
+      typeof c == "string" ? c = c.substring(o, o + a - 1) : c.subarray && (c = c.subarray(o, o + a), a === 1 && (c = c[0]));
+    }
+    t[i] = c;
+  }
+  return t;
+}
+function v(r, e, t, s) {
+  let i = null, n = null;
+  const a = Ae(e);
+  switch (e) {
+    case m.BYTE:
+    case m.ASCII:
+    case m.UNDEFINED:
+      i = new Uint8Array(t), n = r.readUint8;
+      break;
+    case m.SBYTE:
+      i = new Int8Array(t), n = r.readInt8;
+      break;
+    case m.SHORT:
+      i = new Uint16Array(t), n = r.readUint16;
+      break;
+    case m.SSHORT:
+      i = new Int16Array(t), n = r.readInt16;
+      break;
+    case m.LONG:
+    case m.IFD:
+      i = new Uint32Array(t), n = r.readUint32;
+      break;
+    case m.SLONG:
+      i = new Int32Array(t), n = r.readInt32;
+      break;
+    case m.LONG8:
+    case m.IFD8:
+      i = new Array(t), n = r.readUint64;
+      break;
+    case m.SLONG8:
+      i = new Array(t), n = r.readInt64;
+      break;
+    case m.RATIONAL:
+      i = new Uint32Array(t * 2), n = r.readUint32;
+      break;
+    case m.SRATIONAL:
+      i = new Int32Array(t * 2), n = r.readInt32;
+      break;
+    case m.FLOAT:
+      i = new Float32Array(t), n = r.readFloat32;
+      break;
+    case m.DOUBLE:
+      i = new Float64Array(t), n = r.readFloat64;
+      break;
+    default:
+      throw new RangeError(`Invalid field type: ${e}`);
+  }
+  if (e === m.RATIONAL || e === m.SRATIONAL)
+    for (let o = 0; o < t; o += 2)
+      i[o] = n.call(
+        r,
+        s + o * a
+      ), i[o + 1] = n.call(
+        r,
+        s + (o * a + 4)
+      );
+  else
+    for (let o = 0; o < t; ++o)
+      i[o] = n.call(
+        r,
+        s + o * a
+      );
+  return e === m.ASCII ? new TextDecoder("utf-8").decode(i) : i;
+}
+class ms {
+  constructor(e, t, s) {
+    this.fileDirectory = e, this.geoKeyDirectory = t, this.nextIFDByteOffset = s;
+  }
+}
+class fe extends Error {
+  constructor(e) {
+    super(`No image at index ${e}`), this.index = e;
+  }
+}
+class pt {
+  /**
+   * (experimental) Reads raster data from the best fitting image. This function uses
+   * the image with the lowest resolution that is still a higher resolution than the
+   * requested resolution.
+   * When specified, the `bbox` option is translated to the `window` option and the
+   * `resX` and `resY` to `width` and `height` respectively.
+   * Then, the [readRasters]{@link GeoTIFFImage#readRasters} method of the selected
+   * image is called and the result returned.
+   * @see GeoTIFFImage.readRasters
+   * @param {import('./geotiffimage').ReadRasterOptions} [options={}] optional parameters
+   * @returns {Promise<ReadRasterResult>} the decoded array(s), with `height` and `width`, as a promise
+   */
+  async readRasters(e = {}) {
+    const { window: t, width: s, height: i } = e;
+    let { resX: n, resY: a, bbox: o } = e;
+    const c = await this.getImage();
+    let l = c;
+    const f = await this.getImageCount(), h = c.getBoundingBox();
+    if (t && o)
+      throw new Error('Both "bbox" and "window" passed.');
+    if (s || i) {
+      if (t) {
+        const [g, y] = c.getOrigin(), [p, x] = c.getResolution();
+        o = [
+          g + t[0] * p,
+          y + t[1] * x,
+          g + t[2] * p,
+          y + t[3] * x
+        ];
+      }
+      const d = o || h;
+      if (s) {
+        if (n)
+          throw new Error("Both width and resX passed");
+        n = (d[2] - d[0]) / s;
+      }
+      if (i) {
+        if (a)
+          throw new Error("Both width and resY passed");
+        a = (d[3] - d[1]) / i;
+      }
+    }
+    if (n || a) {
+      const d = [];
+      for (let g = 0; g < f; ++g) {
+        const y = await this.getImage(g), { SubfileType: p, NewSubfileType: x } = y.fileDirectory;
+        (g === 0 || p === 2 || x & 1) && d.push(y);
+      }
+      d.sort((g, y) => g.getWidth() - y.getWidth());
+      for (let g = 0; g < d.length; ++g) {
+        const y = d[g], p = (h[2] - h[0]) / y.getWidth(), x = (h[3] - h[1]) / y.getHeight();
+        if (l = y, n && n > p || a && a > x)
+          break;
+      }
+    }
+    let u = t;
+    if (o) {
+      const [d, g] = c.getOrigin(), [y, p] = l.getResolution(c);
+      u = [
+        Math.round((o[0] - d) / y),
+        Math.round((o[1] - g) / p),
+        Math.round((o[2] - d) / y),
+        Math.round((o[3] - g) / p)
+      ], u = [
+        Math.min(u[0], u[2]),
+        Math.min(u[1], u[3]),
+        Math.max(u[0], u[2]),
+        Math.max(u[1], u[3])
+      ];
+    }
+    return l.readRasters({ ...e, window: u });
+  }
+}
+class k extends pt {
+  /**
+   * @constructor
+   * @param {*} source The datasource to read from.
+   * @param {boolean} littleEndian Whether the image uses little endian.
+   * @param {boolean} bigTiff Whether the image uses bigTIFF conventions.
+   * @param {number} firstIFDOffset The numeric byte-offset from the start of the image
+   *                                to the first IFD.
+   * @param {GeoTIFFOptions} [options] further options.
+   */
+  constructor(e, t, s, i, n = {}) {
+    super(), this.source = e, this.littleEndian = t, this.bigTiff = s, this.firstIFDOffset = i, this.cache = n.cache || !1, this.ifdRequests = [], this.ghostValues = null;
+  }
+  async getSlice(e, t) {
+    const s = this.bigTiff ? 4048 : 1024;
+    return new br(
+      (await this.source.fetch([{
+        offset: e,
+        length: typeof t < "u" ? t : s
+      }]))[0],
+      e,
+      this.littleEndian,
+      this.bigTiff
+    );
+  }
+  /**
+   * Instructs to parse an image file directory at the given file offset.
+   * As there is no way to ensure that a location is indeed the start of an IFD,
+   * this function must be called with caution (e.g only using the IFD offsets from
+   * the headers or other IFDs).
+   * @param {number} offset the offset to parse the IFD at
+   * @returns {Promise<ImageFileDirectory>} the parsed IFD
+   */
+  async parseFileDirectoryAt(e) {
+    const t = this.bigTiff ? 20 : 12, s = this.bigTiff ? 8 : 2;
+    let i = await this.getSlice(e);
+    const n = this.bigTiff ? i.readUint64(e) : i.readUint16(e), a = n * t + (this.bigTiff ? 16 : 6);
+    i.covers(e, a) || (i = await this.getSlice(e, a));
+    const o = {};
+    let c = e + (this.bigTiff ? 8 : 2);
+    for (let h = 0; h < n; c += t, ++h) {
+      const u = i.readUint16(c), d = i.readUint16(c + 2), g = this.bigTiff ? i.readUint64(c + 4) : i.readUint32(c + 4);
+      let y, p;
+      const x = Ae(d), w = c + (this.bigTiff ? 12 : 8);
+      if (x * g <= (this.bigTiff ? 8 : 4))
+        y = v(i, d, g, w);
+      else {
+        const S = i.readOffset(w), I = Ae(d) * g;
+        if (i.covers(S, I))
+          y = v(i, d, g, S);
+        else {
+          const b = await this.getSlice(S, I);
+          y = v(b, d, g, S);
+        }
+      }
+      g === 1 && st.indexOf(u) === -1 && !(d === m.RATIONAL || d === m.SRATIONAL) ? p = y[0] : p = y, o[U[u]] = p;
+    }
+    const l = ws(o), f = i.readOffset(
+      e + s + t * n
+    );
+    return new ms(
+      o,
+      l,
+      f
+    );
+  }
+  async requestIFD(e) {
+    if (this.ifdRequests[e])
+      return this.ifdRequests[e];
+    if (e === 0)
+      return this.ifdRequests[e] = this.parseFileDirectoryAt(this.firstIFDOffset), this.ifdRequests[e];
+    if (!this.ifdRequests[e - 1])
+      try {
+        this.ifdRequests[e - 1] = this.requestIFD(e - 1);
+      } catch (t) {
+        throw t instanceof fe ? new fe(e) : t;
+      }
+    return this.ifdRequests[e] = (async () => {
+      const t = await this.ifdRequests[e - 1];
+      if (t.nextIFDByteOffset === 0)
+        throw new fe(e);
+      return this.parseFileDirectoryAt(t.nextIFDByteOffset);
+    })(), this.ifdRequests[e];
+  }
+  /**
+   * Get the n-th internal subfile of an image. By default, the first is returned.
+   *
+   * @param {number} [index=0] the index of the image to return.
+   * @returns {Promise<GeoTIFFImage>} the image at the given index
+   */
+  async getImage(e = 0) {
+    const t = await this.requestIFD(e);
+    return new ke(
+      t.fileDirectory,
+      t.geoKeyDirectory,
+      this.dataView,
+      this.littleEndian,
+      this.cache,
+      this.source
+    );
+  }
+  /**
+   * Returns the count of the internal subfiles.
+   *
+   * @returns {Promise<number>} the number of internal subfile images
+   */
+  async getImageCount() {
+    let e = 0, t = !0;
+    for (; t; )
+      try {
+        await this.requestIFD(e), ++e;
+      } catch (s) {
+        if (s instanceof fe)
+          t = !1;
+        else
+          throw s;
+      }
+    return e;
+  }
+  /**
+   * Get the values of the COG ghost area as a parsed map.
+   * See https://gdal.org/drivers/raster/cog.html#header-ghost-area for reference
+   * @returns {Promise<Object>} the parsed ghost area or null, if no such area was found
+   */
+  async getGhostValues() {
+    const e = this.bigTiff ? 16 : 8;
+    if (this.ghostValues)
+      return this.ghostValues;
+    const t = "GDAL_STRUCTURAL_METADATA_SIZE=", s = t.length + 100;
+    let i = await this.getSlice(e, s);
+    if (t === v(i, m.ASCII, t.length, e)) {
+      const a = v(i, m.ASCII, s, e).split(`
+`)[0], o = Number(a.split("=")[1].split(" ")[0]) + a.length;
+      o > s && (i = await this.getSlice(e, o));
+      const c = v(i, m.ASCII, o, e);
+      this.ghostValues = {}, c.split(`
+`).filter((l) => l.length > 0).map((l) => l.split("=")).forEach(([l, f]) => {
+        this.ghostValues[l] = f;
+      });
+    }
+    return this.ghostValues;
+  }
+  /**
+   * Parse a (Geo)TIFF file from the given source.
+   *
+   * @param {*} source The source of data to parse from.
+   * @param {GeoTIFFOptions} [options] Additional options.
+   * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
+   *                               to be aborted
+   */
+  static async fromSource(e, t, s) {
+    const i = (await e.fetch([{ offset: 0, length: 1024 }], s))[0], n = new Ir(i), a = n.getUint16(0, 0);
+    let o;
+    if (a === 18761)
+      o = !0;
+    else if (a === 19789)
+      o = !1;
+    else
+      throw new TypeError("Invalid byte order value.");
+    const c = n.getUint16(2, o);
+    let l;
+    if (c === 42)
+      l = !1;
+    else if (c === 43) {
+      if (l = !0, n.getUint16(4, o) !== 8)
+        throw new Error("Unsupported offset byte-size.");
+    } else
+      throw new TypeError("Invalid magic number.");
+    const f = l ? n.getUint64(8, o) : n.getUint32(4, o);
+    return new k(e, o, l, f, t);
+  }
+  /**
+   * Closes the underlying file buffer
+   * N.B. After the GeoTIFF has been completely processed it needs
+   * to be closed but only if it has been constructed from a file.
+   */
+  close() {
+    return typeof this.source.close == "function" ? this.source.close() : !1;
+  }
+}
+class wt extends pt {
+  /**
+   * Construct a new MultiGeoTIFF from a main and several overview files.
+   * @param {GeoTIFF} mainFile The main GeoTIFF file.
+   * @param {GeoTIFF[]} overviewFiles An array of overview files.
+   */
+  constructor(e, t) {
+    super(), this.mainFile = e, this.overviewFiles = t, this.imageFiles = [e].concat(t), this.fileDirectoriesPerFile = null, this.fileDirectoriesPerFileParsing = null, this.imageCount = null;
+  }
+  async parseFileDirectoriesPerFile() {
+    const e = [this.mainFile.parseFileDirectoryAt(this.mainFile.firstIFDOffset)].concat(this.overviewFiles.map((t) => t.parseFileDirectoryAt(t.firstIFDOffset)));
+    return this.fileDirectoriesPerFile = await Promise.all(e), this.fileDirectoriesPerFile;
+  }
+  /**
+   * Get the n-th internal subfile of an image. By default, the first is returned.
+   *
+   * @param {number} [index=0] the index of the image to return.
+   * @returns {Promise<GeoTIFFImage>} the image at the given index
+   */
+  async getImage(e = 0) {
+    await this.getImageCount(), await this.parseFileDirectoriesPerFile();
+    let t = 0, s = 0;
+    for (let i = 0; i < this.imageFiles.length; i++) {
+      const n = this.imageFiles[i];
+      for (let a = 0; a < this.imageCounts[i]; a++) {
+        if (e === t) {
+          const o = await n.requestIFD(s);
+          return new ke(
+            o.fileDirectory,
+            o.geoKeyDirectory,
+            n.dataView,
+            n.littleEndian,
+            n.cache,
+            n.source
+          );
+        }
+        t++, s++;
+      }
+      s = 0;
+    }
+    throw new RangeError("Invalid image index");
+  }
+  /**
+   * Returns the count of the internal subfiles.
+   *
+   * @returns {Promise<number>} the number of internal subfile images
+   */
+  async getImageCount() {
+    if (this.imageCount !== null)
+      return this.imageCount;
+    const e = [this.mainFile.getImageCount()].concat(this.overviewFiles.map((t) => t.getImageCount()));
+    return this.imageCounts = await Promise.all(e), this.imageCount = this.imageCounts.reduce((t, s) => t + s, 0), this.imageCount;
+  }
+}
+async function xs(r, e = {}, t) {
+  return k.fromSource(Te(r, e), t);
+}
+async function Ss(r, e = {}, t) {
+  return k.fromSource(jr(r, e), t);
+}
+async function Is(r, e) {
+  return k.fromSource(Yr(r), e);
+}
+async function bs(r, e) {
+  return k.fromSource(es(r), e);
+}
+async function Ts(r, e) {
+  return k.fromSource(Xr(r), e);
+}
+async function As(r, e = [], t = {}, s) {
+  const i = await k.fromSource(Te(r, t), s), n = await Promise.all(
+    e.map((a) => k.fromSource(Te(a, t)))
+  );
+  return new wt(i, n);
+}
+function Ds(r, e) {
+  return fs(r, e);
+}
+const Os = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  BaseClient: ye,
+  BaseDecoder: ps,
+  BaseResponse: de,
+  GeoTIFF: k,
+  GeoTIFFImage: ke,
+  MultiGeoTIFF: wt,
+  Pool: Ar,
+  addDecoder: G,
+  default: k,
+  fromArrayBuffer: Is,
+  fromBlob: Ts,
+  fromCustomClient: Ss,
+  fromFile: bs,
+  fromUrl: xs,
+  fromUrls: As,
+  getDecoder: Fe,
+  globals: ar,
+  rgb: hr,
+  setLogger: us,
+  writeArrayBuffer: Ds
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  ps as B,
+  nr as L,
+  Ar as P,
+  or as a,
+  Is as b,
+  Ts as c,
+  ye as d,
+  Ss as e,
+  xs as f,
+  Os as g
+};