@nika-js/onlymap 0.5.9 → 0.5.11

package/dist/raster-B5dIvmBr.js

@@ -0,0 +1,3614 @@
+import { c as re, t as Ae, i as nt, a as Re, s as rt, C as ot, b as it, F as at, A as st, d as lt, R as he, e as ct, p as ut, m as dt, f as ht, g as pt, h as gt } from "./raster-pipeline-Dzo5h6YY.js";
+import pe from "./index-CW1n5LdO.js";
+function mt(e, t) {
+  const n = e.length / 3, r = new Uint8ClampedArray(n * 4), o = 0, i = n, a = n * 2;
+  for (let s = 0; s < n; s++)
+    r[4 * s + 0] = e[o + s] >> 8, r[4 * s + 1] = e[i + s] >> 8, r[4 * s + 2] = e[a + s] >> 8, r[4 * s + 3] = 255;
+  return new ImageData(r, n, 1);
+}
+var q;
+(function(e) {
+  e[e.Big = 19789] = "Big", e[e.Little = 18761] = "Little";
+})(q || (q = {}));
+var J;
+(function(e) {
+  e[e.ReducedImage = 1] = "ReducedImage", e[e.Page = 2] = "Page", e[e.Mask = 4] = "Mask";
+})(J || (J = {}));
+var ge;
+(function(e) {
+  e[e.TopLeft = 1] = "TopLeft", e[e.TopRight = 2] = "TopRight", e[e.BottomRight = 3] = "BottomRight", e[e.BottomLeft = 4] = "BottomLeft", e[e.LeftTop = 5] = "LeftTop", e[e.RightTOP = 6] = "RightTOP", e[e.RightBottom = 7] = "RightBottom", e[e.LeftBottom = 8] = "LeftBottom";
+})(ge || (ge = {}));
+var T;
+(function(e) {
+  e[e.PixelIsArea = 1] = "PixelIsArea", e[e.PixelIsPoint = 2] = "PixelIsPoint";
+})(T || (T = {}));
+var M;
+(function(e) {
+  e[e.Unknown = 0] = "Unknown", e[e.Projected = 1] = "Projected", e[e.Geographic = 2] = "Geographic", e[e.Geocentric = 3] = "Geocentric", e[e.UserDefined = 32767] = "UserDefined";
+})(M || (M = {}));
+var me;
+(function(e) {
+  e[e.Image = 1] = "Image", e[e.ReducedImage = 2] = "ReducedImage", e[e.Page = 3] = "Page";
+})(me || (me = {}));
+var m;
+(function(e) {
+  e[e.None = 1] = "None", e[e.Ccittrle = 2] = "Ccittrle", e[e.CcittT4 = 3] = "CcittT4", e[e.CcittT6 = 4] = "CcittT6", e[e.Lzw = 5] = "Lzw", e[e.Jpeg6 = 6] = "Jpeg6", e[e.Jpeg = 7] = "Jpeg", e[e.DeflateOther = 8] = "DeflateOther", e[e.T85 = 9] = "T85", e[e.T43 = 10] = "T43", e[e.Next = 32766] = "Next", e[e.Ccittrlew = 32771] = "Ccittrlew", e[e.PackBits = 32773] = "PackBits", e[e.ThunderScan = 32809] = "ThunderScan", e[e.It8ctpad = 32895] = "It8ctpad", e[e.It8lw = 32896] = "It8lw", e[e.It8mp = 32897] = "It8mp", e[e.It8bl = 32898] = "It8bl", e[e.PixarFilm = 32908] = "PixarFilm", e[e.PixarLog = 32909] = "PixarLog", e[e.Deflate = 32946] = "Deflate", e[e.Dcs = 32947] = "Dcs", e[e.Jbig = 34661] = "Jbig", e[e.SgiLog = 34676] = "SgiLog", e[e.SgiLog24 = 34677] = "SgiLog24", e[e.Jp2000 = 34712] = "Jp2000", e[e.Lerc = 34887] = "Lerc", e[e.Lzma = 34925] = "Lzma", e[e.Zstd = 5e4] = "Zstd", e[e.Webp = 50001] = "Webp", e[e.JpegXl = 50002] = "JpegXl", e[e.JpegXlDng17 = 52546] = "JpegXlDng17";
+})(m || (m = {}));
+var U;
+(function(e) {
+  e[e.Contig = 1] = "Contig", e[e.Separate = 2] = "Separate";
+})(U || (U = {}));
+var _;
+(function(e) {
+  e[e.None = 1] = "None", e[e.Horizontal = 2] = "Horizontal", e[e.FloatingPoint = 3] = "FloatingPoint";
+})(_ || (_ = {}));
+var F;
+(function(e) {
+  e[e.Uint = 1] = "Uint", e[e.Int = 2] = "Int", e[e.Float = 3] = "Float", e[e.Void = 4] = "Void", e[e.ComplexInt = 5] = "ComplexInt", e[e.ComplexFloat = 6] = "ComplexFloat";
+})(F || (F = {}));
+var E;
+(function(e) {
+  e[e.MinIsWhite = 0] = "MinIsWhite", e[e.MinIsBlack = 1] = "MinIsBlack", e[e.Rgb = 2] = "Rgb", e[e.Palette = 3] = "Palette", e[e.Mask = 4] = "Mask", e[e.Separated = 5] = "Separated", e[e.Ycbcr = 6] = "Ycbcr", e[e.Cielab = 8] = "Cielab", e[e.Icclab = 9] = "Icclab", e[e.Itulab = 10] = "Itulab", e[e.Cfa = 32803] = "Cfa", e[e.Logl = 32844] = "Logl", e[e.Logluv = 32845] = "Logluv";
+})(E || (E = {}));
+var u;
+(function(e) {
+  e[e.SubFileType = 254] = "SubFileType", e[e.OldSubFileType = 255] = "OldSubFileType", e[e.ImageWidth = 256] = "ImageWidth", e[e.ImageHeight = 257] = "ImageHeight", e[e.BitsPerSample = 258] = "BitsPerSample", e[e.SampleFormat = 339] = "SampleFormat", e[e.Compression = 259] = "Compression", e[e.Photometric = 262] = "Photometric", e[e.TileWidth = 322] = "TileWidth", e[e.TileHeight = 323] = "TileHeight", e[e.TileOffsets = 324] = "TileOffsets", e[e.TileByteCounts = 325] = "TileByteCounts", e[e.JpegTables = 347] = "JpegTables", e[e.StripOffsets = 273] = "StripOffsets", e[e.StripByteCounts = 279] = "StripByteCounts", e[e.GdalMetadata = 42112] = "GdalMetadata", e[e.GdalNoData = 42113] = "GdalNoData", e[e.ModelPixelScale = 33550] = "ModelPixelScale", e[e.ModelTiePoint = 33922] = "ModelTiePoint", e[e.ModelTransformation = 34264] = "ModelTransformation", e[e.GeoKeyDirectory = 34735] = "GeoKeyDirectory", e[e.GeoDoubleParams = 34736] = "GeoDoubleParams", e[e.GeoAsciiParams = 34737] = "GeoAsciiParams", e[e.LercParameters = 50674] = "LercParameters", e[e.PlanarConfiguration = 284] = "PlanarConfiguration", e[e.CellLength = 265] = "CellLength", e[e.CellWidth = 264] = "CellWidth", e[e.ColorMap = 320] = "ColorMap", e[e.Copyright = 33432] = "Copyright", e[e.DateTime = 306] = "DateTime", e[e.ExtraSamples = 338] = "ExtraSamples", e[e.FillOrder = 266] = "FillOrder", e[e.FreeByteCounts = 289] = "FreeByteCounts", e[e.FreeOffsets = 288] = "FreeOffsets", e[e.GrayResponseCurve = 291] = "GrayResponseCurve", e[e.GrayResponseUnit = 290] = "GrayResponseUnit", e[e.HostComputer = 316] = "HostComputer", e[e.ImageDescription = 270] = "ImageDescription", e[e.Make = 271] = "Make", e[e.MaxSampleValue = 281] = "MaxSampleValue", e[e.MinSampleValue = 280] = "MinSampleValue", e[e.Model = 272] = "Model", e[e.Orientation = 274] = "Orientation", e[e.ResolutionUnit = 296] = "ResolutionUnit", e[e.RowsPerStrip = 278] = "RowsPerStrip", e[e.SamplesPerPixel = 277] = "SamplesPerPixel", e[e.Software = 305] = "Software", e[e.Threshholding = 263] = "Threshholding", e[e.XResolution = 282] = "XResolution", e[e.YResolution = 283] = "YResolution", e[e.BadFaxLines = 326] = "BadFaxLines", e[e.CleanFaxData = 327] = "CleanFaxData", e[e.ClipPath = 343] = "ClipPath", e[e.ConsecutiveBadFaxLines = 328] = "ConsecutiveBadFaxLines", e[e.Decode = 433] = "Decode", e[e.DefaultImageColor = 434] = "DefaultImageColor", e[e.DocumentName = 269] = "DocumentName", e[e.DotRange = 336] = "DotRange", e[e.HalftoneHints = 321] = "HalftoneHints", e[e.Indexed = 346] = "Indexed", e[e.PageName = 285] = "PageName", e[e.PageNumber = 297] = "PageNumber", e[e.Predictor = 317] = "Predictor", e[e.PrimaryChromaticities = 319] = "PrimaryChromaticities", e[e.ReferenceBlackWhite = 532] = "ReferenceBlackWhite", e[e.SMinSampleValue = 340] = "SMinSampleValue", e[e.SMaxSampleValue = 341] = "SMaxSampleValue", e[e.StripRowCounts = 559] = "StripRowCounts", e[e.SubIFDs = 330] = "SubIFDs", e[e.T4Options = 292] = "T4Options", e[e.T6Options = 293] = "T6Options", e[e.TransferFunction = 301] = "TransferFunction", e[e.WhitePoint = 318] = "WhitePoint", e[e.XClipPathUnits = 344] = "XClipPathUnits", e[e.XPosition = 286] = "XPosition", e[e.YCbCrCoefficients = 529] = "YCbCrCoefficients", e[e.YCbCrPositioning = 531] = "YCbCrPositioning", e[e.YCbCrSubSampling = 530] = "YCbCrSubSampling", e[e.YClipPathUnits = 345] = "YClipPathUnits", e[e.YPosition = 287] = "YPosition", e[e.ApertureValue = 37378] = "ApertureValue", e[e.ColorSpace = 40961] = "ColorSpace", e[e.DateTimeDigitized = 36868] = "DateTimeDigitized", e[e.DateTimeOriginal = 36867] = "DateTimeOriginal", e[e.ExifIFD = 34665] = "ExifIFD", e[e.ExifVersion = 36864] = "ExifVersion", e[e.ExposureTime = 33434] = "ExposureTime", e[e.FileSource = 41728] = "FileSource", e[e.Flash = 37385] = "Flash", e[e.FlashpixVersion = 40960] = "FlashpixVersion", e[e.FNumber = 33437] = "FNumber", e[e.ImageUniqueID = 42016] = "ImageUniqueID", e[e.LightSource = 37384] = "LightSource", e[e.MakerNote = 37500] = "MakerNote", e[e.ShutterSpeedValue = 37377] = "ShutterSpeedValue", e[e.UserComment = 37510] = "UserComment", e[e.IPTC = 33723] = "IPTC", e[e.ICCProfile = 34675] = "ICCProfile", e[e.XMP = 700] = "XMP";
+})(u || (u = {}));
+var p;
+(function(e) {
+  e[e.GTModelTypeGeoKey = 1024] = "GTModelTypeGeoKey", e[e.GTRasterTypeGeoKey = 1025] = "GTRasterTypeGeoKey", e[e.GTCitationGeoKey = 1026] = "GTCitationGeoKey", e[e.GeodeticCRSGeoKey = 2048] = "GeodeticCRSGeoKey", e[e.GeodeticCitationGeoKey = 2049] = "GeodeticCitationGeoKey", e[e.GeodeticDatumGeoKey = 2050] = "GeodeticDatumGeoKey", e[e.PrimeMeridianGeoKey = 2051] = "PrimeMeridianGeoKey", e[e.GeogLinearUnitsGeoKey = 2052] = "GeogLinearUnitsGeoKey", e[e.GeogLinearUnitSizeGeoKey = 2053] = "GeogLinearUnitSizeGeoKey", e[e.GeogAngularUnitsGeoKey = 2054] = "GeogAngularUnitsGeoKey", e[e.GeogAngularUnitSizeGeoKey = 2055] = "GeogAngularUnitSizeGeoKey", e[e.EllipsoidGeoKey = 2056] = "EllipsoidGeoKey", e[e.EllipsoidSemiMajorAxisGeoKey = 2057] = "EllipsoidSemiMajorAxisGeoKey", e[e.EllipsoidSemiMinorAxisGeoKey = 2058] = "EllipsoidSemiMinorAxisGeoKey", e[e.EllipsoidInvFlatteningGeoKey = 2059] = "EllipsoidInvFlatteningGeoKey", e[e.PrimeMeridianLongitudeGeoKey = 2061] = "PrimeMeridianLongitudeGeoKey", e[e.GeogTOWGS84GeoKey = 2062] = "GeogTOWGS84GeoKey", e[e.GeogAzimuthUnitsGeoKey = 2060] = "GeogAzimuthUnitsGeoKey", e[e.ProjectedCRSGeoKey = 3072] = "ProjectedCRSGeoKey", e[e.ProjectedCitationGeoKey = 3073] = "ProjectedCitationGeoKey", e[e.ProjectionGeoKey = 3074] = "ProjectionGeoKey", e[e.ProjMethodGeoKey = 3075] = "ProjMethodGeoKey", e[e.ProjLinearUnitsGeoKey = 3076] = "ProjLinearUnitsGeoKey", e[e.ProjLinearUnitSizeGeoKey = 3077] = "ProjLinearUnitSizeGeoKey", e[e.ProjStdParallel1GeoKey = 3078] = "ProjStdParallel1GeoKey", e[e.ProjStdParallel2GeoKey = 3079] = "ProjStdParallel2GeoKey", e[e.ProjNatOriginLongGeoKey = 3080] = "ProjNatOriginLongGeoKey", e[e.ProjNatOriginLatGeoKey = 3081] = "ProjNatOriginLatGeoKey", e[e.ProjFalseEastingGeoKey = 3082] = "ProjFalseEastingGeoKey", e[e.ProjFalseNorthingGeoKey = 3083] = "ProjFalseNorthingGeoKey", e[e.ProjFalseOriginLongGeoKey = 3084] = "ProjFalseOriginLongGeoKey", e[e.ProjFalseOriginLatGeoKey = 3085] = "ProjFalseOriginLatGeoKey", e[e.ProjFalseOriginEastingGeoKey = 3086] = "ProjFalseOriginEastingGeoKey", e[e.ProjFalseOriginNorthingGeoKey = 3087] = "ProjFalseOriginNorthingGeoKey", e[e.ProjCenterLongGeoKey = 3088] = "ProjCenterLongGeoKey", e[e.ProjCenterLatGeoKey = 3089] = "ProjCenterLatGeoKey", e[e.ProjCenterEastingGeoKey = 3090] = "ProjCenterEastingGeoKey", e[e.ProjCenterNorthingGeoKey = 3091] = "ProjCenterNorthingGeoKey", e[e.ProjScaleAtNatOriginGeoKey = 3092] = "ProjScaleAtNatOriginGeoKey", e[e.ProjScaleAtCenterGeoKey = 3093] = "ProjScaleAtCenterGeoKey", e[e.ProjAzimuthAngleGeoKey = 3094] = "ProjAzimuthAngleGeoKey", e[e.ProjStraightVertPoleLongGeoKey = 3095] = "ProjStraightVertPoleLongGeoKey", e[e.ProjRectifiedGridAngleGeoKey = 3096] = "ProjRectifiedGridAngleGeoKey", e[e.VerticalGeoKey = 4096] = "VerticalGeoKey", e[e.VerticalCitationGeoKey = 4097] = "VerticalCitationGeoKey", e[e.VerticalDatumGeoKey = 4098] = "VerticalDatumGeoKey", e[e.VerticalUnitsGeoKey = 4099] = "VerticalUnitsGeoKey";
+})(p || (p = {}));
+var fe;
+(function(e) {
+  e[e.Radian = 9101] = "Radian", e[e.Degree = 9102] = "Degree", e[e.ArcMinute = 9103] = "ArcMinute", e[e.ArcDegree = 9104] = "ArcDegree", e[e.Grad = 9105] = "Grad", e[e.Gon = 9106] = "Gon", e[e.Dms = 9107] = "Dms";
+})(fe || (fe = {}));
+var ye;
+(function(e) {
+  e[e.Metre = 9001] = "Metre", e[e.Foot = 9002] = "Foot", e[e.FootUsSurvey = 9003] = "FootUsSurvey", e[e.FootModifiedAmerican = 9004] = "FootModifiedAmerican", e[e.FootClarke = 9005] = "FootClarke", e[e.FootIndian = 9006] = "FootIndian", e[e.Link = 9007] = "Link", e[e.LinkBenoit = 9008] = "LinkBenoit", e[e.LinkSears = 9009] = "LinkSears", e[e.ChainBenoit = 9010] = "ChainBenoit", e[e.ChainSears = 9011] = "ChainSears", e[e.YardSears = 9012] = "YardSears", e[e.YardIndian = 9013] = "YardIndian", e[e.Fathom = 9014] = "Fathom", e[e.MileInternationalNautical = 9015] = "MileInternationalNautical";
+})(ye || (ye = {}));
+const ft = {
+  [u.TileByteCounts]: !0,
+  [u.TileOffsets]: !0,
+  [u.StripOffsets]: !0,
+  [u.StripByteCounts]: !0,
+  [u.BitsPerSample]: !0,
+  [u.SampleFormat]: !0,
+  [u.GeoKeyDirectory]: !0,
+  [u.GeoDoubleParams]: !0
+};
+var w;
+(function(e) {
+  e.None = "application/octet-stream", e.Jbig = "image/jbig", e.Dcs = "image/x-kodak-dcs", e.PackBits = "application/packbits", e.Jpeg = "image/jpeg", e.Jp2000 = "image/jp2", e.JpegXl = "image/jpegxl", e.Webp = "image/webp", e.Zstd = "application/zstd", e.Lzw = "application/lzw", e.Deflate = "application/deflate", e.Lerc = "application/lerc", e.Lzma = "application/x-lzma";
+})(w || (w = {}));
+const ve = {
+  [m.None]: w.None,
+  [m.Lzw]: w.Lzw,
+  [m.Jpeg6]: w.Jpeg,
+  [m.Jpeg]: w.Jpeg,
+  [m.DeflateOther]: w.Deflate,
+  [m.Deflate]: w.Deflate,
+  [m.Lerc]: w.Lerc,
+  [m.Lzma]: w.Lzma,
+  [m.Jp2000]: w.Jp2000,
+  [m.Zstd]: w.Zstd,
+  [m.Webp]: w.Webp,
+  [m.JpegXl]: w.JpegXl,
+  [m.Ccittrle]: w.None,
+  [m.CcittT4]: w.None,
+  [m.CcittT6]: w.None,
+  [m.T85]: w.Jbig,
+  [m.T43]: w.Jbig,
+  [m.Next]: w.None,
+  [m.Ccittrlew]: w.None,
+  [m.PackBits]: w.PackBits,
+  [m.ThunderScan]: w.None,
+  [m.It8ctpad]: w.None,
+  [m.It8lw]: w.None,
+  [m.It8mp]: w.None,
+  [m.It8bl]: w.None,
+  [m.PixarFilm]: w.None,
+  [m.PixarLog]: w.None,
+  [m.Dcs]: w.Dcs,
+  [m.Jbig]: w.Jbig,
+  [m.SgiLog]: w.None,
+  [m.SgiLog24]: w.None,
+  [m.JpegXlDng17]: w.JpegXl
+};
+function yt(e) {
+  return e == null ? null : ve[e];
+}
+var y;
+(function(e) {
+  e[e.Uint8 = 1] = "Uint8", e[e.Ascii = 2] = "Ascii", e[e.Uint16 = 3] = "Uint16", e[e.Uint32 = 4] = "Uint32", e[e.Rational = 5] = "Rational", e[e.Int8 = 6] = "Int8", e[e.Undefined = 7] = "Undefined", e[e.Int16 = 8] = "Int16", e[e.Int32 = 9] = "Int32", e[e.SignedRational = 10] = "SignedRational", e[e.Float32 = 11] = "Float32", e[e.Float64 = 12] = "Float64", e[e.Ifd = 13] = "Ifd", e[e.Uint64 = 16] = "Uint64", e[e.Int64 = 17] = "Int64", e[e.Ifd8 = 18] = "Ifd8";
+})(y || (y = {}));
+var v;
+(function(e) {
+  e[e.BigTiff = 43] = "BigTiff", e[e.Tiff = 42] = "Tiff";
+})(v || (v = {}));
+function N(e) {
+  switch (e) {
+    case y.Uint8:
+    case y.Ascii:
+    case y.Int8:
+    case y.Undefined:
+      return 1;
+    case y.Uint16:
+    case y.Int16:
+      return 2;
+    case y.Uint32:
+    case y.Int32:
+    case y.Float32:
+    case y.Ifd:
+      return 4;
+    case y.Rational:
+    case y.SignedRational:
+    case y.Float64:
+    case y.Uint64:
+    case y.Int64:
+    case y.Ifd8:
+      return 8;
+    default:
+      throw new Error(`Invalid fieldType ${String(e)}`);
+  }
+}
+var we;
+(function(e) {
+  e[e.Double = 8] = "Double", e[e.Float32 = 4] = "Float32";
+})(we || (we = {}));
+var L;
+(function(e) {
+  e[e.UInt64 = 8] = "UInt64", e[e.UInt32 = 4] = "UInt32", e[e.UInt16 = 2] = "UInt16", e[e.UInt8 = 1] = "UInt8";
+})(L || (L = {}));
+const Se = 2 ** 32;
+function Ue(e, t, n) {
+  const r = e.getUint32(t, n), o = e.getUint32(t + 4, n), i = n ? r + Se * o : Se * r + o;
+  if (!Number.isSafeInteger(i))
+    throw new Error(i + " exceeds MAX_SAFE_INTEGER. Precision may is lost");
+  return i;
+}
+function K(e, t, n, r) {
+  switch (n) {
+    case L.UInt8:
+      return e.getUint8(t);
+    case L.UInt16:
+      return e.getUint16(t, r);
+    case L.UInt32:
+      return e.getUint32(t, r);
+    case L.UInt64:
+      return Ue(e, t, r);
+  }
+}
+function Y(e, t, n) {
+  return !(t < e.sourceOffset || e.sourceOffset + e.byteLength < t + n);
+}
+const Oe = new ArrayBuffer(4), wt = new Uint32Array(Oe), St = new Uint8Array(Oe);
+wt[0] = 1;
+const Pe = St[0] === 1;
+function Ce(e, t, n, r) {
+  switch (e) {
+    case y.Ascii:
+      return String.fromCharCode(t.getUint8(n));
+    case y.Undefined:
+    case y.Uint8:
+      return t.getUint8(n);
+    case y.Int8:
+      return t.getInt8(n);
+    case y.Uint16:
+      return t.getUint16(n, r);
+    case y.Int16:
+      return t.getInt16(n, r);
+    case y.Uint32:
+    case y.Ifd:
+      return t.getUint32(n, r);
+    case y.Int32:
+      return t.getInt32(n, r);
+    case y.Rational:
+      return [t.getUint32(n, r), t.getUint32(n + 4, r)];
+    case y.SignedRational:
+      return [t.getInt32(n, r), t.getInt32(n + 4, r)];
+    case y.Float64:
+      return t.getFloat64(n, r);
+    case y.Float32:
+      return t.getFloat32(n, r);
+    case y.Uint64:
+      return Ue(t, n, r);
+    default:
+      throw new Error(`Unknown read type "${e}" "${y[e]}"`);
+  }
+}
+function Me(e, t, n, r, o) {
+  switch (o) {
+    case y.Uint8:
+      return new Uint8Array(t.buffer.slice(t.byteOffset + n, t.byteOffset + n + r));
+    case y.Uint16:
+      return e.isLittleEndian !== Pe ? null : new Uint16Array(t.buffer.slice(t.byteOffset + n, t.byteOffset + n + r));
+    case y.Uint32:
+      return e.isLittleEndian !== Pe ? null : new Uint32Array(t.buffer.slice(t.byteOffset + n, t.byteOffset + n + r));
+  }
+  return null;
+}
+function x(e, t, n, r, o, i) {
+  const a = N(o), s = i * a;
+  if (i === 1) {
+    const c = Ce(o, n, r, e.isLittleEndian);
+    return t && ft[t] ? [c] : c;
+  }
+  switch (o) {
+    case y.Ascii:
+      return String.fromCharCode.apply(null, new Uint8Array(n.buffer, r, s - 1));
+  }
+  if (t === u.TileOffsets || t === u.TileByteCounts || t === u.StripOffsets || t === u.StripByteCounts) {
+    const c = Me(e, n, r, s, o);
+    if (c)
+      return c;
+  }
+  const l = [];
+  for (let c = 0; c < s; c += a)
+    l.push(Ce(o, n, r + c, e.isLittleEndian));
+  return l;
+}
+function Pt(e, t, n) {
+  const r = t.getUint16(n + 0, e.isLittleEndian), o = t.getUint16(n + 2, e.isLittleEndian), i = K(t, n + 4, e.ifdConfig.pointer, e.isLittleEndian), s = N(o) * i;
+  if (s <= e.ifdConfig.pointer) {
+    const c = x(e, r, t, n + 4 + e.ifdConfig.pointer, o, i);
+    return { type: "inline", id: r, name: u[r], count: i, value: c, dataType: o, tagOffset: n };
+  }
+  const l = K(t, n + 4 + e.ifdConfig.pointer, e.ifdConfig.pointer, e.isLittleEndian);
+  switch (r) {
+    case u.TileOffsets:
+    case u.TileByteCounts:
+    case u.StripByteCounts:
+    case u.StripOffsets:
+      const c = {
+        type: "offset",
+        id: r,
+        name: u[r],
+        count: i,
+        dataType: o,
+        dataOffset: l,
+        isLoaded: !1,
+        value: [],
+        tagOffset: n
+      };
+      if (Y(t, l, s)) {
+        const d = Me(e, t, l - t.sourceOffset, s, o);
+        d ? (c.value = d, c.isLoaded = !0) : bt(c, t);
+      }
+      return c;
+  }
+  if (Y(t, l, s)) {
+    const c = x(e, r, t, l - t.sourceOffset, o, i);
+    return { type: "inline", id: r, name: u[r], count: i, value: c, dataType: o, tagOffset: n };
+  }
+  return { type: "lazy", id: r, name: u[r], count: i, dataOffset: l, dataType: o, tagOffset: n };
+}
+async function Ct(e, t, n) {
+  if (e.value != null)
+    return e.value;
+  const o = N(e.dataType) * e.count, i = await t.source.fetch(e.dataOffset, o, n), a = new DataView(i);
+  return e.value = x(t, e.id, a, 0, e.dataType, e.count), e.value;
+}
+async function Lt(e, t, n) {
+  const r = N(t.dataType);
+  if (t.view == null) {
+    const o = await e.source.fetch(t.dataOffset, r * t.count, n);
+    t.view = new DataView(o), t.view.sourceOffset = t.dataOffset;
+  }
+  return t.value = x(e, t.id, t.view, 0, t.dataType, t.count), t.view = void 0, t.isLoaded = !0, t.value;
+}
+function bt(e, t) {
+  const n = N(e.dataType), r = t.byteOffset + e.dataOffset - t.sourceOffset;
+  e.view = new DataView(t.buffer.slice(r, r + n * e.count)), e.view.sourceOffset = e.dataOffset;
+}
+async function It(e, t, n, r) {
+  if (n > t.count || n < 0)
+    throw new Error("TagOffset: out of bounds :" + n);
+  if (t.value[n] != null)
+    return t.value[n];
+  const o = N(t.dataType);
+  if (t.view == null) {
+    const a = await e.source.fetch(t.dataOffset + n * o, o, r), s = new DataView(a), l = x(e, void 0, s, 0, t.dataType, 1);
+    if (typeof l != "number")
+      throw new Error("Value is not a number");
+    return t.value[n] = l, l;
+  }
+  const i = x(e, void 0, t.view, n * o, t.dataType, 1);
+  if (typeof i != "number")
+    throw new Error("Value is not a number");
+  return t.value[n] = i, i;
+}
+function Gt(e, t, n) {
+  if (n > t.count || n < 0)
+    throw new Error("TagOffset: out of bounds :" + n);
+  if (t.value[n] != null)
+    return t.value[n];
+  if (t.view == null)
+    return null;
+  const r = N(t.dataType), o = x(e, void 0, t.view, n * r, t.dataType, 1);
+  if (typeof o != "number")
+    throw new Error("Value is not a number");
+  return t.value[n] = o, o;
+}
+const Le = 32767, jt = /* @__PURE__ */ new Set([
+  u.Compression,
+  u.ImageHeight,
+  u.ImageWidth,
+  u.ModelPixelScale,
+  u.ModelTiePoint,
+  u.ModelTransformation,
+  u.TileHeight,
+  u.TileWidth
+]), Et = /* @__PURE__ */ new Set([u.GeoKeyDirectory, u.GeoAsciiParams, u.GeoDoubleParams]);
+class Ft {
+  /**
+   * Id of the tif image, generally the image index inside the tif
+   * where 0 is the root image, and every sub image is +1
+   *
+   * @example 0, 1, 2
+   */
+  id;
+  /** Reference to the TIFF that owns this image */
+  tiff;
+  /** Has loadGeoTiffTags been called */
+  isGeoTagsLoaded = !1;
+  /** Sub tags stored in TiffTag.GeoKeyDirectory */
+  tagsGeo = /* @__PURE__ */ new Map();
+  /** All IFD tags that have been read for the image */
+  tags;
+  constructor(t, n, r) {
+    this.tiff = t, this.id = n, this.tags = r;
+  }
+  /**
+   * Force loading of important tags if they have not already been loaded
+   *
+   * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
+   */
+  async init(t = !0, n) {
+    const r = [];
+    jt.forEach((o) => {
+      r.push(this.fetch(o, n));
+    }), t && Et.forEach((o) => {
+      r.push(this.fetch(o, n));
+    }), await Promise.all(r), t && await this.loadGeoTiffTags();
+  }
+  /**
+   * Get the value of a TiffTag if it has been loaded, null otherwise.
+   *
+   * If the value is not loaded use {@link TiffImage.fetch} to load the value
+   * Or use {@link TiffImage.has} to check if the tag exists
+   *
+   *
+   * @returns value if loaded, null otherwise
+   */
+  value(t) {
+    const n = this.tags.get(t);
+    return n == null || n.type === "offset" && n.isLoaded === !1 ? null : n.value;
+  }
+  /**
+   * Does the tag exist
+   *
+   * @example
+   * ```typescript
+   * img.has(TiffTag.ImageWidth) // true
+   * ```
+   *
+   * @param tag Tag to check
+   * @returns true if the tag exists, false otherwise
+   */
+  has(t) {
+    return this.tags.has(t);
+  }
+  /**
+   * Load a tag.
+   *
+   * If it is not currently loaded, fetch the required data for the tag.
+   *
+   * @example
+   * ```typescript
+   * await img.fetch(TiffTag.ImageWidth) // 512 (px)
+   * ```
+   *
+   * @param tag tag to fetch
+   */
+  async fetch(t, n) {
+    const r = this.tags.get(t);
+    if (r == null)
+      return null;
+    if (r.type === "inline")
+      return r.value;
+    if (r.type === "lazy")
+      return Ct(r, this.tiff, n);
+    if (r.isLoaded)
+      return r.value;
+    if (r.type === "offset")
+      return Lt(this.tiff, r, n);
+    throw new Error("Cannot fetch:" + t);
+  }
+  /**
+   * Get the associated TiffTagGeo
+   *
+   * @example
+   * ```typescript
+   * image.valueGeo(TiffTagGeo.GTRasterTypeGeoKey)
+   * ```
+   * @throws if {@link loadGeoTiffTags} has not been called
+   */
+  valueGeo(t) {
+    if (this.isGeoTagsLoaded === !1)
+      throw new Error("loadGeoTiffTags() has not been called");
+    return this.tagsGeo.get(t);
+  }
+  /**
+   * Load and parse the GDAL_NODATA Tifftag
+   *
+   * @throws if the tag is not loaded
+   * @returns null if the tag does not exist
+   */
+  get noData() {
+    const t = this.tags.get(u.GdalNoData);
+    if (t == null)
+      return null;
+    if (t.value != null)
+      return Number(t.value);
+    throw new Error("GdalNoData tag is not loaded");
+  }
+  /**
+   * Load and unpack the GeoKeyDirectory
+   *
+   * @see {TiffTag.GeoKeyDirectory}
+   */
+  async loadGeoTiffTags() {
+    if (this.isGeoTagsLoaded)
+      return;
+    const t = this.tags.get(u.GeoKeyDirectory);
+    if (t == null) {
+      this.isGeoTagsLoaded = !0;
+      return;
+    }
+    if (t.type === "lazy" && t.value == null && await Promise.all([
+      this.fetch(u.GeoKeyDirectory),
+      this.fetch(u.GeoAsciiParams),
+      this.fetch(u.GeoDoubleParams)
+    ]), this.isGeoTagsLoaded = !0, t.value == null)
+      return;
+    const n = t.value;
+    if (typeof n == "number")
+      throw new Error("Invalid geo tags found");
+    for (let r = 4; r <= n[3] * 4; r += 4) {
+      const o = n[r], i = n[r + 1], a = n[r + 3];
+      if (i === 0) {
+        this.tagsGeo.set(o, a);
+        continue;
+      }
+      const s = this.tags.get(i);
+      if (s == null || s.value == null)
+        continue;
+      const l = n[r + 2];
+      if (typeof s.value == "string")
+        this.tagsGeo.set(o, s.value.slice(a, a + l - 1).trim());
+      else if (Array.isArray(s.value))
+        l === 1 ? this.tagsGeo.set(o, s.value[a]) : this.tagsGeo.set(o, s.value.slice(a, a + l));
+      else
+        throw new Error("Failed to extract GeoTiffTags");
+    }
+  }
+  /**
+   * Get the origin point for the image
+   *
+   * @returns origin point of the image
+   */
+  get origin() {
+    const t = this.value(u.ModelTiePoint);
+    if (t != null && t.length === 6)
+      return [t[3], t[4], t[5]];
+    const n = this.value(u.ModelTransformation);
+    if (n != null)
+      return [n[3], n[7], n[11]];
+    if (this.value(u.SubFileType) === J.ReducedImage && this.id !== 0)
+      return this.tiff.images[0].origin;
+    throw new Error("Image does not have a geo transformation.");
+  }
+  /** Is there enough geo information on this image to figure out where its actually located */
+  get isGeoLocated() {
+    return this.value(u.ModelPixelScale) != null || this.value(u.ModelTransformation) != null ? !0 : this.isSubImage && this.id !== 0 ? this.tiff.images[0].isGeoLocated : !1;
+  }
+  /**
+   * Get the resolution of the image
+   *
+   * @returns [x,y,z] pixel scale
+   */
+  get resolution() {
+    const t = this.value(u.ModelPixelScale);
+    if (t != null)
+      return [t[0], -t[1], t[2]];
+    const n = this.value(u.ModelTransformation);
+    if (n != null)
+      return [n[0], n[5], n[10]];
+    if (this.isSubImage && this.id !== 0) {
+      const r = this.tiff.images[0], [o, i, a] = r.resolution, s = r.size, l = this.size;
+      return [o * s.width / l.width, i * s.height / l.height, a];
+    }
+    throw new Error("Image does not have a geo transformation.");
+  }
+  /**
+   * Is this image a reduced size image
+   * @see {@link TiffTag.SubFileType}
+   * @returns true if SubFileType is Reduces image, false otherwise
+   */
+  get isSubImage() {
+    return this.value(u.SubFileType) === J.ReducedImage;
+  }
+  /**
+   * Bounding box of the image
+   *
+   * @returns [minX, minY, maxX, maxY] bounding box
+   */
+  get bbox() {
+    const t = this.size, n = this.origin, r = this.resolution;
+    if (n == null || t == null || r == null)
+      throw new Error("Unable to calculate bounding box");
+    const o = n[0], i = n[1], a = o + r[0] * t.width, s = i + r[1] * t.height;
+    return [Math.min(o, a), Math.min(i, s), Math.max(o, a), Math.max(i, s)];
+  }
+  /**
+   * Get the compression used by the tile
+   *
+   * @see {@link TiffCompressionMimeType}
+   *
+   * @returns Compression type eg webp
+   */
+  get compression() {
+    const t = this.value(u.Compression);
+    return t == null ? null : ve[t];
+  }
+  /**
+   * Attempt to read the EPSG Code from TiffGeoTags
+   *
+   * looks at TiffTagGeo.ProjectionGeoKey, TiffTagGeo.ProjectedCRSGeoKey and TiffTagGeo.GeodeticCRSGeoKey
+   *
+   * @returns EPSG Code if it exists and is not user defined.
+   */
+  get epsg() {
+    const t = this.valueGeo(p.ProjectionGeoKey);
+    if (t != null && t !== Le)
+      return t;
+    let n = null;
+    switch (this.valueGeo(p.GTModelTypeGeoKey)) {
+      case M.Unknown:
+        return null;
+      case M.Projected:
+        n = this.valueGeo(p.ProjectedCRSGeoKey);
+        break;
+      case M.Geographic:
+        n = this.valueGeo(p.GeodeticCRSGeoKey);
+        break;
+      case M.Geocentric:
+        n = this.valueGeo(p.GeodeticCRSGeoKey);
+        break;
+      case M.UserDefined:
+        return null;
+    }
+    return n === Le ? null : n;
+  }
+  /**
+   * Get the size of the image
+   *
+   * @returns Size in pixels
+   */
+  get size() {
+    const t = this.value(u.ImageWidth), n = this.value(u.ImageHeight);
+    if (t == null || n == null)
+      throw new Error("Tiff has no height or width");
+    return { width: t, height: n };
+  }
+  /**
+   * Determine if this image is tiled
+   */
+  isTiled() {
+    return this.value(u.TileWidth) !== null;
+  }
+  /**
+   * Get size of individual tiles
+   */
+  get tileSize() {
+    const t = this.value(u.TileWidth), n = this.value(u.TileHeight);
+    if (t == null || n == null)
+      throw new Error("Tiff is not tiled");
+    return { width: t, height: n };
+  }
+  /**
+   * Number of tiles used to create this image
+   */
+  get tileCount() {
+    const t = this.size, n = this.tileSize, r = Math.ceil(t.width / n.width), o = Math.ceil(t.height / n.height);
+    return { x: r, y: o };
+  }
+  /**
+   * Get the pointer to where the tiles start in the Tiff file
+   *
+   * @remarks Used to read tiled tiffs
+   *
+   * @returns file offset to where the tiffs are stored
+   */
+  get tileOffset() {
+    const t = this.tags.get(u.TileOffsets);
+    if (t == null)
+      throw new Error("No tile offsets found");
+    return t;
+  }
+  /**
+   * Get the number of strip's inside this tiff
+   *
+   * @remarks Used to read striped tiffs
+   *
+   * @returns number of strips present
+   */
+  get stripCount() {
+    return this.tags.get(u.StripByteCounts)?.count ?? 0;
+  }
+  // Clamp the bounds of the output image to the size of the image, as sometimes the edge tiles are not full tiles
+  getTileBounds(t, n) {
+    const { size: r, tileSize: o } = this, i = n * o.height, a = t * o.width, s = a + o.width >= r.width ? r.width - a : o.width, l = i + o.height >= r.height ? r.height - i : o.height;
+    return { x: a, y: i, width: s, height: l };
+  }
+  /**
+   * Read a strip into a ArrayBuffer
+   *
+   * Image has to be striped see {@link stripCount}
+   *
+   * @param index Strip index to read
+   */
+  async getStrip(t, n) {
+    if (this.isTiled())
+      throw new Error("Cannot read stripes, tiff is tiled: " + t);
+    const r = this.tags.get(u.StripByteCounts), o = this.tags.get(u.StripOffsets);
+    if (t >= r.count)
+      throw new Error("Cannot read strip, index out of bounds");
+    const [i, a] = await Promise.all([
+      $(this.tiff, o, t, n),
+      $(this.tiff, r, t, n)
+    ]);
+    return this.getBytes(i, a, n);
+  }
+  /** The jpeg header is stored in the IFD, read the JPEG header and adjust the byte array to include it */
+  getJpegHeader(t) {
+    const n = this.value(u.JpegTables);
+    if (n == null)
+      throw new Error("Unable to find Jpeg header");
+    const r = n.slice(0, n.length - 2), o = new Uint8Array(t.byteLength + r.length - 2);
+    return o.set(r, 0), o.set(new Uint8Array(t).slice(2), r.length), o.buffer.slice(o.byteOffset, o.byteOffset + o.byteLength);
+  }
+  /** Read image bytes at the given offset */
+  async getBytes(t, n, r) {
+    if (n === 0)
+      return null;
+    const o = await this.tiff.source.fetch(t, n, r);
+    if (o.byteLength < n)
+      throw new Error(`Failed to fetch bytes from offset:${t} wanted:${n} got:${o.byteLength}`);
+    let i = this.value(u.Compression);
+    i == null && (i = m.None);
+    const a = yt(i) ?? w.None;
+    return i === m.Jpeg ? { mimeType: a, bytes: this.getJpegHeader(o), compression: i } : { mimeType: a, bytes: o, compression: i };
+  }
+  /**
+   * Load a tile into a ArrayBuffer
+   *
+   * if the tile compression is JPEG, This will also apply the JPEG compression tables to the resulting ArrayBuffer see {@link getJpegHeader}
+   *
+   * @param x Tile x offset
+   * @param y Tile y offset
+   */
+  async getTile(t, n, r) {
+    const o = this.size, i = this.tileSize;
+    if (i == null)
+      throw new Error("Tiff is not tiled");
+    const a = Math.ceil(o.height / i.height), s = Math.ceil(o.width / i.width);
+    if (t >= s || n >= a)
+      throw new Error(`Tile index is outside of range x:${t} >= ${s} or y:${n} >= ${a}`);
+    const l = n * s + t, c = s * a;
+    if (l >= c)
+      throw new Error(`Tile index is outside of tile range: ${l} >= ${c}`);
+    const { offset: d, imageSize: h } = await this.getTileSize(l, r);
+    return this.getBytes(d, h, r);
+  }
+  /**
+   * Does this tile exist in the tiff and does it actually have a value
+   *
+   * Sparse tiffs can have a lot of empty tiles, they set the tile size to `0 bytes` when the tile is empty
+   * this checks the tile byte size to validate if it actually has any data.
+   *
+   * @param x Tile x offset
+   * @param y Tile y offset
+   *
+   * @returns if the tile exists and has data
+   */
+  async hasTile(t, n, r) {
+    const o = this.tileSize, i = this.size;
+    if (o == null)
+      throw new Error("Tiff is not tiled");
+    const a = Math.ceil(i.height / o.height), s = Math.ceil(i.width / o.width);
+    if (t >= s || n >= a)
+      return !1;
+    const l = n * s + t;
+    return (await this.getTileSize(l, r)).offset > 0;
+  }
+  /**
+   * Load the offset and byteCount of a tile
+   *
+   * if the tiff is sparse, offset and byteCount will be zero if the tile is empty
+   *
+   * @param index index in the tile array
+   * @returns Offset and byteCount for the tile
+   */
+  async getTileSize(t, n) {
+    const r = this.tags.get(u.TileByteCounts), o = ee(this.tiff, this.tileOffset, t), i = ee(this.tiff, r, t);
+    if (o != null && i != null)
+      return { offset: o, imageSize: i };
+    const a = this.tiff.options?.tileLeaderByteSize;
+    if (a) {
+      const c = o ?? await $(this.tiff, this.tileOffset, t, n);
+      if (c === 0)
+        return { offset: 0, imageSize: 0 };
+      const d = await this.tiff.source.fetch(c - a, a, n);
+      return { offset: c, imageSize: K(new DataView(d), 0, a, this.tiff.isLittleEndian) };
+    }
+    if (r == null)
+      throw new Error("No tile byte counts found");
+    const [s, l] = await Promise.all([
+      o ?? $(this.tiff, this.tileOffset, t, n),
+      i ?? $(this.tiff, r, t, n)
+    ]);
+    return { offset: s, imageSize: l };
+  }
+}
+function $(e, t, n, r) {
+  const o = ee(e, t, n);
+  return o != null ? Promise.resolve(o) : It(e, t, n, r);
+}
+function ee(e, t, n) {
+  if (n < 0)
+    throw new Error(`Tiff: ${e.source.url.href} out of bounds ${u[t.id]} index:${n} total:${t.count}`);
+  return n >= t.count ? 0 : t.type === "inline" || t.isLoaded ? t.value[n] : Gt(e, t, n);
+}
+var z;
+(function(e) {
+  e.GdalStructuralMetadataSize = "GDAL_STRUCTURAL_METADATA_SIZE", e.Layout = "LAYOUT", e.BlockOrder = "BLOCK_ORDER", e.BlockLeader = "BLOCK_LEADER", e.BlockTrailer = "BLOCK_TRAILER", e.KnownIncompatibleEdition = "KNOWN_INCOMPATIBLE_EDITION", e.MaskInterleavedWithImagery = "MASK_INTERLEAVED_WITH_IMAGERY";
+})(z || (z = {}));
+var be;
+(function(e) {
+  e.RowMajor = "ROW_MAJOR";
+})(be || (be = {}));
+var te;
+(function(e) {
+  e.uint32 = "SIZE_AS_UINT4";
+})(te || (te = {}));
+class At {
+  options = /* @__PURE__ */ new Map();
+  /**
+   * Has GDAL optimized this tiff
+   */
+  get isCogOptimized() {
+    return this.isBroken ? !1 : this.options.get(z.Layout) === "IFDS_BEFORE_DATA";
+  }
+  /**
+   * Has GDAL determined this tiff is now broken
+   */
+  get isBroken() {
+    return this.options.get(z.KnownIncompatibleEdition) === "YES";
+  }
+  /**
+   * Load the ghost options from a source
+   * @param bytes the ghost header bytes
+   */
+  process(t, n, r) {
+    let o = "", i = "", a = !1;
+    for (let s = 0; s < r; s++) {
+      const l = t.getUint8(n + s);
+      if (l === 0)
+        break;
+      const c = String.fromCharCode(l);
+      c === `
+` ? (this.options.set(o.trim(), i.trim()), o = "", i = "", a = !1) : c === "=" ? a = !0 : a ? i += c : o += c;
+    }
+  }
+  /**
+   * If the tile leader is set, how many bytes are allocated to the tile size
+   */
+  get tileLeaderByteSize() {
+    switch (this.options.get(z.BlockLeader)) {
+      case te.uint32:
+        return L.UInt32;
+      default:
+        return null;
+    }
+  }
+  get isMaskInterleaved() {
+    return this.options.get(z.MaskInterleavedWithImagery) === "YES";
+  }
+}
+const Ke = {
+  version: v.Tiff,
+  pointer: L.UInt32,
+  offset: L.UInt16,
+  /**
+   * Each tag entry is specified as
+   * UInt16:TagCode
+   * UInt16:TagType
+   * UInt32:TagCount
+   * UInt32:Pointer To Value or value
+   */
+  ifd: L.UInt16 + L.UInt16 + 2 * L.UInt32
+}, De = {
+  version: v.BigTiff,
+  /** Size of most pointers */
+  pointer: L.UInt64,
+  /** Size of offsets */
+  offset: L.UInt64,
+  /**
+   * Each tag entry is specified as
+   * UInt16:TagCode
+   * UInt16:TagType
+   * UInt64:TagCount
+   * UInt64:Pointer To Value or value
+   */
+  ifd: L.UInt16 + L.UInt16 + 2 * L.UInt64
+};
+v.BigTiff + "", v.Tiff + "";
+function Rt(e, t = 4, n = !0) {
+  const r = e.toString(16).padStart(t, "0");
+  return n ? "0x" + r : r;
+}
+class B {
+  /** Read 16KB blocks at a time */
+  static DefaultReadSize = 16 * 1024;
+  /** Read 16KB blocks at a time */
+  defaultReadSize = B.DefaultReadSize;
+  /** Where this cog is fetching its data from */
+  source;
+  /** Big or small Tiff */
+  version = v.Tiff;
+  /** List of images, o is the base image */
+  images = [];
+  /** Ghost header options */
+  options;
+  /** Configuration for the size of the IFD */
+  ifdConfig = Ke;
+  /** Is the tiff being read is little Endian */
+  isLittleEndian = !1;
+  /** Has init() been called */
+  isInitialized = !1;
+  _initPromise;
+  /** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
+  constructor(t, n = { defaultReadSize: B.DefaultReadSize }) {
+    this.source = t, this.defaultReadSize = n.defaultReadSize;
+  }
+  /** Create a tiff and initialize it by reading the tiff headers */
+  static create(t, n = { defaultReadSize: B.DefaultReadSize }) {
+    return new B(t, n).init(n);
+  }
+  /**
+   * Initialize the tiff loading in the header and all image headers.
+   *
+   * This is only required if the Tiff was created with the constructor, if you
+   * used {@link create} this will have already been called.
+   */
+  init(t) {
+    return this.isInitialized ? Promise.resolve(this) : this._initPromise ? this._initPromise : (this._initPromise = this.readHeader(t), this._initPromise);
+  }
+  /**
+   * Find a image which has a resolution similar to the provided resolution
+   *
+   * @param resolution resolution to find
+   */
+  getImageByResolution(t) {
+    const n = this.images[0], r = n.size, [o] = n.resolution, i = o * r.width;
+    for (let a = this.images.length - 1; a > 0; a--) {
+      const s = this.images[a], l = s.size;
+      if (i / l.width - t <= 0.01)
+        return s;
+    }
+    return n;
+  }
+  /** Read the Starting header and all Image headers from the source */
+  async readHeader(t) {
+    if (this.isInitialized)
+      return this;
+    const n = new DataView(await this.source.fetch(0, Ie(this.source, 0, this.defaultReadSize), t));
+    if (n.byteLength === 0)
+      throw new Error("Unable to read empty tiff");
+    n.sourceOffset = 0;
+    let r = 0;
+    const o = n.getUint16(r, this.isLittleEndian);
+    r += 2, this.isLittleEndian = o === q.Little, this.version = n.getUint16(r, this.isLittleEndian), r += 2;
+    let i;
+    if (this.version === v.BigTiff) {
+      this.ifdConfig = De;
+      const s = n.getUint16(r, this.isLittleEndian);
+      if (r += 2, s !== 8)
+        throw new Error("Only 8byte pointers are supported");
+      const l = n.getUint16(r, this.isLittleEndian);
+      if (r += 2, l !== 0)
+        throw new Error("Invalid big tiff header");
+      i = K(n, r, this.ifdConfig.pointer, this.isLittleEndian), r += this.ifdConfig.pointer;
+    } else if (this.version === v.Tiff)
+      i = K(n, r, this.ifdConfig.pointer, this.isLittleEndian), r += this.ifdConfig.pointer;
+    else
+      throw new Error(`Only tiff supported version:${String(this.version)}`);
+    const a = i - r;
+    for (a > 0 && a < 16 * 1024 && (this.options = new At(), this.options.process(n, r, a)); i !== 0; ) {
+      let s = n;
+      if (!Y(s, i, 1024)) {
+        const l = await this.source.fetch(i, Ie(this.source, i, this.defaultReadSize), t);
+        s = new DataView(l), s.sourceOffset = i;
+      }
+      i = this.readIfd(i, s);
+    }
+    return await Promise.all(this.images.map((s) => s.init(!0, t))), this.isInitialized = !0, this;
+  }
+  /**
+   * Read a IFD at a the provided offset
+   *
+   * @param offset file offset to read the header from
+   * @param view offset that contains the bytes for the header
+   */
+  readIfd(t, n) {
+    const r = t - n.sourceOffset, o = K(n, r, this.ifdConfig.offset, this.isLittleEndian), i = /* @__PURE__ */ new Map(), a = o * this.ifdConfig.ifd;
+    if (!Y(n, t, a))
+      throw new Error("IFD out of range @ " + Rt(t) + " IFD" + this.images.length);
+    const s = this.ifdConfig.ifd, l = r + this.ifdConfig.offset;
+    for (let c = 0; c < o; c++) {
+      const d = Pt(this, n, l + c * s);
+      i.set(d.id, d);
+    }
+    return this.images.push(new Ft(this, this.images.length, i)), K(n, l + o * s, this.ifdConfig.pointer, this.isLittleEndian);
+  }
+}
+function Ie(e, t, n) {
+  const r = e.metadata?.size;
+  return r == null || r < 0 ? n : t + n > r ? r - t : n;
+}
+async function oe(e, t) {
+  const n = new Blob([e]), r = await createImageBitmap(n), o = new OffscreenCanvas(r.width, r.height), i = o.getContext("2d");
+  i.drawImage(r, 0, 0), r.close();
+  const { width: a, height: s } = o, c = i.getImageData(0, 0, a, s).data, d = t.samplesPerPixel;
+  if (d === 4)
+    return { layout: "pixel-interleaved", data: c };
+  if (d === 3) {
+    const h = a * s, g = new Uint8ClampedArray(h * 3);
+    for (let f = 0, S = 0; f < g.length; f += 3, S += 4)
+      g[f] = c[S], g[f + 1] = c[S + 1], g[f + 2] = c[S + 2];
+    return { layout: "pixel-interleaved", data: g };
+  }
+  if (d === 1) {
+    const h = a * s, g = new Uint8ClampedArray(h);
+    for (let f = 0, S = 0; f < h; f++, S += 4)
+      g[f] = c[S];
+    return { layout: "pixel-interleaved", data: g };
+  }
+  throw new Error(`Unsupported SamplesPerPixel for JPEG: ${d}`);
+}
+function vt(e, t = "") {
+  if (!e)
+    throw new Error(t);
+}
+async function Ut(e, { format: t, signal: n }) {
+  const r = e instanceof Response ? e : new Response(e);
+  vt(r.body, "Response does not contain body.");
+  try {
+    return await new Response(r.body.pipeThrough(new DecompressionStream(t), { signal: n })).arrayBuffer();
+  } catch {
+    throw n?.throwIfAborted(), new Error(`Failed to decode ${t}`);
+  }
+}
+async function xe(e) {
+  return Ut(e, { format: "deflate" });
+}
+function Ot(e, t) {
+  const n = e;
+  let r = 0, o = e.length - t;
+  do {
+    for (let i = t; i > 0; i--)
+      n[r + t] = (n[r + t] ?? 0) + (n[r] ?? 0), r++;
+    o -= t;
+  } while (o > 0);
+}
+function Mt(e, t, n) {
+  let r = 0, o = e.length;
+  const i = o / n;
+  for (; o > t; ) {
+    for (let s = t; s > 0; s--)
+      e[r + t] += e[r], r++;
+    o -= t;
+  }
+  const a = e.slice();
+  for (let s = 0; s < i; s++)
+    for (let l = 0; l < n; l++)
+      e[n * s + l] = a[(n - l - 1) * i + s];
+}
+function Kt(e, t, n, r, o, i, a) {
+  if (t === _.None)
+    return e;
+  const s = o / 8, l = a === U.Separate ? 1 : i;
+  for (let c = 0; c < r; c++) {
+    const d = c * l * n * s;
+    if (d >= e.byteLength)
+      break;
+    if (t === _.Horizontal) {
+      let h;
+      const g = l * n;
+      switch (o) {
+        case 8:
+          h = new Uint8Array(e, d, g);
+          break;
+        case 16:
+          h = new Uint16Array(e, d, g);
+          break;
+        case 32:
+          h = new Uint32Array(e, d, g);
+          break;
+        default:
+          throw new Error(`Predictor 2 not supported for ${o} bits per sample.`);
+      }
+      Ot(h, l);
+    } else if (t === _.FloatingPoint) {
+      const h = new Uint8Array(e, d, l * n * s);
+      Mt(h, l, s);
+    }
+  }
+  return e;
+}
+async function Dt(e) {
+  return e;
+}
+const A = /* @__PURE__ */ new Map();
+A.set(m.None, () => Promise.resolve(Dt));
+A.set(m.Deflate, () => Promise.resolve(xe));
+A.set(m.DeflateOther, () => Promise.resolve(xe));
+A.set(m.Lzw, () => import("./lzw-BY5a_5nb.js").then((e) => e.decode));
+A.set(m.Zstd, () => import("./zstd-jXobGRcq.js").then((e) => e.decode));
+A.set(m.Jpeg, () => Promise.resolve(oe));
+A.set(m.Jpeg6, () => Promise.resolve(oe));
+A.set(m.Webp, () => Promise.resolve(oe));
+A.set(m.Lerc, () => import("./lerc-Bl4IMkfo.js").then((e) => e.l).then((e) => e.decode));
+async function ie(e, t, n) {
+  const r = A.get(t);
+  if (!r)
+    throw new Error(`Unsupported compression: ${t}`);
+  const i = await (await r())(e, n);
+  if (i instanceof ArrayBuffer) {
+    const { predictor: a, width: s, height: l, bitsPerSample: c, samplesPerPixel: d, planarConfiguration: h } = n, g = Kt(i, a, s, l, c, d, h);
+    return {
+      layout: "pixel-interleaved",
+      data: Nt(g, n)
+    };
+  }
+  return i;
+}
+function xt(e, t) {
+  const n = new Uint8Array(e), r = new Uint8Array(t);
+  for (let o = 0; o < t; o++)
+    r[o] = n[o >> 3] >> 7 - (o & 7) & 1 ? 255 : 0;
+  return r;
+}
+function Nt(e, t) {
+  const { sampleFormat: n, bitsPerSample: r } = t;
+  switch (n) {
+    case F.Uint:
+      switch (r) {
+        case 1:
+          return xt(e, t.width * t.height * t.samplesPerPixel);
+        case 8:
+          return new Uint8Array(e);
+        case 16:
+          return new Uint16Array(e);
+        case 32:
+          return new Uint32Array(e);
+      }
+      break;
+    case F.Int:
+      switch (r) {
+        case 8:
+          return new Int8Array(e);
+        case 16:
+          return new Int16Array(e);
+        case 32:
+          return new Int32Array(e);
+      }
+      break;
+    case F.Float:
+      switch (r) {
+        case 32:
+          return new Float32Array(e);
+        case 64:
+          return new Float64Array(e);
+      }
+      break;
+  }
+  throw new Error(`Unsupported sample format/depth: SampleFormat=${n}, BitsPerSample=${r}`);
+}
+class zt {
+  name = "source:cache";
+  maxSize;
+  /** Number of bytes cached in cacheA, when this overflows maxSize cacheA is moved to cacheB and cacheB is dropped */
+  size = 0;
+  /** Number of times `this.cacheB` has been cleared */
+  resets = 0;
+  /** Primary cache of objects */
+  cacheA = /* @__PURE__ */ new Map();
+  cacheB = /* @__PURE__ */ new Map();
+  /** List of protocols to cache */
+  protocols;
+  constructor(t) {
+    this.maxSize = t.size, this.protocols = new Set(t.protocols ?? []);
+  }
+  fetch(t, n) {
+    if (this.protocols.size > 0 && !this.protocols.has(t.source.url.protocol) || t.length == null)
+      return n(t);
+    const r = `${t.source.url.toString()}@${t.offset}+${t.length}`;
+    let o = this.cacheA.get(r);
+    return o ? (o.hits++, o.promise) : (o = this.cacheB.get(r), o ? (o.hits++, o.saves++, this.size += o.size, this.cacheA.set(r, o), o.promise) : (o = { promise: n(t), hits: 0, saves: 0, size: t.length }, this.size += o.size, this.size > this.maxSize && (this.size = o.size, this.cacheB = this.cacheA, this.cacheA = /* @__PURE__ */ new Map(), this.resets++), this.cacheA.set(r, o), o.promise));
+  }
+}
+class O extends Error {
+  /** Status code for the error eg 403 - Forbidden vs 404 Not found */
+  code;
+  /** URL that the status code came from */
+  url;
+  /** File system that triggered the error */
+  source;
+  constructor(t, n, r, o) {
+    super(t, { cause: o }), this.code = n, this.url = r.url, this.source = r, Object.defineProperty(this, "_sourceError", {
+      enumerable: !1,
+      // hide it from for..in
+      value: "SourceError"
+    });
+  }
+  /** Check that a unknown is a FsError */
+  static is(t) {
+    return t instanceof O ? !0 : typeof t != "object" || t == null ? !1 : "_sourceError" in t && t._sourceError === "SourceError";
+  }
+}
+const X = {
+  /** Convert a offset/length to a range request
+   *
+   * @example
+   * ```typescript
+   * ContentRange.toRange(10) // "bytes=10"
+   * ContentRange.toRange(0, 1024) // "bytes=0-1023"
+   * ```
+   */
+  toRange(e, t) {
+    if (t == null)
+      return `bytes=${e}`;
+    if (e < 0)
+      throw new Error("Cannot read from remote source with negative offset and length");
+    return `bytes=${e}-${e + t - 1}`;
+  },
+  /**
+   * Parse a Content-Range header to extract the size of the source
+   *
+   * @example
+   * ```typescript
+   * ContentRange.parseRange("bytes 200-1000/67589"); // 67589
+   * ```
+   * @throws if range is not a Content-Range with size
+   */
+  parseSize(e) {
+    const [t, n] = e.split(" ");
+    if (t !== "bytes")
+      throw new Error("Failed to parse content-range: " + e);
+    if (n == null)
+      throw new Error("Failed to parse content-range: " + e);
+    const [, r] = n.split("/"), o = Number(r);
+    if (isNaN(o))
+      throw new Error("Failed to parse content-range: " + e);
+    return o;
+  }
+};
+class Bt {
+  source;
+  middleware;
+  static is(t) {
+    return "middleware" in t;
+  }
+  constructor(t, n = []) {
+    this.source = t, this.middleware = n;
+  }
+  get type() {
+    return this.source.type;
+  }
+  get url() {
+    return this.source.url;
+  }
+  get metadata() {
+    return this.source.metadata;
+  }
+  head(t) {
+    return this.source.head(t);
+  }
+  async fetch(t, n, r) {
+    const o = this.middleware;
+    if (o == null || o.length === 0)
+      return this.source.fetch(t, n, r);
+    const i = (a) => this.source.fetch(a.offset, a.length, r);
+    return this.run(i, t, n, r);
+  }
+  /** Run a request using all the middleware */
+  async run(t, n, r, o) {
+    const i = this.middleware;
+    if (i == null)
+      return t({ source: this, offset: n, length: r, signal: o?.signal });
+    function a(s, l) {
+      return (c) => s.fetch(c, l);
+    }
+    for (let s = i.length - 1; s >= 0; s--)
+      t = a(i[s], t);
+    return t({ source: this, offset: n, length: r, signal: o?.signal });
+  }
+}
+function _t(e) {
+  try {
+    return new URL(e);
+  } catch {
+    return null;
+  }
+}
+class kt {
+  name = "source:chunk";
+  /** Number of bytes to chunk requests into */
+  chunkSize;
+  constructor(t) {
+    this.chunkSize = t.size ?? 32 * 1024;
+  }
+  async fetch(t, n) {
+    if (t.offset < 0 || t.length == null)
+      return n(t);
+    const r = Math.floor(t.offset / this.chunkSize), o = Math.ceil((t.offset + t.length) / this.chunkSize), i = t.source.metadata?.size;
+    if (i != null && t.offset + t.length > i)
+      throw new O(`Request outside of bounds ${X.toRange(t.offset, t.length)}`, 416, t.source);
+    const a = r * this.chunkSize, l = (i != null ? Math.min(o * this.chunkSize, i) : o * this.chunkSize) - a, c = t.offset - a;
+    return o - r > 1 ? (await this.fetchChunks(t, r, o)).slice(c, c + t.length) : t.offset === a && t.length === l ? n(t) : (await n({ ...t, offset: a, length: l })).slice(c, c + t.length);
+  }
+  async fetchChunks(t, n, r) {
+    const o = [], i = t.source.metadata?.size ?? r * this.chunkSize;
+    for (let l = n; l < r; l++) {
+      const c = l * this.chunkSize, h = Math.min(c + this.chunkSize, i) - c;
+      o.push(t.source.fetch(l * this.chunkSize, h, t.signal ? { signal: t.signal } : void 0));
+    }
+    const a = await Promise.all(o), s = new Uint8Array(o.length * this.chunkSize);
+    for (let l = 0; l < a.length; l++)
+      s.set(new Uint8Array(a[l]), l * this.chunkSize);
+    return s.buffer;
+  }
+}
+function Ge(e) {
+  const t = {}, n = e.headers.get("content-length");
+  n && (t.size = parseInt(n));
+  const r = e.headers.get("content-range");
+  return r != null && (t.size = X.parseSize(r)), t.eTag = e.headers.get("etag") ?? void 0, t.contentType = e.headers.get("content-type") ?? void 0, t.contentDisposition = e.headers.get("content-disposition") ?? void 0, t.cacheControl = e.headers.get("cache-control") ?? void 0, t.contentEncoding = e.headers.get("content-encoding") ?? void 0, t;
+}
+class k {
+  constructor(t, n) {
+    this.type = "http", this.url = typeof t == "string" ? k.tryUrl(t) : t, this.headers = n;
+  }
+  /** Attempt to parse a relative string into a URL */
+  static tryUrl(t) {
+    try {
+      return new URL(t);
+    } catch {
+      return typeof document < "u" ? new URL(t, document.baseURI) : new URL(t, import.meta.url);
+    }
+  }
+  head() {
+    return this._head ? this._head : (this._head = k.fetch(this.url, { method: "HEAD", headers: this.headers }).then((t) => {
+      if (!t.ok)
+        throw delete this._head, new Error(`Failed to HEAD ${this.url.href}`, { cause: { statusCode: t.status, msg: t.statusText } });
+      return this.metadata = Ge(t), this.metadata;
+    }), this._head);
+  }
+  async fetch(t, n, r) {
+    try {
+      const o = { range: X.toRange(t, n), ...this.headers }, i = await k.fetch(this.url, { headers: o, signal: r?.signal });
+      if (!i.ok)
+        throw new O(`Failed to fetch ${this.url.href} ${o.range}`, i.status, this, new Error(i.statusText));
+      const a = Ge(i);
+      if (this.metadata == null)
+        this.metadata = a;
+      else if (this.metadata.eTag && this.metadata.eTag !== a.eTag)
+        throw new O(`ETag conflict ${this.url.href} ${o.range} expected: ${this.metadata.eTag} got: ${a.eTag}`, 409, this);
+      return i.arrayBuffer();
+    } catch (o) {
+      throw O.is(o) && o.source === this ? o : new O(`Failed to fetch: ${this.url.href}`, 500, this, o);
+    }
+  }
+}
+k.fetch = (e, t) => fetch(e, t);
+function $t(e) {
+  if (typeof e != "string")
+    return e;
+  const t = _t(e);
+  return t || new URL("memory://" + e);
+}
+class ae {
+  url;
+  type = "memory";
+  data;
+  metadata;
+  static toArrayBuffer(t) {
+    return t instanceof ArrayBuffer ? t : t.byteLength === t.buffer.byteLength ? t.buffer : t.buffer.slice(t.byteOffset, t.byteOffset + t.byteLength);
+  }
+  constructor(t, n) {
+    const r = ae.toArrayBuffer(n ?? new Uint8Array());
+    this.url = $t(t), this.data = r, this.metadata = { size: r.byteLength };
+  }
+  head() {
+    return Promise.resolve({ size: this.data.byteLength });
+  }
+  fetch(t, n) {
+    if (t < 0 && (t = this.data.byteLength + t), t > this.data.byteLength)
+      throw new O(`Read offset outside of file bounds range:${X.toRange(t, n)} fileSize:${this.data.byteLength}`, 416, this);
+    return Promise.resolve(this.data.slice(t, n == null ? void 0 : t + n));
+  }
+}
+const Ne = "https://proj.org/schemas/v0.7/projjson.schema.json", Wt = 1, Jt = 2, V = 32767, je = 1, Vt = 2, Ht = 3, Yt = 4, Xt = 5, Zt = 6, Qt = 7, qt = 8, Tt = 9, en = 10, tn = 11, nn = 12, rn = 14, on = 15, an = 16, sn = 17, ln = 18, cn = 21, un = 22, dn = 24, hn = 26, pn = 27, ze = 9102, gn = 9101, mn = 9105, fn = {
+  [ze]: "degree",
+  [gn]: "radian",
+  [mn]: "grad"
+}, Be = 9001, yn = 9002, wn = 9003, Sn = {
+  type: "LinearUnit",
+  name: "US survey foot",
+  conversion_factor: 0.30480060960121924
+}, Pn = {
+  [Be]: "metre",
+  [yn]: "foot",
+  [wn]: Sn
+};
+function Cn(e) {
+  const t = e.modelType;
+  if (t === Wt)
+    return bn(e);
+  if (t === Jt)
+    return Ln(e);
+  throw new Error(`Unsupported GeoTIFF model type: ${t}`);
+}
+function Ln(e) {
+  const t = e.geodeticCRS;
+  return t !== null && t !== V ? t : _e(e, Ne);
+}
+function bn(e) {
+  const t = e.projectedCRS;
+  return t !== null && t !== V ? t : In(e);
+}
+function _e(e, t) {
+  const n = Gn(e);
+  let r = "Greenwich", o = 0;
+  e.primeMeridian !== null && e.primeMeridian !== V ? r = `EPSG:${e.primeMeridian}` : e.primeMeridianLongitude !== null && (o = e.primeMeridianLongitude, r = "User-defined");
+  let i;
+  e.geodeticDatum !== null && e.geodeticDatum !== V ? i = {
+    type: "GeodeticReferenceFrame",
+    name: `Unknown datum based upon EPSG ${e.geodeticDatum} ellipsoid`
+  } : i = {
+    type: "GeodeticReferenceFrame",
+    name: e.geodeticCitation ?? "User-defined",
+    ellipsoid: n,
+    prime_meridian: { name: r, longitude: o }
+  };
+  const a = {
+    type: "GeographicCRS",
+    name: e.geodeticCitation ?? "User-defined",
+    datum: i,
+    coordinate_system: En(e)
+  };
+  return t !== void 0 && (a.$schema = t), a;
+}
+function In(e) {
+  const t = _e(e), n = jn(e), r = Fn(e);
+  return {
+    type: "ProjectedCRS",
+    $schema: Ne,
+    name: e.projectedCitation ?? e.citation ?? "User-defined",
+    base_crs: t,
+    conversion: n,
+    coordinate_system: r
+  };
+}
+function Gn(e) {
+  if (e.ellipsoid !== null && e.ellipsoid !== V) {
+    const n = {
+      name: `EPSG ellipsoid ${e.ellipsoid}`
+    };
+    return e.ellipsoidSemiMajorAxis !== null && (n.semi_major_axis = e.ellipsoidSemiMajorAxis), e.ellipsoidInvFlattening !== null ? n.inverse_flattening = e.ellipsoidInvFlattening : e.ellipsoidSemiMinorAxis !== null && (n.semi_minor_axis = e.ellipsoidSemiMinorAxis), n;
+  }
+  if (e.ellipsoidSemiMajorAxis === null)
+    throw new Error("User-defined ellipsoid requires ellipsoidSemiMajorAxis");
+  const t = {
+    name: e.geodeticCitation ?? "User-defined",
+    semi_major_axis: e.ellipsoidSemiMajorAxis
+  };
+  if (e.ellipsoidInvFlattening !== null)
+    t.inverse_flattening = e.ellipsoidInvFlattening;
+  else if (e.ellipsoidSemiMinorAxis !== null)
+    t.semi_minor_axis = e.ellipsoidSemiMinorAxis;
+  else
+    throw new Error("User-defined ellipsoid requires ellipsoidInvFlattening or ellipsoidSemiMinorAxis");
+  return t;
+}
+function jn(e) {
+  const t = e.projMethod;
+  if (t === null)
+    throw new Error("User-defined projected CRS requires projMethod");
+  const n = (i, a, s = 0) => ({
+    name: i,
+    value: a ?? s,
+    unit: "degree"
+  }), r = (i, a, s = 0) => ({
+    name: i,
+    value: a ?? s,
+    unit: "metre"
+  }), o = (i, a, s = 1) => ({
+    name: i,
+    value: a ?? s,
+    unit: "unity"
+  });
+  switch (t) {
+    case je:
+    case Vt:
+    case pn: {
+      const i = t === je ? "Transverse Mercator" : "Transverse Mercator (South Orientated)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          o("Scale factor at natural origin", e.projScaleAtNatOrigin),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case Ht:
+    case Yt:
+    case Xt:
+    case Zt: {
+      const i = "Hotine Oblique Mercator (variant B)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of projection centre", e.projCenterLat),
+          n("Longitude of projection centre", e.projCenterLong),
+          n("Azimuth of initial line", e.projAzimuthAngle),
+          n("Angle from Rectified to Skew Grid", e.projAzimuthAngle),
+          o("Scale factor on initial line", e.projScaleAtCenter),
+          r("Easting at projection centre", e.projCenterEasting),
+          r("Northing at projection centre", e.projCenterNorthing)
+        ]
+      };
+    }
+    case Qt: {
+      const i = "Mercator (variant A)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          o("Scale factor at natural origin", e.projScaleAtNatOrigin),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case qt: {
+      const i = "Lambert Conic Conformal (2SP)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of false origin", e.projFalseOriginLat ?? e.projNatOriginLat),
+          n("Longitude of false origin", e.projFalseOriginLong ?? e.projNatOriginLong),
+          n("Latitude of 1st standard parallel", e.projStdParallel1),
+          n("Latitude of 2nd standard parallel", e.projStdParallel2),
+          r("Easting at false origin", e.projFalseOriginEasting ?? e.projFalseEasting),
+          r("Northing at false origin", e.projFalseOriginNorthing ?? e.projFalseNorthing)
+        ]
+      };
+    }
+    case Tt: {
+      const i = "Lambert Conic Conformal (1SP)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          o("Scale factor at natural origin", e.projScaleAtNatOrigin),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case en: {
+      const i = "Lambert Azimuthal Equal Area";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case tn: {
+      const i = "Albers Equal Area";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of false origin", e.projFalseOriginLat ?? e.projNatOriginLat),
+          n("Longitude of false origin", e.projFalseOriginLong ?? e.projNatOriginLong),
+          n("Latitude of 1st standard parallel", e.projStdParallel1),
+          n("Latitude of 2nd standard parallel", e.projStdParallel2),
+          r("Easting at false origin", e.projFalseOriginEasting ?? e.projFalseEasting),
+          r("Northing at false origin", e.projFalseOriginNorthing ?? e.projFalseNorthing)
+        ]
+      };
+    }
+    case nn: {
+      const i = "Modified Azimuthal Equidistant";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case rn: {
+      const i = "Stereographic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          o("Scale factor at natural origin", e.projScaleAtCenter),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case on: {
+      const i = "Polar Stereographic (variant B)";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of standard parallel", e.projNatOriginLat ?? e.projStdParallel1),
+          n("Longitude of origin", e.projStraightVertPoleLong ?? e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case an: {
+      const i = "Oblique Stereographic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          o("Scale factor at natural origin", e.projScaleAtCenter),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case sn: {
+      const i = "Equidistant Cylindrical";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of 1st standard parallel", e.projStdParallel1 ?? e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case ln: {
+      const i = "Cassini-Soldner";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case un: {
+      const i = "American Polyconic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case dn: {
+      const i = "Sinusoidal";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case cn: {
+      const i = "Orthographic";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projCenterLat),
+          n("Longitude of natural origin", e.projCenterLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    case hn: {
+      const i = "New Zealand Map Grid";
+      return {
+        name: i,
+        method: { name: i },
+        parameters: [
+          n("Latitude of natural origin", e.projNatOriginLat),
+          n("Longitude of natural origin", e.projNatOriginLong),
+          r("False easting", e.projFalseEasting),
+          r("False northing", e.projFalseNorthing)
+        ]
+      };
+    }
+    default:
+      throw new Error(`Unsupported coordinate transformation type: ${t}`);
+  }
+}
+function En(e) {
+  const t = fn[e.angularUnits ?? ze] ?? "degree";
+  return {
+    subtype: "ellipsoidal",
+    axis: [
+      {
+        name: "Geodetic latitude",
+        abbreviation: "Lat",
+        direction: "north",
+        unit: t
+      },
+      {
+        name: "Geodetic longitude",
+        abbreviation: "Lon",
+        direction: "east",
+        unit: t
+      }
+    ]
+  };
+}
+function Fn(e) {
+  const t = Pn[e.projLinearUnits ?? Be] ?? "metre";
+  return {
+    subtype: "Cartesian",
+    axis: [
+      { name: "Easting", abbreviation: "E", direction: "east", unit: t },
+      { name: "Northing", abbreviation: "N", direction: "north", unit: t }
+    ]
+  };
+}
+const An = 1024 * 1024, Rn = 16 * 1024 * 1024, Ee = 6;
+async function vn(e, t, n) {
+  if (t.length === 0)
+    return [];
+  const r = n?.coalesce ?? An, o = n?.maxRangeSize ?? Rn, i = n?.signal, a = Un(t, r, o), s = await Mn(e, a, i), l = new Array(t.length);
+  for (let c = 0; c < t.length; c++) {
+    const d = t[c], h = On(a, d.offset), g = a[h], f = s[h], S = d.offset - g.offset, P = S + d.length;
+    if (P > f.byteLength)
+      throw new Error(`Failed to fetch bytes from offset:${d.offset} wanted:${d.length} got:${f.byteLength - S}`);
+    l[c] = f.slice(S, P);
+  }
+  return l;
+}
+function Un(e, t, n) {
+  const r = [...e].sort((a, s) => a.offset - s.offset), o = [];
+  let i = null;
+  for (const a of r) {
+    if (i == null) {
+      i = { offset: a.offset, length: a.length };
+      continue;
+    }
+    const s = i.offset + i.length, l = a.offset + a.length, c = a.offset - s, d = Math.max(s, l), h = d - i.offset;
+    c <= t && h <= n ? i.length = d - i.offset : (o.push(i), i = { offset: a.offset, length: a.length });
+  }
+  return i != null && o.push(i), o;
+}
+function On(e, t) {
+  let n = 0, r = e.length - 1;
+  for (; n < r; ) {
+    const o = n + r + 1 >>> 1;
+    e[o].offset <= t ? n = o : r = o - 1;
+  }
+  return n;
+}
+async function Mn(e, t, n) {
+  const r = new Array(t.length);
+  for (let o = 0; o < t.length; o += Ee) {
+    const i = t.slice(o, o + Ee), a = await Promise.all(i.map((s) => e.fetch(s.offset, s.length, { signal: n })));
+    for (let s = 0; s < a.length; s++)
+      r[o + s] = a[s];
+  }
+  return r;
+}
+async function ke(e, t, n, { boundless: r = !0, pool: o, signal: i } = {}) {
+  const a = xn(e, t, n, { signal: i }), s = e.maskImage != null ? Ve(e.maskImage, t, n, e.dataSource, {
+    signal: i,
+    debug: e._debug ? { label: "mask" } : void 0
+  }) : Promise.resolve(null), [l, c] = await Promise.all([a, s]);
+  return $e(e, t, n, l, c, { boundless: r, pool: o });
+}
+async function $e(e, t, n, r, o, { boundless: i, pool: a }) {
+  const { bitsPerSample: s, predictor: l, planarConfiguration: c, sampleFormat: d, lercParameters: h } = e.cachedTags, { sampleFormat: g, bitsPerSample: f } = Ze(d, s), S = re(e.transform, Ae(t * e.tileWidth, n * e.tileHeight)), P = e.image.value(u.SamplesPerPixel) ?? 1, C = {
+    sampleFormat: g,
+    bitsPerSample: f,
+    samplesPerPixel: P,
+    width: e.tileWidth,
+    height: e.tileHeight,
+    predictor: l,
+    planarConfiguration: c,
+    lercParameters: h
+  }, [j, b] = await Promise.all([
+    Dn(r, C, a),
+    o != null && e.maskImage != null ? Kn(o, e.maskImage, a) : Promise.resolve(null)
+  ]), G = {
+    ...j,
+    count: P,
+    height: e.tileHeight,
+    width: e.tileWidth,
+    mask: b,
+    transform: S,
+    crs: e.crs,
+    nodata: e.nodata
+  };
+  return {
+    x: t,
+    y: n,
+    array: i === !0 ? G : _n(e, t, n, G)
+  };
+}
+async function We(e, t, { boundless: n = !0, pool: r, signal: o } = {}) {
+  if (t.length === 0)
+    return [];
+  const i = zn(e, t, { signal: o }), a = e.maskImage != null ? Xe(e.maskImage, t, e.dataSource, {
+    signal: o,
+    debug: e._debug ? { label: "mask" } : void 0
+  }) : Promise.resolve(t.map(() => null)), [s, l] = await Promise.all([
+    i,
+    a
+  ]);
+  return Promise.all(t.map(([c, d], h) => $e(e, c, d, s[h], l[h] ?? null, {
+    boundless: n,
+    pool: r
+  })));
+}
+async function Kn(e, t, n) {
+  const r = t.value(u.SampleFormat) ?? [1], o = t.value(u.BitsPerSample) ?? [8], { sampleFormat: i, bitsPerSample: a } = Ze(r, new Uint16Array(o)), { width: s, height: l } = t.tileSize, c = {
+    sampleFormat: i,
+    bitsPerSample: a,
+    samplesPerPixel: t.value(u.SamplesPerPixel) ?? 1,
+    width: s,
+    height: l,
+    predictor: t.value(u.Predictor) ?? 1,
+    planarConfiguration: t.value(u.PlanarConfiguration) ?? U.Contig
+  }, d = (P, C, j) => n ? n.decode(P, C, j) : ie(P, C, j), { bytes: h, compression: g } = e, f = await d(h, g, c), S = f.layout === "pixel-interleaved" ? f.data : f.bands[0];
+  if (S instanceof Uint8Array)
+    return S;
+  throw new Error("Expected mask data to decode to Uint8Array");
+}
+async function Dn(e, t, n) {
+  const r = (o, i, a) => n ? n.decode(o, i, a) : ie(o, i, a);
+  if (Array.isArray(e)) {
+    const o = { ...t, samplesPerPixel: 1 };
+    return { layout: "band-separate", bands: (await Promise.all(e.map(({ bytes: s, compression: l }) => r(s, l, o)))).map((s) => s.layout === "band-separate" ? s.bands[0] : s.data) };
+  } else {
+    const { bytes: o, compression: i } = e;
+    return r(o, i, t);
+  }
+}
+async function xn(e, t, n, { signal: r } = {}) {
+  const o = e._debug ? { label: "data" } : void 0;
+  switch (e.cachedTags.planarConfiguration) {
+    case U.Contig: {
+      const i = await Ve(e.image, t, n, e.dataSource, {
+        signal: r,
+        debug: o
+      });
+      if (i === null)
+        throw new Error(`Tile at (${t}, ${n}) not found`);
+      return i;
+    }
+    case U.Separate:
+      return await Nn(e, t, n, { signal: r });
+    default:
+      throw new Error(`Unsupported PlanarConfiguration: ${e.cachedTags.planarConfiguration}`);
+  }
+}
+async function Je(e, t, n) {
+  const { x: r, y: o } = e.image.tileCount, i = r * o, a = e.cachedTags.samplesPerPixel, s = [...Array(a).keys()].map((l) => {
+    const c = l * i + n * r + t;
+    return e.image.getTileSize(c);
+  });
+  return Promise.all(s);
+}
+async function Nn(e, t, n, { signal: r } = {}) {
+  const o = e._debug ? { label: "data" } : void 0, a = (await Je(e, t, n)).map(async ({ offset: s, imageSize: l }) => {
+    const c = await He(e.image, s, l, e.dataSource, { signal: r, debug: o });
+    if (c === null)
+      throw new Error(`Tile at (${t}, ${n}) not found`);
+    return c;
+  });
+  return Promise.all(a);
+}
+async function zn(e, t, { signal: n } = {}) {
+  const r = e._debug ? { label: "data" } : void 0;
+  switch (e.cachedTags.planarConfiguration) {
+    case U.Contig:
+      return (await Xe(e.image, t, e.dataSource, {
+        signal: n,
+        debug: r
+      })).map((i, a) => {
+        if (i === null) {
+          const [s, l] = t[a];
+          throw new Error(`Tile at (${s}, ${l}) not found`);
+        }
+        return i;
+      });
+    case U.Separate:
+      return Bn(e, t, { signal: n });
+    default:
+      throw new Error(`Unsupported PlanarConfiguration: ${e.cachedTags.planarConfiguration}`);
+  }
+}
+async function Bn(e, t, { signal: n } = {}) {
+  const r = e._debug ? { label: "data" } : void 0, o = e.cachedTags.samplesPerPixel, a = (await Promise.all(t.map(([l, c]) => Je(e, l, c)))).flatMap((l) => l.map(({ offset: c, imageSize: d }) => ({
+    offset: c,
+    byteCount: d
+  }))), s = await Ye(e.image, a, e.dataSource, { signal: n, debug: r });
+  return t.map(([l, c], d) => s.slice(d * o, d * o + o).map((h) => {
+    if (h === null)
+      throw new Error(`Tile at (${l}, ${c}) not found`);
+    return h;
+  }));
+}
+async function Ve(e, t, n, r, o) {
+  const { size: i, tileSize: a } = e;
+  if (a == null)
+    throw new Error("Tiff is not tiled");
+  const s = Math.ceil(i.height / a.height), l = Math.ceil(i.width / a.width);
+  if (t >= l || n >= s)
+    throw new Error(`Tile index is outside of range x:${t} >= ${l} or y:${n} >= ${s}`);
+  const c = n * l + t, d = l * s;
+  if (c >= d)
+    throw new Error(`Tile index is outside of tile range: ${c} >= ${d}`);
+  const { offset: h, imageSize: g } = await e.getTileSize(c);
+  return He(e, h, g, r, o);
+}
+async function He(e, t, n, r, o) {
+  if (n === 0)
+    return null;
+  o?.debug !== void 0 && console.log(`[geotiff dataSource] ${o.debug.label}: offset=${t} length=${n}`);
+  const i = await r.fetch(t, n, o);
+  if (i.byteLength < n)
+    throw new Error(`Failed to fetch bytes from offset:${t} wanted:${n} got:${i.byteLength}`);
+  const a = e.value(u.Compression) ?? m.None;
+  return a === m.Jpeg ? {
+    bytes: e.getJpegHeader(i),
+    compression: a
+  } : { bytes: i, compression: a };
+}
+async function Ye(e, t, n, r) {
+  if (t.length === 0)
+    return [];
+  const o = new Array(t.length), i = [], a = [];
+  for (let c = 0; c < t.length; c++) {
+    const d = t[c];
+    d.offset === 0 || d.byteCount === 0 ? o[c] = null : (a.push(c), i.push({ offset: d.offset, length: d.byteCount }));
+  }
+  if (i.length === 0)
+    return o;
+  if (r?.debug !== void 0)
+    for (const c of i)
+      console.log(`[geotiff dataSource] ${r.debug.label}: offset=${c.offset} length=${c.length}`);
+  const s = await vn(n, i, {
+    coalesce: r?.coalesce,
+    maxRangeSize: r?.maxRangeSize,
+    signal: r?.signal
+  }), l = e.value(u.Compression) ?? m.None;
+  for (let c = 0; c < s.length; c++) {
+    const d = a[c], h = s[c], g = l === m.Jpeg ? e.getJpegHeader(h) : h;
+    o[d] = { bytes: g, compression: l };
+  }
+  return o;
+}
+async function Xe(e, t, n, r) {
+  if (t.length === 0)
+    return [];
+  const { size: o, tileSize: i } = e;
+  if (i == null)
+    throw new Error("Tiff is not tiled");
+  const a = Math.ceil(o.height / i.height), s = Math.ceil(o.width / i.width), l = s * a, c = t.map(([h, g]) => {
+    if (h >= s || g >= a)
+      throw new Error(`Tile index is outside of range x:${h} >= ${s} or y:${g} >= ${a}`);
+    const f = g * s + h;
+    if (f >= l)
+      throw new Error(`Tile index is outside of tile range: ${f} >= ${l}`);
+    return f;
+  }), d = await Promise.all(c.map((h) => e.getTileSize(h)));
+  return Ye(e, d.map((h) => ({ offset: h.offset, byteCount: h.imageSize })), n, r);
+}
+function _n(e, t, n, r) {
+  const { width: o, height: i } = e.image.getTileBounds(t, n);
+  if (o === e.tileWidth && i === e.tileHeight)
+    return r;
+  const a = r.mask ? Q(r.mask, e.tileWidth, o, i, 1) : r.mask;
+  if (r.layout === "pixel-interleaved") {
+    const { count: c, data: d } = r, h = Q(d, e.tileWidth, o, i, c);
+    return {
+      ...r,
+      width: o,
+      height: i,
+      data: h,
+      mask: a
+    };
+  }
+  const { bands: s } = r, l = s.map((c) => Q(c, e.tileWidth, o, i, 1));
+  return {
+    ...r,
+    width: o,
+    height: i,
+    bands: l,
+    mask: a
+  };
+}
+function Q(e, t, n, r, o) {
+  const i = t * o, a = n * o, s = new e.constructor(a * r);
+  for (let l = 0; l < r; l++)
+    s.set(e.subarray(l * i, l * i + a), l * a);
+  return s;
+}
+function Ze(e, t) {
+  const n = new Set(e), r = new Set(t);
+  if (n.size > 1)
+    throw new Error("Multiple sample formats are not supported.");
+  if (r.size > 1)
+    throw new Error("Multiple bits per sample values are not supported.");
+  const o = e[0], i = t[0];
+  if (o === void 0 || i === void 0)
+    throw new Error("SampleFormat and BitsPerSample arrays cannot be empty.");
+  return {
+    sampleFormat: o,
+    bitsPerSample: i
+  };
+}
+function kn(e, { count: t }) {
+  if (e == null)
+    return null;
+  const o = new DOMParser().parseFromString(e, "text/xml").documentElement;
+  if (o.tagName !== "GDALMetadata")
+    throw new Error("Not a GDALMetadata XML block");
+  const i = /* @__PURE__ */ new Map(), a = Array(t).fill(0), s = Array(t).fill(1), l = (c) => {
+    const d = parseInt(c, 10) + 1;
+    return i.has(d) || i.set(d, {
+      max: null,
+      min: null,
+      mean: null,
+      std: null,
+      validPercent: null
+    }), i.get(d);
+  };
+  for (const c of Array.from(o.querySelectorAll("Item"))) {
+    const d = c.getAttribute("name"), h = c.getAttribute("sample"), g = c.textContent ?? "";
+    if (h !== null)
+      switch (d) {
+        case "STATISTICS_MAXIMUM":
+          l(h).max = parseFloat(g);
+          break;
+        case "STATISTICS_MEAN":
+          l(h).mean = parseFloat(g);
+          break;
+        case "STATISTICS_MINIMUM":
+          l(h).min = parseFloat(g);
+          break;
+        case "STATISTICS_STDDEV":
+          l(h).std = parseFloat(g);
+          break;
+        case "STATISTICS_VALID_PERCENT":
+          l(h).validPercent = parseFloat(g);
+          break;
+        case "OFFSET":
+          a[parseInt(h, 10)] = parseFloat(g);
+          break;
+        case "SCALE":
+          s[parseInt(h, 10)] = parseFloat(g);
+          break;
+      }
+  }
+  return { bandStatistics: i, offsets: a, scales: s };
+}
+async function $n(e, t = {}) {
+  const { signal: n } = t, r = e.value(u.Compression);
+  if (r === null)
+    throw new Error("Compression tag should always exist.");
+  const [o, i, a, s, l, c, d, h, g, f, S, P, C] = await Promise.all([
+    e.fetch(u.BitsPerSample, { signal: n }),
+    e.fetch(u.ColorMap, { signal: n }),
+    e.fetch(u.GdalNoData, { signal: n }),
+    e.fetch(u.GdalMetadata, { signal: n }),
+    e.fetch(u.LercParameters, { signal: n }),
+    e.fetch(u.ModelPixelScale, { signal: n }),
+    e.fetch(u.ModelTiePoint, { signal: n }),
+    e.fetch(u.ModelTransformation, { signal: n }),
+    e.fetch(u.Photometric, { signal: n }),
+    e.fetch(u.PlanarConfiguration, { signal: n }),
+    e.fetch(u.Predictor, { signal: n }),
+    e.fetch(u.SampleFormat, { signal: n }),
+    e.fetch(u.SamplesPerPixel, { signal: n })
+  ]), j = (b) => {
+    throw new Error(`${b} tag should always exist.`);
+  };
+  return o === null && j("BitsPerSample"), C === null && j("SamplesPerPixel"), g === null && j("Photometric"), {
+    bitsPerSample: new Uint16Array(o),
+    colorMap: i ? new Uint16Array(i) : void 0,
+    compression: r,
+    gdalMetadata: s,
+    lercParameters: l,
+    modelTiepoint: d,
+    modelPixelScale: c,
+    modelTransformation: h,
+    nodata: a !== null ? Number(a) : null,
+    photometric: g,
+    // PlanarConfiguration defaults to interleaved/chunky/contig
+    // https://web.archive.org/web/20240329145253/https://www.awaresystems.be/imaging/tiff/tifftags/planarconfiguration.html
+    planarConfiguration: f ?? U.Contig,
+    predictor: S ?? _.None,
+    // Uint is the default sample format according to the spec
+    // https://web.archive.org/web/20240329145340/https://www.awaresystems.be/imaging/tiff/tifftags/sampleformat.html
+    sampleFormat: P ?? [F.Uint],
+    samplesPerPixel: C
+  };
+}
+function Wn(e) {
+  const t = (n) => e.valueGeo(n) ?? null;
+  return {
+    // Configuration keys
+    modelType: t(p.GTModelTypeGeoKey),
+    rasterType: t(p.GTRasterTypeGeoKey),
+    citation: t(p.GTCitationGeoKey),
+    // Geographic CRS keys
+    geodeticCRS: t(p.GeodeticCRSGeoKey),
+    geodeticCitation: t(p.GeodeticCitationGeoKey),
+    geodeticDatum: t(p.GeodeticDatumGeoKey),
+    primeMeridian: t(p.PrimeMeridianGeoKey),
+    linearUnits: t(p.GeogLinearUnitsGeoKey),
+    linearUnitSize: t(p.GeogLinearUnitSizeGeoKey),
+    angularUnits: t(p.GeogAngularUnitsGeoKey),
+    angularUnitSize: t(p.GeogAngularUnitSizeGeoKey),
+    ellipsoid: t(p.EllipsoidGeoKey),
+    ellipsoidSemiMajorAxis: t(p.EllipsoidSemiMajorAxisGeoKey),
+    ellipsoidSemiMinorAxis: t(p.EllipsoidSemiMinorAxisGeoKey),
+    ellipsoidInvFlattening: t(p.EllipsoidInvFlatteningGeoKey),
+    azimuthUnits: t(p.GeogAzimuthUnitsGeoKey),
+    primeMeridianLongitude: t(p.PrimeMeridianLongitudeGeoKey),
+    toWGS84: t(p.GeogTOWGS84GeoKey),
+    // Projected CRS keys
+    projectedCRS: t(p.ProjectedCRSGeoKey),
+    projectedCitation: t(p.ProjectedCitationGeoKey),
+    projection: t(p.ProjectionGeoKey),
+    projMethod: t(p.ProjMethodGeoKey),
+    projLinearUnits: t(p.ProjLinearUnitsGeoKey),
+    projLinearUnitSize: t(p.ProjLinearUnitSizeGeoKey),
+    projStdParallel1: t(p.ProjStdParallel1GeoKey),
+    projStdParallel2: t(p.ProjStdParallel2GeoKey),
+    projNatOriginLong: t(p.ProjNatOriginLongGeoKey),
+    projNatOriginLat: t(p.ProjNatOriginLatGeoKey),
+    projFalseEasting: t(p.ProjFalseEastingGeoKey),
+    projFalseNorthing: t(p.ProjFalseNorthingGeoKey),
+    projFalseOriginLong: t(p.ProjFalseOriginLongGeoKey),
+    projFalseOriginLat: t(p.ProjFalseOriginLatGeoKey),
+    projFalseOriginEasting: t(p.ProjFalseOriginEastingGeoKey),
+    projFalseOriginNorthing: t(p.ProjFalseOriginNorthingGeoKey),
+    projCenterLong: t(p.ProjCenterLongGeoKey),
+    projCenterLat: t(p.ProjCenterLatGeoKey),
+    projCenterEasting: t(p.ProjCenterEastingGeoKey),
+    projCenterNorthing: t(p.ProjCenterNorthingGeoKey),
+    projScaleAtNatOrigin: t(p.ProjScaleAtNatOriginGeoKey),
+    projScaleAtCenter: t(p.ProjScaleAtCenterGeoKey),
+    projAzimuthAngle: t(p.ProjAzimuthAngleGeoKey),
+    projStraightVertPoleLong: t(p.ProjStraightVertPoleLongGeoKey),
+    projRectifiedGridAngle: t(p.ProjRectifiedGridAngleGeoKey),
+    // Vertical CRS keys
+    verticalCRS: t(p.VerticalGeoKey),
+    verticalCitation: t(p.VerticalCitationGeoKey),
+    verticalDatum: t(p.VerticalDatumGeoKey),
+    verticalUnits: t(p.VerticalUnitsGeoKey)
+  };
+}
+function Jn({ modelTiepoint: e, modelPixelScale: t, modelTransformation: n, rasterType: r }) {
+  let o;
+  if (e && t)
+    o = Vn(e, t);
+  else if (n)
+    o = Hn(n);
+  else
+    throw new Error("The image does not have an affine transformation.");
+  return r === T.PixelIsPoint && (o = re(o, Ae(-0.5, -0.5))), o;
+}
+function Vn(e, t) {
+  const n = e[3], r = e[4], o = t[0], i = -t[1];
+  return [o, 0, n, 0, i, r];
+}
+function Hn(e) {
+  const t = e[3], n = e[7], r = e[1], o = e[4], i = e[0], a = e[5];
+  return [i, r, t, o, a, n];
+}
+function Qe(e, t, n, r = Math.floor) {
+  const o = nt(e.transform), [i, a] = Re(o, t, n);
+  return [r(a), r(i)];
+}
+function qe(e, t, n, r = "center") {
+  let o, i;
+  switch (r) {
+    case "center":
+      o = n + 0.5, i = t + 0.5;
+      break;
+    case "ul":
+      o = n, i = t;
+      break;
+    case "ur":
+      o = n + 1, i = t;
+      break;
+    case "ll":
+      o = n, i = t + 1;
+      break;
+    case "lr":
+      o = n + 1, i = t + 1;
+      break;
+  }
+  return Re(e.transform, o, i);
+}
+class Yn {
+  cachedTags;
+  /** The data source used for fetching tile data. */
+  dataSource;
+  /** A reference to the parent GeoTIFF object. */
+  geotiff;
+  /** The GeoKeyDirectory of the primary IFD. */
+  gkd;
+  /** The data IFD for this resolution level. */
+  image;
+  /** The IFD for the mask associated with this overview level, if any. */
+  maskImage = null;
+  constructor(t, n, r, o, i, a) {
+    this.geotiff = t, this.gkd = n, this.image = r, this.maskImage = o, this.cachedTags = i, this.dataSource = a;
+  }
+  /**
+   * The CRS parsed from the GeoKeyDirectory.
+   *
+   * Returns an EPSG code (number) for EPSG-coded CRSes, or a PROJJSON object
+   * for user-defined CRSes. The result is cached after the first access.
+   *
+   * See also {@link GeoTIFF.epsg} for the EPSG code directly from the TIFF tags.
+   */
+  get crs() {
+    return this.geotiff.crs;
+  }
+  /** Image height in pixels. */
+  get height() {
+    return this.image.size.height;
+  }
+  /** The no data value, or null if not set. */
+  get nodata() {
+    return this.geotiff.nodata;
+  }
+  /** Inherits the {@link GeoTIFF._debug} flag from the parent. */
+  get _debug() {
+    return this.geotiff._debug;
+  }
+  /** The number of tiles in the x and y directions */
+  get tileCount() {
+    return this.image.tileCount;
+  }
+  /** Tile height in pixels. */
+  get tileHeight() {
+    return this.image.tileSize.height;
+  }
+  /** Tile width in pixels. */
+  get tileWidth() {
+    return this.image.tileSize.width;
+  }
+  /**
+   * Return the dataset's georeferencing transformation matrix.
+   */
+  get transform() {
+    const t = this.geotiff.transform, n = this.geotiff.width / this.width, r = this.geotiff.height / this.height;
+    return re(t, rt(n, r));
+  }
+  /** Image width in pixels. */
+  get width() {
+    return this.image.size.width;
+  }
+  /** Fetch a single tile from the full-resolution image.
+   *
+   * @param x The tile column index (0-based).
+   * @param y The tile row index (0-based).
+   * @param options Optional parameters for fetching the tile.
+   * @param options.boundless Whether to clip tiles that are partially outside the image bounds. When `true`, no clipping is applied and edge tiles are returned at the full nominal tile size. Defaults to `true`.
+   * @param options.pool An optional {@link DecoderPool} for decoding the tile data. If not provided, a new decoder will be created for each tile.
+   * @param options.signal An optional {@link AbortSignal} to cancel the fetch request.
+   */
+  async fetchTile(t, n, r = {}) {
+    return await ke(this, t, n, r);
+  }
+  /**
+   * Fetch multiple tiles in parallel.
+   *
+   * A future implementation may coalesce contiguous byte ranges to reduce
+   * the number of HTTP requests.
+   *
+   * @param xy - Array of `[x, y]` tile coordinates.
+   * @param options - Optional parameters (same as {@link fetchTile}).
+   * @returns Array of {@link Tile} objects in the same order as `xy`.
+   *
+   * @see {@link fetchTile} for single-tile fetching.
+   */
+  async fetchTiles(t, n = {}) {
+    return await We(this, t, n);
+  }
+  // TiledMixin
+  // Transform mixin
+  /**
+   * Get the (row, col) pixel index containing the geographic coordinate (x, y).
+   *
+   * @param x          x coordinate in the CRS.
+   * @param y          y coordinate in the CRS.
+   * @param op         Rounding function applied to fractional pixel indices.
+   *                   Defaults to Math.floor.
+   * @returns          [row, col] pixel indices.
+   */
+  index(t, n, r = Math.floor) {
+    return Qe(this, t, n, r);
+  }
+  /**
+   * Get the geographic (x, y) coordinate of the pixel at (row, col).
+   *
+   * @param row        Pixel row.
+   * @param col        Pixel column.
+   * @param offset     Which part of the pixel to return.  Defaults to "center".
+   * @returns          [x, y] in the CRS.
+   */
+  xy(t, n, r = "center") {
+    return qe(this, t, n, r);
+  }
+}
+class D {
+  /**
+   * Reduced-resolution overview levels, sorted finest-to-coarsest.
+   *
+   * Does not include the full-resolution image — use {@link fetchTile} on the
+   * GeoTIFF instance itself for that.
+   */
+  overviews;
+  /** A cached CRS value. */
+  _crs;
+  /** Cached TIFF tags that are pre-fetched when opening the GeoTIFF. */
+  cachedTags;
+  /** The data source used for fetching tile data.
+   *
+   * This is typically the raw source (e.g. HTTP or memory) rather than a
+   * layered source with caching and chunking, to avoid unnecessary copying of
+   * tile data through cache layers.
+   */
+  dataSource;
+  /** The underlying Tiff instance. */
+  tiff;
+  /** The primary (full-resolution) TiffImage. */
+  image;
+  /** The mask IFD of the full-resolution GeoTIFF, if any. */
+  maskImage;
+  /** The GeoKeyDirectory of the primary IFD. */
+  gkd;
+  /** Parsed GDALMetadata tag, if present. */
+  gdalMetadata;
+  /**
+   * Internal: when true, log each `dataSource` fetch (image tile data and
+   * mask tile data) to the console with offset/length and a `data`/`mask`
+   * label. Enable via the `debug` option on {@link GeoTIFF.open} or
+   * {@link GeoTIFF.fromUrl}. Read by the tile-fetch path; not part of the
+   * public API surface.
+   *
+   * @internal
+   */
+  _debug;
+  constructor(t, n, r, o, i, a, s, l, c) {
+    this.tiff = t, this.image = n, this.maskImage = r, this.gkd = o, this.overviews = i, this.cachedTags = a, this.dataSource = s, this.gdalMetadata = l, this._debug = c;
+  }
+  /**
+   * Open a GeoTIFF from a @cogeotiff/core Source.
+   *
+   * This creates and initialises the underlying Tiff, then classifies IFDs.
+   *
+   * @param options.dataSource A source for fetching tile data. This is separate from the source used to construct the TIFF to allow for separate caching implementations.
+   * @param options.headerSource The source used to construct the TIFF. This is typically a layered source with caching and chunking, to optimise access to TIFF tags and IFDs. Callers who want to control the initial read size should compose a `SourceChunk` of the desired block size; cogeotiff's default `defaultReadSize` (16 KiB) gets padded up by the chunking layer anyway.
+   * @param options.signal An optional {@link AbortSignal} to cancel the header reads.
+   * @param options.debug When true, the returned GeoTIFF logs each tile/mask data fetch to the console. Off by default.
+   */
+  static async open(t) {
+    const { dataSource: n, headerSource: r, signal: o, debug: i } = t, a = await new B(r).init({ signal: o });
+    return a.options = void 0, D.fromTiff(a, n, { signal: o, debug: i });
+  }
+  /**
+   * Create a GeoTIFF from an already-initialised Tiff instance.
+   *
+   * All IFDs are walked; mask IFDs are matched to data IFDs by matching
+   * (width, height).  Overviews are sorted from finest to coarsest resolution.
+   *
+   * @param dataSource A source for fetching tile data. This is separate from the source used to construct the TIFF to allow for separate caching implementations.
+   * @param options.signal An optional {@link AbortSignal} to cancel header tag reads.
+   * @param options.debug When true, the returned GeoTIFF logs each tile/mask data fetch to the console.
+   */
+  static async fromTiff(t, n, r = {}) {
+    const { signal: o, debug: i = !1 } = r, a = t.images;
+    if (a.length === 0)
+      throw new Error("TIFF does not contain any IFDs");
+    await Promise.all(a.map((b) => b.init(!0, { signal: o })));
+    const s = a[0], l = Wn(s), c = /* @__PURE__ */ new Map(), d = /* @__PURE__ */ new Map();
+    for (let b = 1; b < a.length; b++) {
+      const G = a[b], R = G.size, I = `${R.width},${R.height}`;
+      Xn(G) ? d.set(I, G) : c.set(I, G);
+    }
+    const h = `${s.size.width},${s.size.height}`, g = d.get(h) ?? null, f = Array.from(c.entries());
+    f.sort((b, G) => {
+      const R = b[1].size, I = G[1].size;
+      return I.width * I.height - R.width * R.height;
+    });
+    const S = await $n(s, { signal: o }), P = kn(S.gdalMetadata, {
+      count: S.samplesPerPixel
+    }), C = new D(t, s, g, l, [], S, n, P, i), j = f.map(([b, G]) => {
+      const R = d.get(b) ?? null;
+      return new Yn(C, l, G, R, S, n);
+    });
+    return C.overviews = j, C;
+  }
+  /**
+   * Create a GeoTIFF from an ArrayBuffer containing the entire file.
+   *
+   * This is a convenience method that wraps the ArrayBuffer in a memory source
+   * and calls {@link GeoTIFF.open}. For large files, consider using
+   * {@link GeoTIFF.fromUrl} or {@link GeoTIFF.open} with a chunked HTTP source
+   * to avoid loading the entire file into memory at once.
+   *
+   * @param input The ArrayBuffer containing the GeoTIFF file data.
+   * @returns A Promise that resolves to a GeoTIFF instance.
+   */
+  static async fromArrayBuffer(t) {
+    const n = new ae("memory://input.tif", t);
+    return await D.open({
+      dataSource: n,
+      headerSource: n
+    });
+  }
+  /**
+   * Create a new GeoTIFF from a URL.
+   *
+   * Wraps the HTTP source with a fixed-size block-aligned LRU cache tuned for
+   * TIFF metadata. cogeotiff's lazy per-entry reads (for tile offsets, byte
+   * counts, and other tag values) are served by the block cache; adjacent
+   * entries within a single block hit one underlying request. Tile data reads
+   * bypass the cache and go straight to the raw HTTP source.
+   *
+   * @param url The URL of the GeoTIFF to open.
+   * @param options Optional parameters.
+   * @param options.chunkSize Bytes per chunk for the header cache. Defaults to 64 KiB (matches geotiff.js's BlockedSource).
+   * @param options.cacheSize Total cache size in bytes. Defaults to 8 MiB (~128 blocks at the default chunk size).
+   * @param options.signal An optional {@link AbortSignal} to cancel the header reads.
+   * @param options.debug When true, the returned GeoTIFF logs each tile/mask data fetch to the console with offset/length and a `data`/`mask` label. Off by default.
+   * @returns A Promise that resolves to a GeoTIFF instance.
+   */
+  static async fromUrl(t, { chunkSize: n = 64 * 1024, cacheSize: r = 8 * 1024 * 1024, signal: o, debug: i } = {}) {
+    const a = new k(t, {});
+    a.metadata = { size: Number.POSITIVE_INFINITY };
+    const s = new Bt(a, [
+      new kt({ size: n }),
+      new zt({ size: r })
+    ]);
+    return await D.open({
+      // Tile data reads bypass the header cache (raw source).
+      dataSource: a,
+      headerSource: s,
+      signal: o,
+      debug: i
+    });
+  }
+  // ── Properties from the primary image ─────────────────────────────────
+  /**
+   * The CRS parsed from the GeoKeyDirectory.
+   *
+   * Returns an EPSG code (number) for EPSG-coded CRSes, or a PROJJSON object
+   * for user-defined CRSes. The result is cached after the first access.
+   *
+   * See also {@link GeoTIFF.epsg} for the EPSG code directly from the TIFF tags.
+   */
+  get crs() {
+    return this._crs === void 0 && (this._crs = Cn(this.gkd)), this._crs;
+  }
+  /** Image width in pixels. */
+  get width() {
+    return this.image.size.width;
+  }
+  /** Image height in pixels. */
+  get height() {
+    return this.image.size.height;
+  }
+  /** The number of tiles in the x and y directions */
+  get tileCount() {
+    return this.image.tileCount;
+  }
+  /** Tile width in pixels. */
+  get tileWidth() {
+    return this.image.tileSize.width;
+  }
+  /** Tile height in pixels. */
+  get tileHeight() {
+    return this.image.tileSize.height;
+  }
+  /** The no data value, or null if not set. */
+  get nodata() {
+    return this.image.noData;
+  }
+  /** Whether the primary image is tiled. */
+  get isTiled() {
+    return this.image.isTiled();
+  }
+  /**
+   * The pre-existing statistics for each band, if available.
+   *
+   * Extracted from the GDALMetadata TIFF tag; never computed on demand.
+   * Keys are **1-based** band indices to match GDAL's convention.
+   *
+   * Returns `null` if no statistics are stored in the file.
+   */
+  get storedStats() {
+    const t = this.gdalMetadata?.bandStatistics;
+    return t && t.size > 0 ? t : null;
+  }
+  /**
+   * The offset for each band (0-indexed), defaulting to 0.
+   *
+   * Extracted from the GDALMetadata TIFF tag.
+   */
+  get offsets() {
+    return this.gdalMetadata?.offsets ?? Array(this.count).fill(0);
+  }
+  /**
+   * The scale for each band (0-indexed), defaulting to 1.
+   *
+   * Extracted from the GDALMetadata TIFF tag.
+   */
+  get scales() {
+    return this.gdalMetadata?.scales ?? Array(this.count).fill(1);
+  }
+  /** Number of bands (samples per pixel). */
+  get count() {
+    return this.image.value(u.SamplesPerPixel) ?? 1;
+  }
+  /** Bounding box [minX, minY, maxX, maxY] in the CRS. */
+  get bbox() {
+    return this.image.bbox;
+  }
+  /**
+   * Return the dataset's georeferencing transformation matrix.
+   */
+  get transform() {
+    const { modelPixelScale: t, modelTiepoint: n, modelTransformation: r } = this.cachedTags;
+    return Jn({
+      modelTiepoint: n,
+      modelPixelScale: t,
+      modelTransformation: r,
+      rasterType: this.gkd.rasterType
+    });
+  }
+  // Mixins
+  /** Fetch a single tile from the full-resolution image.
+   *
+   * @param x The tile column index (0-based).
+   * @param y The tile row index (0-based).
+   * @param options Optional parameters for fetching the tile.
+   * @param options.boundless Whether to clip tiles that are partially outside the image bounds. When `true`, no clipping is applied and edge tiles are returned at the full nominal tile size. Defaults to `true`.
+   * @param options.pool An optional {@link DecoderPool} for decoding the tile data. If not provided, a new decoder will be created for each tile.
+   * @param options.signal An optional {@link AbortSignal} to cancel the fetch request.
+   */
+  async fetchTile(t, n, r = {}) {
+    return await ke(this, t, n, r);
+  }
+  /**
+   * Fetch multiple tiles in parallel.
+   *
+   * A future implementation may coalesce contiguous byte ranges to reduce
+   * the number of HTTP requests.
+   *
+   * @param xy - Array of `[x, y]` tile coordinates.
+   * @param options - Optional parameters (same as {@link fetchTile}).
+   * @returns Array of {@link Tile} objects in the same order as `xy`.
+   *
+   * @see {@link fetchTile} for single-tile fetching.
+   */
+  async fetchTiles(t, n = {}) {
+    return await We(this, t, n);
+  }
+  // Transform mixin
+  /**
+   * Get the (row, col) pixel index containing the geographic coordinate (x, y).
+   *
+   * @param x          x coordinate in the CRS.
+   * @param y          y coordinate in the CRS.
+   * @param op         Rounding function applied to fractional pixel indices.
+   *                   Defaults to Math.floor.
+   * @returns          [row, col] pixel indices.
+   */
+  index(t, n, r = Math.floor) {
+    return Qe(this, t, n, r);
+  }
+  /**
+   * Get the geographic (x, y) coordinate of the pixel at (row, col).
+   *
+   * @param row        Pixel row.
+   * @param col        Pixel column.
+   * @param offset     Which part of the pixel to return.  Defaults to "center".
+   * @returns          [x, y] in the CRS.
+   */
+  xy(t, n, r = "center") {
+    return qe(this, t, n, r);
+  }
+}
+function Xn(e) {
+  const t = e.value(u.SubFileType), n = e.value(u.Photometric);
+  return t !== null && (t & J.Mask) !== 0 && n === E.Mask;
+}
+let Zn = class {
+  worker;
+  jobIdCounter = 0;
+  jobs = /* @__PURE__ */ new Map();
+  constructor(t) {
+    this.worker = t, this.worker.addEventListener("message", (n) => this.onMessage(n));
+  }
+  get jobCount() {
+    return this.jobs.size;
+  }
+  onMessage(t) {
+    const { jobId: n, error: r, pixels: o } = t.data, i = this.jobs.get(n);
+    this.jobs.delete(n), i && (r ? i.reject(new Error(r)) : i.resolve(o));
+  }
+  submitJob(t, n) {
+    const r = this.jobIdCounter++;
+    return new Promise((o, i) => {
+      this.jobs.set(r, { resolve: o, reject: i }), this.worker.postMessage({ ...t, jobId: r }, { transfer: n });
+    });
+  }
+  terminate() {
+    this.worker.terminate();
+  }
+};
+const Qn = typeof navigator < "u" ? navigator.hardwareConcurrency ?? 2 : 2;
+class ne {
+  workerWrappers;
+  constructor(t = {}) {
+    const { size: n = Qn, createWorker: r } = t;
+    if (this.workerWrappers = [], r && n > 0)
+      for (let o = 0; o < n; o++)
+        this.workerWrappers.push(new Zn(r()));
+  }
+  /** True when workers are available for off-main-thread decoding. */
+  get hasWorkers() {
+    return this.workerWrappers.length > 0;
+  }
+  /**
+   * Decode a compressed tile buffer.
+   *
+   * When workers are available, the compressed `bytes` buffer is transferred
+   * zero-copy to the least-loaded worker. The returned `DecodedPixels` typed
+   * array buffers are transferred back to the main thread.
+   *
+   * When no workers are available, decoding runs on the main thread via the
+   * normal `decode()` path.
+   */
+  async decode(t, n, r) {
+    if (!this.hasWorkers)
+      return ie(t, n, r);
+    const o = this.leastLoaded(), i = {
+      compression: n,
+      metadata: r,
+      buffer: t
+    };
+    return await o.submitJob(i, [t]);
+  }
+  /** Terminate all workers and release resources. */
+  destroy() {
+    for (const t of this.workerWrappers)
+      t.terminate();
+    this.workerWrappers.length = 0;
+  }
+  leastLoaded() {
+    let t = this.workerWrappers[0];
+    for (let n = 1; n < this.workerWrappers.length; n++)
+      this.workerWrappers[n].jobCount < t.jobCount && (t = this.workerWrappers[n]);
+    return t;
+  }
+}
+let H = null;
+function qn() {
+  return H !== null || (H = new ne({
+    createWorker: () => new Worker(new URL(
+      /* @vite-ignore */
+      "" + new URL("assets/worker-DtIrTJB7.js", import.meta.url).href,
+      import.meta.url
+    ), { type: "module" })
+  })), H;
+}
+function Tn(e) {
+  const { height: t, width: n } = e;
+  if (e.layout === "band-separate")
+    throw new Error("Band-separate images not yet implemented.");
+  if (e.data.length === t * n * 4)
+    return e;
+  if (e.data.length === t * n * 3) {
+    const r = e.data.length / 3 * 4, o = e.data instanceof Uint16Array, i = o ? new Uint16Array(r) : new Uint8ClampedArray(r), a = o ? 65535 : 255;
+    for (let s = 0; s < e.data.length / 3; ++s)
+      i[s * 4] = e.data[s * 3], i[s * 4 + 1] = e.data[s * 3 + 1], i[s * 4 + 2] = e.data[s * 3 + 2], i[s * 4 + 3] = a;
+    return {
+      ...e,
+      count: 4,
+      data: i
+    };
+  } else
+    throw new Error(`Unexpected number of channels in raster data: ${e.data.length / (t * n)}`);
+}
+async function er(e) {
+  return typeof e == "string" || e instanceof URL ? await D.fromUrl(e) : e instanceof ArrayBuffer ? await D.fromArrayBuffer(e) : e;
+}
+function tr(e, t) {
+  const [n, r, o, i] = e.bbox, a = [
+    t.forward([n, r]),
+    // bottom-left
+    t.forward([o, r]),
+    // bottom-right
+    t.forward([o, i]),
+    // top-right
+    t.forward([n, i])
+    // top-left
+  ], s = a.map((f) => f[0]), l = a.map((f) => f[1]), c = Math.min(...s), d = Math.min(...l), h = Math.max(...s), g = Math.max(...l);
+  return { west: c, south: d, east: h, north: g };
+}
+const nr = (
+  /* glsl */
+  `
+  vec3 black_zero_to_rgb(float value) {
+    return vec3(value, value, value);
+  }
+`
+), rr = {
+  name: "black-is-zero",
+  inject: {
+    "fs:#decl": nr,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = black_zero_to_rgb(color.r);
+    `
+    )
+  }
+}, or = (
+  /* glsl */
+  `
+  const vec3 D65 = vec3(
+      0.95047, // Xn
+      1.00000, // Yn
+      1.08883 // Zn
+  );
+
+  vec3 cielabToRgb(vec3 labTex) {
+    // labTex in [0,1] from RGB8 texture
+    float L = labTex.r * 255.0;
+    float a = (labTex.g - 0.5) * 255.0;
+    float b = (labTex.b - 0.5) * 255.0;
+
+    float y = (L + 16.0) / 116.0;
+    float x = (a / 500.0) + y;
+    float z = y - (b / 200.0);
+
+    vec3 xyz;
+    vec3 v = vec3(x, y, z);
+    vec3 v3 = v * v * v;
+
+    xyz = D65 * mix(
+      (v - 16.0 / 116.0) / 7.787,
+      v3,
+      step(0.008856, v3)
+    );
+
+    vec3 rgb = mat3(
+      3.2406, -1.5372, -0.4986,
+      -0.9689, 1.8758, 0.0415,
+      0.0557, -0.2040, 1.0570
+    ) * xyz;
+
+    // sRGB gamma
+    rgb = mix(
+      12.92 * rgb,
+      1.055 * pow(rgb, vec3(1.0 / 2.4)) - 0.055,
+      step(0.0031308, rgb)
+    );
+
+    return clamp(rgb, 0.0, 1.0);
+  }
+`
+), ir = {
+  name: "cielab-to-rgb",
+  inject: {
+    "fs:#decl": or,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = cielabToRgb(color);
+    `
+    )
+  }
+}, ar = (
+  /* glsl */
+  `
+  vec3 cmykToRgb(vec4 cmyk) {
+    // cmyk in [0.0, 1.0]
+    float invK = 1.0 - cmyk.a;
+
+    return vec3(
+        (1.0 - cmyk.r) * invK,
+        (1.0 - cmyk.g) * invK,
+        (1.0 - cmyk.b) * invK
+    );
+  }
+`
+), sr = {
+  name: "cmyk-to-rgb",
+  inject: {
+    "fs:#decl": ar,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = cmykToRgb(color);
+    `
+    )
+  }
+}, lr = (
+  /* glsl */
+  `
+  vec3 white_zero_to_rgb(float value) {
+    return vec3(1.0 - value, 1.0 - value, 1.0 - value);
+  }
+`
+), cr = {
+  name: "white-is-zero",
+  inject: {
+    "fs:#decl": lr,
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      color.rgb = white_zero_to_rgb(color.r);
+    `
+    )
+  }
+}, ur = {
+  name: "mask-texture",
+  inject: {
+    "fs:#decl": "uniform sampler2D maskTexture;",
+    "fs:DECKGL_FILTER_COLOR": (
+      /* glsl */
+      `
+      float maskValue = texture(maskTexture, geometry.uv).r;
+      if (maskValue == 0.0) {
+        discard;
+      }
+    `
+    )
+  },
+  getUniforms: (e) => ({
+    maskTexture: e.maskTexture
+  })
+};
+function dr(e, t, n) {
+  const r = hr(e), o = pr(t), i = gr(n), a = `${r}:${i}:${o}`, s = mr[a];
+  if (!s)
+    throw new Error(`Unsupported texture format for SamplesPerPixel=${e}, BitsPerSample=${t}, SampleFormat=${n}`);
+  return s;
+}
+function hr(e) {
+  if (e === 1 || e === 2 || e === 3 || e === 4)
+    return e;
+  throw new Error(`Unsupported SamplesPerPixel ${e}. Only 1, 2, 3, or 4 are supported.`);
+}
+function pr(e) {
+  const t = e[0];
+  for (let n = 1; n < e.length; n++)
+    if (e[n] !== t)
+      throw new Error(`Unsupported varying BitsPerSample ${e}. All samples must have the same bit width.`);
+  if (t !== 8 && t !== 16 && t !== 32)
+    throw new Error(`Unsupported BitsPerSample ${t}. Only 8, 16, or 32 are supported.`);
+  return t;
+}
+function gr(e) {
+  const t = e[0];
+  for (let n = 1; n < e.length; n++)
+    if (e[n] !== t)
+      throw new Error(`Unsupported varying SampleFormat ${e}. All samples must have the same format.`);
+  switch (t) {
+    case F.Uint:
+      return "unorm";
+    case F.Int:
+      return "sint";
+    case F.Float:
+      return "float";
+    default:
+      throw new Error(`Unsupported SampleFormat ${e}`);
+  }
+}
+const mr = {
+  // 1 byte per pixel
+  "1:sint:8": "r8sint",
+  "1:uint:8": "r8uint",
+  "1:unorm:8": "r8unorm",
+  // 2 bytes per pixel (one channel)
+  "1:float:16": "r16float",
+  "1:sint:16": "r16sint",
+  "1:uint:16": "r16uint",
+  "1:unorm:16": "r16unorm",
+  // 2 bytes per pixel (two channels)
+  "2:sint:8": "rg8sint",
+  "2:uint:8": "rg8uint",
+  "2:unorm:8": "rg8unorm",
+  // 4 bytes per pixel (one channel)
+  "1:float:32": "r32float",
+  "1:sint:32": "r32sint",
+  "1:uint:32": "r32uint",
+  // 4 bytes per pixel (two channels)
+  "2:float:16": "rg16float",
+  "2:sint:16": "rg16sint",
+  "2:uint:16": "rg16uint",
+  "2:unorm:16": "rg16unorm",
+  // 4 bytes per pixel (four channels)
+  "4:sint:8": "rgba8sint",
+  "4:uint:8": "rgba8uint",
+  "4:unorm:8": "rgba8unorm",
+  // 6 bytes per pixel (three channels)
+  // Note: this is supported on WebGL2 but not supported on WebGPU
+  // I expect actual switch to WebGPU to be quite a ways off still
+  "3:uint:16": "rgb16unorm-webgl",
+  // 8 bytes per pixel (two channels)
+  "2:float:32": "rg32float",
+  "2:sint:32": "rg32sint",
+  "2:uint:32": "rg32uint",
+  // 8 bytes per pixel (four channels)
+  "4:float:16": "rgba16float",
+  "4:sint:16": "rgba16sint",
+  "4:uint:16": "rgba16uint",
+  "4:unorm:16": "rgba16unorm",
+  // 12 bytes per pixel (three channels)
+  "3:float:32": "rgb32float-webgl",
+  // 16 bytes per pixel (four channels)
+  "4:float:32": "rgba32float",
+  "4:sint:32": "rgba32sint",
+  "4:uint:32": "rgba32uint"
+};
+function fr(e, t) {
+  const { sampleFormat: n } = e.cachedTags;
+  if (n === null)
+    throw new Error("SampleFormat tag is required to infer render pipeline");
+  switch (n[0]) {
+    // Unsigned integers
+    case F.Uint:
+      return yr(e, t);
+  }
+  throw new Error(`Inferring render pipeline for non-unsigned integers not yet supported. Found SampleFormat: ${n}`);
+}
+function yr(e, t) {
+  const { bitsPerSample: n, colorMap: r, photometric: o, sampleFormat: i, samplesPerPixel: a, nodata: s } = e.cachedTags, l = [
+    {
+      module: it,
+      props: {
+        textureName: (f) => f.texture
+      }
+    }
+  ];
+  if (s !== null) {
+    const f = 2 ** n[0] - 1, S = s / f;
+    l.push({
+      module: at,
+      props: { value: S }
+    });
+  }
+  e.maskImage !== null && l.push({
+    module: ur,
+    props: {
+      // TODO: how to handle if mask failed to load and is undefined here
+      maskTexture: (f) => f.mask
+    }
+  });
+  const c = wr({
+    count: a,
+    photometric: o,
+    device: t,
+    colorMap: r
+  });
+  c && l.push(c);
+  const d = o === E.Palette ? {
+    magFilter: "nearest",
+    minFilter: "nearest"
+  } : {
+    magFilter: "linear",
+    minFilter: "linear"
+  };
+  return { getTileData: async (f, S) => {
+    const { device: P, x: C, y: j, signal: b, pool: G } = S, R = await f.fetchTile(C, j, {
+      boundless: !1,
+      pool: G,
+      signal: b
+    });
+    let { array: I } = R;
+    const { width: se, height: le, mask: Z } = I;
+    let ce = a;
+    if (a === 3 && (I = Tn(I), ce = 4), I.layout === "band-separate")
+      throw new Error("Band-separate images not yet implemented.");
+    const et = dr(
+      // Add one sample for added alpha channel
+      ce,
+      n,
+      i
+    );
+    let ue = I.data.byteLength;
+    const tt = P.createTexture({
+      data: I.data,
+      format: et,
+      width: se,
+      height: le,
+      sampler: d
+    });
+    let de;
+    return Z !== null && (de = P.createTexture({
+      data: Z,
+      // Single-channel 8-bit texture for the mask
+      format: "r8unorm",
+      width: se,
+      height: le,
+      // Use nearest filtering for the mask to avoid interpolated edges/halos
+      sampler: {
+        minFilter: "nearest",
+        magFilter: "nearest"
+      }
+    }), ue += Z.byteLength), {
+      texture: tt,
+      mask: de,
+      byteLength: ue,
+      height: I.height,
+      width: I.width
+    };
+  }, renderTile: (f) => ({
+    renderPipeline: l.map((S, P) => Sr(S, f))
+  }) };
+}
+function wr({ count: e, colorMap: t, device: n, photometric: r }) {
+  if (e === 3 || e === 4)
+    return null;
+  switch (r) {
+    case E.MinIsWhite:
+      return {
+        module: cr
+      };
+    case E.MinIsBlack:
+      return {
+        module: rr
+      };
+    case E.Rgb:
+      return null;
+    case E.Palette: {
+      if (!t)
+        throw new Error("ColorMap is required for PhotometricInterpretation Palette");
+      const { data: o, width: i, height: a } = mt(t), s = n.createTexture({
+        dimension: "2d-array",
+        data: o,
+        format: "rgba8unorm",
+        width: i,
+        height: a,
+        depth: 1,
+        mipLevels: 1,
+        sampler: {
+          minFilter: "nearest",
+          magFilter: "nearest",
+          addressModeU: "clamp-to-edge",
+          addressModeV: "clamp-to-edge",
+          addressModeW: "clamp-to-edge"
+        }
+      });
+      return {
+        module: ot,
+        props: {
+          colormapTexture: s
+        }
+      };
+    }
+    // Not sure why cogeotiff calls this "Separated", but it means CMYK
+    case E.Separated:
+      return {
+        module: sr
+      };
+    case E.Ycbcr:
+      return null;
+    case E.Cielab:
+      return {
+        module: ir
+      };
+    default:
+      throw new Error(`Unsupported PhotometricInterpretation ${r}`);
+  }
+}
+function Sr(e, t) {
+  const { module: n, props: r } = e;
+  if (!r)
+    return { module: n };
+  const o = {};
+  for (const [i, a] of Object.entries(r)) {
+    const s = typeof a == "function" ? a(t) : a;
+    s !== void 0 && (o[i] = s);
+  }
+  return { module: n, props: o };
+}
+function Pr(e, t) {
+  const r = [
+    ...[...e.overviews].reverse(),
+    e
+  ].map((o) => new st({
+    affine: o.transform,
+    arrayWidth: o.width,
+    arrayHeight: o.height,
+    tileWidth: o.tileWidth,
+    tileHeight: o.tileHeight,
+    mpu: t.mpu
+  }));
+  return new lt({
+    levels: r,
+    projectTo3857: t.projectTo3857,
+    projectFrom3857: t.projectFrom3857,
+    projectTo4326: t.projectTo4326,
+    projectFrom4326: t.projectFrom4326
+  });
+}
+class Cr extends he {
+  static layerName = "COGLayer";
+  // COGLayer's getTileData signature differs from the base class's, so
+  // `DefaultProps<COGLayerProps>` is not assignable to
+  // `DefaultProps<RasterTileLayerProps>`. Cast to the base static-side type
+  // to keep inheritance happy. The only COG-specific default is
+  // `epsgResolver`; all behavior still flows from the base class.
+  static defaultProps = {
+    ...he.defaultProps,
+    epsgResolver: ct
+  };
+  initializeState() {
+    this.setState({});
+  }
+  updateState(t) {
+    super.updateState(t);
+    const { props: n, oldProps: r, changeFlags: o } = t;
+    (!!o.dataChanged || n.geotiff !== r.geotiff) && (this.clearState(), this._parseGeoTIFF());
+  }
+  clearState() {
+    this.setState({
+      geotiff: void 0,
+      tilesetDescriptor: void 0,
+      defaultGetTileData: void 0,
+      defaultRenderTile: void 0
+    });
+  }
+  async _parseGeoTIFF() {
+    const t = await er(this.props.geotiff), n = t.crs, r = typeof n == "number" ? await this.props.epsgResolver(n) : ut(n), o = pe(r, "EPSG:4326"), i = (P, C) => o.forward([P, C], !1), a = (P, C) => o.inverse([P, C], !1), s = pe(r, "EPSG:3857"), l = ht((P, C) => s.forward([P, C], !1), i), c = (P, C) => s.inverse([P, C], !1), d = r.units;
+    if (!d)
+      throw new Error("Source projection is missing 'units' property, cannot compute meters per unit");
+    const h = dt(d, {
+      semiMajorAxis: r.datum?.a ?? r.a
+    }), g = Pr(t, {
+      projectTo4326: i,
+      projectFrom4326: a,
+      projectTo3857: l,
+      projectFrom3857: c,
+      mpu: h
+    });
+    if (this.props.onGeoTIFFLoad) {
+      const P = tr(t, o);
+      this.props.onGeoTIFFLoad(t, {
+        projection: r,
+        geographicBounds: P
+      });
+    }
+    let f, S;
+    (!this.props.getTileData || !this.props.renderTile) && ({ getTileData: f, renderTile: S } = fr(t, this.context.device)), this.setState({
+      geotiff: t,
+      tilesetDescriptor: g,
+      defaultGetTileData: f,
+      defaultRenderTile: S
+    });
+  }
+  _tilesetDescriptor() {
+    return this.state.tilesetDescriptor;
+  }
+  /**
+   * Adapts the user-facing `(image, { x, y, ... }) => Promise<DataT>` signature
+   * into RasterTileLayer's `(tile, { signal, device }) => Promise<DataT>`.
+   */
+  _getTileDataCallback() {
+    const t = this.state.geotiff;
+    if (!t)
+      return;
+    const n = this.props.getTileData ?? this.state.defaultGetTileData;
+    return n ? async (o, i) => {
+      const { x: a, y: s, z: l } = o.index, c = l === t.overviews.length ? t : t.overviews[t.overviews.length - 1 - l];
+      return n(c, {
+        device: i.device,
+        x: a,
+        y: s,
+        signal: i.signal,
+        pool: this.props.pool ?? qn()
+      });
+    } : void 0;
+  }
+  _renderTileCallback() {
+    const t = this.props.renderTile ?? this.state.defaultRenderTile;
+    if (t)
+      return t;
+  }
+}
+const Te = `var j;
+(function(e) {
+  e[e.Big = 19789] = "Big", e[e.Little = 18761] = "Little";
+})(j || (j = {}));
+var F;
+(function(e) {
+  e[e.ReducedImage = 1] = "ReducedImage", e[e.Page = 2] = "Page", e[e.Mask = 4] = "Mask";
+})(F || (F = {}));
+var m;
+(function(e) {
+  e[e.TopLeft = 1] = "TopLeft", e[e.TopRight = 2] = "TopRight", e[e.BottomRight = 3] = "BottomRight", e[e.BottomLeft = 4] = "BottomLeft", e[e.LeftTop = 5] = "LeftTop", e[e.RightTOP = 6] = "RightTOP", e[e.RightBottom = 7] = "RightBottom", e[e.LeftBottom = 8] = "LeftBottom";
+})(m || (m = {}));
+var A;
+(function(e) {
+  e[e.PixelIsArea = 1] = "PixelIsArea", e[e.PixelIsPoint = 2] = "PixelIsPoint";
+})(A || (A = {}));
+var G;
+(function(e) {
+  e[e.Unknown = 0] = "Unknown", e[e.Projected = 1] = "Projected", e[e.Geographic = 2] = "Geographic", e[e.Geocentric = 3] = "Geocentric", e[e.UserDefined = 32767] = "UserDefined";
+})(G || (G = {}));
+var C;
+(function(e) {
+  e[e.Image = 1] = "Image", e[e.ReducedImage = 2] = "ReducedImage", e[e.Page = 3] = "Page";
+})(C || (C = {}));
+var t;
+(function(e) {
+  e[e.None = 1] = "None", e[e.Ccittrle = 2] = "Ccittrle", e[e.CcittT4 = 3] = "CcittT4", e[e.CcittT6 = 4] = "CcittT6", e[e.Lzw = 5] = "Lzw", e[e.Jpeg6 = 6] = "Jpeg6", e[e.Jpeg = 7] = "Jpeg", e[e.DeflateOther = 8] = "DeflateOther", e[e.T85 = 9] = "T85", e[e.T43 = 10] = "T43", e[e.Next = 32766] = "Next", e[e.Ccittrlew = 32771] = "Ccittrlew", e[e.PackBits = 32773] = "PackBits", e[e.ThunderScan = 32809] = "ThunderScan", e[e.It8ctpad = 32895] = "It8ctpad", e[e.It8lw = 32896] = "It8lw", e[e.It8mp = 32897] = "It8mp", e[e.It8bl = 32898] = "It8bl", e[e.PixarFilm = 32908] = "PixarFilm", e[e.PixarLog = 32909] = "PixarLog", e[e.Deflate = 32946] = "Deflate", e[e.Dcs = 32947] = "Dcs", e[e.Jbig = 34661] = "Jbig", e[e.SgiLog = 34676] = "SgiLog", e[e.SgiLog24 = 34677] = "SgiLog24", e[e.Jp2000 = 34712] = "Jp2000", e[e.Lerc = 34887] = "Lerc", e[e.Lzma = 34925] = "Lzma", e[e.Zstd = 5e4] = "Zstd", e[e.Webp = 50001] = "Webp", e[e.JpegXl = 50002] = "JpegXl", e[e.JpegXlDng17 = 52546] = "JpegXlDng17";
+})(t || (t = {}));
+var x;
+(function(e) {
+  e[e.Contig = 1] = "Contig", e[e.Separate = 2] = "Separate";
+})(x || (x = {}));
+var L;
+(function(e) {
+  e[e.None = 1] = "None", e[e.Horizontal = 2] = "Horizontal", e[e.FloatingPoint = 3] = "FloatingPoint";
+})(L || (L = {}));
+var R;
+(function(e) {
+  e[e.Uint = 1] = "Uint", e[e.Int = 2] = "Int", e[e.Float = 3] = "Float", e[e.Void = 4] = "Void", e[e.ComplexInt = 5] = "ComplexInt", e[e.ComplexFloat = 6] = "ComplexFloat";
+})(R || (R = {}));
+var N;
+(function(e) {
+  e[e.MinIsWhite = 0] = "MinIsWhite", e[e.MinIsBlack = 1] = "MinIsBlack", e[e.Rgb = 2] = "Rgb", e[e.Palette = 3] = "Palette", e[e.Mask = 4] = "Mask", e[e.Separated = 5] = "Separated", e[e.Ycbcr = 6] = "Ycbcr", e[e.Cielab = 8] = "Cielab", e[e.Icclab = 9] = "Icclab", e[e.Itulab = 10] = "Itulab", e[e.Cfa = 32803] = "Cfa", e[e.Logl = 32844] = "Logl", e[e.Logluv = 32845] = "Logluv";
+})(N || (N = {}));
+var s;
+(function(e) {
+  e[e.SubFileType = 254] = "SubFileType", e[e.OldSubFileType = 255] = "OldSubFileType", e[e.ImageWidth = 256] = "ImageWidth", e[e.ImageHeight = 257] = "ImageHeight", e[e.BitsPerSample = 258] = "BitsPerSample", e[e.SampleFormat = 339] = "SampleFormat", e[e.Compression = 259] = "Compression", e[e.Photometric = 262] = "Photometric", e[e.TileWidth = 322] = "TileWidth", e[e.TileHeight = 323] = "TileHeight", e[e.TileOffsets = 324] = "TileOffsets", e[e.TileByteCounts = 325] = "TileByteCounts", e[e.JpegTables = 347] = "JpegTables", e[e.StripOffsets = 273] = "StripOffsets", e[e.StripByteCounts = 279] = "StripByteCounts", e[e.GdalMetadata = 42112] = "GdalMetadata", e[e.GdalNoData = 42113] = "GdalNoData", e[e.ModelPixelScale = 33550] = "ModelPixelScale", e[e.ModelTiePoint = 33922] = "ModelTiePoint", e[e.ModelTransformation = 34264] = "ModelTransformation", e[e.GeoKeyDirectory = 34735] = "GeoKeyDirectory", e[e.GeoDoubleParams = 34736] = "GeoDoubleParams", e[e.GeoAsciiParams = 34737] = "GeoAsciiParams", e[e.LercParameters = 50674] = "LercParameters", e[e.PlanarConfiguration = 284] = "PlanarConfiguration", e[e.CellLength = 265] = "CellLength", e[e.CellWidth = 264] = "CellWidth", e[e.ColorMap = 320] = "ColorMap", e[e.Copyright = 33432] = "Copyright", e[e.DateTime = 306] = "DateTime", e[e.ExtraSamples = 338] = "ExtraSamples", e[e.FillOrder = 266] = "FillOrder", e[e.FreeByteCounts = 289] = "FreeByteCounts", e[e.FreeOffsets = 288] = "FreeOffsets", e[e.GrayResponseCurve = 291] = "GrayResponseCurve", e[e.GrayResponseUnit = 290] = "GrayResponseUnit", e[e.HostComputer = 316] = "HostComputer", e[e.ImageDescription = 270] = "ImageDescription", e[e.Make = 271] = "Make", e[e.MaxSampleValue = 281] = "MaxSampleValue", e[e.MinSampleValue = 280] = "MinSampleValue", e[e.Model = 272] = "Model", e[e.Orientation = 274] = "Orientation", e[e.ResolutionUnit = 296] = "ResolutionUnit", e[e.RowsPerStrip = 278] = "RowsPerStrip", e[e.SamplesPerPixel = 277] = "SamplesPerPixel", e[e.Software = 305] = "Software", e[e.Threshholding = 263] = "Threshholding", e[e.XResolution = 282] = "XResolution", e[e.YResolution = 283] = "YResolution", e[e.BadFaxLines = 326] = "BadFaxLines", e[e.CleanFaxData = 327] = "CleanFaxData", e[e.ClipPath = 343] = "ClipPath", e[e.ConsecutiveBadFaxLines = 328] = "ConsecutiveBadFaxLines", e[e.Decode = 433] = "Decode", e[e.DefaultImageColor = 434] = "DefaultImageColor", e[e.DocumentName = 269] = "DocumentName", e[e.DotRange = 336] = "DotRange", e[e.HalftoneHints = 321] = "HalftoneHints", e[e.Indexed = 346] = "Indexed", e[e.PageName = 285] = "PageName", e[e.PageNumber = 297] = "PageNumber", e[e.Predictor = 317] = "Predictor", e[e.PrimaryChromaticities = 319] = "PrimaryChromaticities", e[e.ReferenceBlackWhite = 532] = "ReferenceBlackWhite", e[e.SMinSampleValue = 340] = "SMinSampleValue", e[e.SMaxSampleValue = 341] = "SMaxSampleValue", e[e.StripRowCounts = 559] = "StripRowCounts", e[e.SubIFDs = 330] = "SubIFDs", e[e.T4Options = 292] = "T4Options", e[e.T6Options = 293] = "T6Options", e[e.TransferFunction = 301] = "TransferFunction", e[e.WhitePoint = 318] = "WhitePoint", e[e.XClipPathUnits = 344] = "XClipPathUnits", e[e.XPosition = 286] = "XPosition", e[e.YCbCrCoefficients = 529] = "YCbCrCoefficients", e[e.YCbCrPositioning = 531] = "YCbCrPositioning", e[e.YCbCrSubSampling = 530] = "YCbCrSubSampling", e[e.YClipPathUnits = 345] = "YClipPathUnits", e[e.YPosition = 287] = "YPosition", e[e.ApertureValue = 37378] = "ApertureValue", e[e.ColorSpace = 40961] = "ColorSpace", e[e.DateTimeDigitized = 36868] = "DateTimeDigitized", e[e.DateTimeOriginal = 36867] = "DateTimeOriginal", e[e.ExifIFD = 34665] = "ExifIFD", e[e.ExifVersion = 36864] = "ExifVersion", e[e.ExposureTime = 33434] = "ExposureTime", e[e.FileSource = 41728] = "FileSource", e[e.Flash = 37385] = "Flash", e[e.FlashpixVersion = 40960] = "FlashpixVersion", e[e.FNumber = 33437] = "FNumber", e[e.ImageUniqueID = 42016] = "ImageUniqueID", e[e.LightSource = 37384] = "LightSource", e[e.MakerNote = 37500] = "MakerNote", e[e.ShutterSpeedValue = 37377] = "ShutterSpeedValue", e[e.UserComment = 37510] = "UserComment", e[e.IPTC = 33723] = "IPTC", e[e.ICCProfile = 34675] = "ICCProfile", e[e.XMP = 700] = "XMP";
+})(s || (s = {}));
+var v;
+(function(e) {
+  e[e.GTModelTypeGeoKey = 1024] = "GTModelTypeGeoKey", e[e.GTRasterTypeGeoKey = 1025] = "GTRasterTypeGeoKey", e[e.GTCitationGeoKey = 1026] = "GTCitationGeoKey", e[e.GeodeticCRSGeoKey = 2048] = "GeodeticCRSGeoKey", e[e.GeodeticCitationGeoKey = 2049] = "GeodeticCitationGeoKey", e[e.GeodeticDatumGeoKey = 2050] = "GeodeticDatumGeoKey", e[e.PrimeMeridianGeoKey = 2051] = "PrimeMeridianGeoKey", e[e.GeogLinearUnitsGeoKey = 2052] = "GeogLinearUnitsGeoKey", e[e.GeogLinearUnitSizeGeoKey = 2053] = "GeogLinearUnitSizeGeoKey", e[e.GeogAngularUnitsGeoKey = 2054] = "GeogAngularUnitsGeoKey", e[e.GeogAngularUnitSizeGeoKey = 2055] = "GeogAngularUnitSizeGeoKey", e[e.EllipsoidGeoKey = 2056] = "EllipsoidGeoKey", e[e.EllipsoidSemiMajorAxisGeoKey = 2057] = "EllipsoidSemiMajorAxisGeoKey", e[e.EllipsoidSemiMinorAxisGeoKey = 2058] = "EllipsoidSemiMinorAxisGeoKey", e[e.EllipsoidInvFlatteningGeoKey = 2059] = "EllipsoidInvFlatteningGeoKey", e[e.PrimeMeridianLongitudeGeoKey = 2061] = "PrimeMeridianLongitudeGeoKey", e[e.GeogTOWGS84GeoKey = 2062] = "GeogTOWGS84GeoKey", e[e.GeogAzimuthUnitsGeoKey = 2060] = "GeogAzimuthUnitsGeoKey", e[e.ProjectedCRSGeoKey = 3072] = "ProjectedCRSGeoKey", e[e.ProjectedCitationGeoKey = 3073] = "ProjectedCitationGeoKey", e[e.ProjectionGeoKey = 3074] = "ProjectionGeoKey", e[e.ProjMethodGeoKey = 3075] = "ProjMethodGeoKey", e[e.ProjLinearUnitsGeoKey = 3076] = "ProjLinearUnitsGeoKey", e[e.ProjLinearUnitSizeGeoKey = 3077] = "ProjLinearUnitSizeGeoKey", e[e.ProjStdParallel1GeoKey = 3078] = "ProjStdParallel1GeoKey", e[e.ProjStdParallel2GeoKey = 3079] = "ProjStdParallel2GeoKey", e[e.ProjNatOriginLongGeoKey = 3080] = "ProjNatOriginLongGeoKey", e[e.ProjNatOriginLatGeoKey = 3081] = "ProjNatOriginLatGeoKey", e[e.ProjFalseEastingGeoKey = 3082] = "ProjFalseEastingGeoKey", e[e.ProjFalseNorthingGeoKey = 3083] = "ProjFalseNorthingGeoKey", e[e.ProjFalseOriginLongGeoKey = 3084] = "ProjFalseOriginLongGeoKey", e[e.ProjFalseOriginLatGeoKey = 3085] = "ProjFalseOriginLatGeoKey", e[e.ProjFalseOriginEastingGeoKey = 3086] = "ProjFalseOriginEastingGeoKey", e[e.ProjFalseOriginNorthingGeoKey = 3087] = "ProjFalseOriginNorthingGeoKey", e[e.ProjCenterLongGeoKey = 3088] = "ProjCenterLongGeoKey", e[e.ProjCenterLatGeoKey = 3089] = "ProjCenterLatGeoKey", e[e.ProjCenterEastingGeoKey = 3090] = "ProjCenterEastingGeoKey", e[e.ProjCenterNorthingGeoKey = 3091] = "ProjCenterNorthingGeoKey", e[e.ProjScaleAtNatOriginGeoKey = 3092] = "ProjScaleAtNatOriginGeoKey", e[e.ProjScaleAtCenterGeoKey = 3093] = "ProjScaleAtCenterGeoKey", e[e.ProjAzimuthAngleGeoKey = 3094] = "ProjAzimuthAngleGeoKey", e[e.ProjStraightVertPoleLongGeoKey = 3095] = "ProjStraightVertPoleLongGeoKey", e[e.ProjRectifiedGridAngleGeoKey = 3096] = "ProjRectifiedGridAngleGeoKey", e[e.VerticalGeoKey = 4096] = "VerticalGeoKey", e[e.VerticalCitationGeoKey = 4097] = "VerticalCitationGeoKey", e[e.VerticalDatumGeoKey = 4098] = "VerticalDatumGeoKey", e[e.VerticalUnitsGeoKey = 4099] = "VerticalUnitsGeoKey";
+})(v || (v = {}));
+var B;
+(function(e) {
+  e[e.Radian = 9101] = "Radian", e[e.Degree = 9102] = "Degree", e[e.ArcMinute = 9103] = "ArcMinute", e[e.ArcDegree = 9104] = "ArcDegree", e[e.Grad = 9105] = "Grad", e[e.Gon = 9106] = "Gon", e[e.Dms = 9107] = "Dms";
+})(B || (B = {}));
+var M;
+(function(e) {
+  e[e.Metre = 9001] = "Metre", e[e.Foot = 9002] = "Foot", e[e.FootUsSurvey = 9003] = "FootUsSurvey", e[e.FootModifiedAmerican = 9004] = "FootModifiedAmerican", e[e.FootClarke = 9005] = "FootClarke", e[e.FootIndian = 9006] = "FootIndian", e[e.Link = 9007] = "Link", e[e.LinkBenoit = 9008] = "LinkBenoit", e[e.LinkSears = 9009] = "LinkSears", e[e.ChainBenoit = 9010] = "ChainBenoit", e[e.ChainSears = 9011] = "ChainSears", e[e.YardSears = 9012] = "YardSears", e[e.YardIndian = 9013] = "YardIndian", e[e.Fathom = 9014] = "Fathom", e[e.MileInternationalNautical = 9015] = "MileInternationalNautical";
+})(M || (M = {}));
+s.TileByteCounts + "", s.TileOffsets + "", s.StripOffsets + "", s.StripByteCounts + "", s.BitsPerSample + "", s.SampleFormat + "", s.GeoKeyDirectory + "", s.GeoDoubleParams + "";
+var r;
+(function(e) {
+  e.None = "application/octet-stream", e.Jbig = "image/jbig", e.Dcs = "image/x-kodak-dcs", e.PackBits = "application/packbits", e.Jpeg = "image/jpeg", e.Jp2000 = "image/jp2", e.JpegXl = "image/jpegxl", e.Webp = "image/webp", e.Zstd = "application/zstd", e.Lzw = "application/lzw", e.Deflate = "application/deflate", e.Lerc = "application/lerc", e.Lzma = "application/x-lzma";
+})(r || (r = {}));
+t.None + "", r.None, t.Lzw + "", r.Lzw, t.Jpeg6 + "", r.Jpeg, t.Jpeg + "", r.Jpeg, t.DeflateOther + "", r.Deflate, t.Deflate + "", r.Deflate, t.Lerc + "", r.Lerc, t.Lzma + "", r.Lzma, t.Jp2000 + "", r.Jp2000, t.Zstd + "", r.Zstd, t.Webp + "", r.Webp, t.JpegXl + "", r.JpegXl, t.Ccittrle + "", r.None, t.CcittT4 + "", r.None, t.CcittT6 + "", r.None, t.T85 + "", r.Jbig, t.T43 + "", r.Jbig, t.Next + "", r.None, t.Ccittrlew + "", r.None, t.PackBits + "", r.PackBits, t.ThunderScan + "", r.None, t.It8ctpad + "", r.None, t.It8lw + "", r.None, t.It8mp + "", r.None, t.It8bl + "", r.None, t.PixarFilm + "", r.None, t.PixarLog + "", r.None, t.Dcs + "", r.Dcs, t.Jbig + "", r.Jbig, t.SgiLog + "", r.None, t.SgiLog24 + "", r.None, t.JpegXlDng17 + "", r.JpegXl;
+var U;
+(function(e) {
+  e[e.Uint8 = 1] = "Uint8", e[e.Ascii = 2] = "Ascii", e[e.Uint16 = 3] = "Uint16", e[e.Uint32 = 4] = "Uint32", e[e.Rational = 5] = "Rational", e[e.Int8 = 6] = "Int8", e[e.Undefined = 7] = "Undefined", e[e.Int16 = 8] = "Int16", e[e.Int32 = 9] = "Int32", e[e.SignedRational = 10] = "SignedRational", e[e.Float32 = 11] = "Float32", e[e.Float64 = 12] = "Float64", e[e.Ifd = 13] = "Ifd", e[e.Uint64 = 16] = "Uint64", e[e.Int64 = 17] = "Int64", e[e.Ifd8 = 18] = "Ifd8";
+})(U || (U = {}));
+var w;
+(function(e) {
+  e[e.BigTiff = 43] = "BigTiff", e[e.Tiff = 42] = "Tiff";
+})(w || (w = {}));
+var E;
+(function(e) {
+  e[e.Double = 8] = "Double", e[e.Float32 = 4] = "Float32";
+})(E || (E = {}));
+var K;
+(function(e) {
+  e[e.UInt64 = 8] = "UInt64", e[e.UInt32 = 4] = "UInt32", e[e.UInt16 = 2] = "UInt16", e[e.UInt8 = 1] = "UInt8";
+})(K || (K = {}));
+const W = new ArrayBuffer(4), Y = new Uint32Array(W), X = new Uint8Array(W);
+Y[0] = 1;
+X[0];
+s.Compression, s.ImageHeight, s.ImageWidth, s.ModelPixelScale, s.ModelTiePoint, s.ModelTransformation, s.TileHeight, s.TileWidth;
+s.GeoKeyDirectory, s.GeoAsciiParams, s.GeoDoubleParams;
+var k;
+(function(e) {
+  e.GdalStructuralMetadataSize = "GDAL_STRUCTURAL_METADATA_SIZE", e.Layout = "LAYOUT", e.BlockOrder = "BLOCK_ORDER", e.BlockLeader = "BLOCK_LEADER", e.BlockTrailer = "BLOCK_TRAILER", e.KnownIncompatibleEdition = "KNOWN_INCOMPATIBLE_EDITION", e.MaskInterleavedWithImagery = "MASK_INTERLEAVED_WITH_IMAGERY";
+})(k || (k = {}));
+var J;
+(function(e) {
+  e.RowMajor = "ROW_MAJOR";
+})(J || (J = {}));
+var O;
+(function(e) {
+  e.uint32 = "SIZE_AS_UINT4";
+})(O || (O = {}));
+const H = {
+  version: w.Tiff,
+  pointer: K.UInt32,
+  offset: K.UInt16,
+  /**
+   * Each tag entry is specified as
+   * UInt16:TagCode
+   * UInt16:TagType
+   * UInt32:TagCount
+   * UInt32:Pointer To Value or value
+   */
+  ifd: K.UInt16 + K.UInt16 + 2 * K.UInt32
+}, _ = {
+  version: w.BigTiff,
+  /** Size of most pointers */
+  pointer: K.UInt64,
+  /** Size of offsets */
+  offset: K.UInt64,
+  /**
+   * Each tag entry is specified as
+   * UInt16:TagCode
+   * UInt16:TagType
+   * UInt64:TagCount
+   * UInt64:Pointer To Value or value
+   */
+  ifd: K.UInt16 + K.UInt16 + 2 * K.UInt64
+};
+w.BigTiff + "", w.Tiff + "";
+async function b(e, n) {
+  const l = new Blob([e]), o = await createImageBitmap(l), c = new OffscreenCanvas(o.width, o.height), d = c.getContext("2d");
+  d.drawImage(o, 0, 0), o.close();
+  const { width: P, height: a } = c, h = d.getImageData(0, 0, P, a).data, y = n.samplesPerPixel;
+  if (y === 4)
+    return { layout: "pixel-interleaved", data: h };
+  if (y === 3) {
+    const I = P * a, u = new Uint8ClampedArray(I * 3);
+    for (let p = 0, D = 0; p < u.length; p += 3, D += 4)
+      u[p] = h[D], u[p + 1] = h[D + 1], u[p + 2] = h[D + 2];
+    return { layout: "pixel-interleaved", data: u };
+  }
+  if (y === 1) {
+    const I = P * a, u = new Uint8ClampedArray(I);
+    for (let p = 0, D = 0; p < I; p++, D += 4)
+      u[p] = h[D];
+    return { layout: "pixel-interleaved", data: u };
+  }
+  throw new Error(\`Unsupported SamplesPerPixel for JPEG: \${y}\`);
+}
+function Z(e, n = "") {
+  if (!e)
+    throw new Error(n);
+}
+async function $(e, { format: n, signal: l }) {
+  const o = e instanceof Response ? e : new Response(e);
+  Z(o.body, "Response does not contain body.");
+  try {
+    return await new Response(o.body.pipeThrough(new DecompressionStream(n), { signal: l })).arrayBuffer();
+  } catch {
+    throw l?.throwIfAborted(), new Error(\`Failed to decode \${n}\`);
+  }
+}
+async function z(e) {
+  return $(e, { format: "deflate" });
+}
+function q(e, n) {
+  const l = e;
+  let o = 0, c = e.length - n;
+  do {
+    for (let d = n; d > 0; d--)
+      l[o + n] = (l[o + n] ?? 0) + (l[o] ?? 0), o++;
+    c -= n;
+  } while (c > 0);
+}
+function Q(e, n, l) {
+  let o = 0, c = e.length;
+  const d = c / l;
+  for (; c > n; ) {
+    for (let a = n; a > 0; a--)
+      e[o + n] += e[o], o++;
+    c -= n;
+  }
+  const P = e.slice();
+  for (let a = 0; a < d; a++)
+    for (let i = 0; i < l; i++)
+      e[l * a + i] = P[(l - i - 1) * d + a];
+}
+function V(e, n, l, o, c, d, P) {
+  if (n === L.None)
+    return e;
+  const a = c / 8, i = P === x.Separate ? 1 : d;
+  for (let h = 0; h < o; h++) {
+    const y = h * i * l * a;
+    if (y >= e.byteLength)
+      break;
+    if (n === L.Horizontal) {
+      let I;
+      const u = i * l;
+      switch (c) {
+        case 8:
+          I = new Uint8Array(e, y, u);
+          break;
+        case 16:
+          I = new Uint16Array(e, y, u);
+          break;
+        case 32:
+          I = new Uint32Array(e, y, u);
+          break;
+        default:
+          throw new Error(\`Predictor 2 not supported for \${c} bits per sample.\`);
+      }
+      q(I, i);
+    } else if (n === L.FloatingPoint) {
+      const I = new Uint8Array(e, y, i * l * a);
+      Q(I, i, a);
+    }
+  }
+  return e;
+}
+async function g(e) {
+  return e;
+}
+const S = /* @__PURE__ */ new Map();
+S.set(t.None, () => Promise.resolve(g));
+S.set(t.Deflate, () => Promise.resolve(z));
+S.set(t.DeflateOther, () => Promise.resolve(z));
+S.set(t.Lzw, () => import("./lzw-BY5a_5nb.js").then((e) => e.decode));
+S.set(t.Zstd, () => import("./zstd-QGAv3PMm.js").then((e) => e.decode));
+S.set(t.Jpeg, () => Promise.resolve(b));
+S.set(t.Jpeg6, () => Promise.resolve(b));
+S.set(t.Webp, () => Promise.resolve(b));
+S.set(t.Lerc, () => import("./__vite-browser-external-DDArsqdc.js").then(function(e) {
+  return e.l;
+}).then((e) => e.decode));
+async function f(e, n, l) {
+  const o = S.get(n);
+  if (!o)
+    throw new Error(\`Unsupported compression: \${n}\`);
+  const d = await (await o())(e, l);
+  if (d instanceof ArrayBuffer) {
+    const { predictor: P, width: a, height: i, bitsPerSample: h, samplesPerPixel: y, planarConfiguration: I } = l, u = V(d, P, a, i, h, y, I);
+    return {
+      layout: "pixel-interleaved",
+      data: ee(u, l)
+    };
+  }
+  return d;
+}
+function T(e, n) {
+  const l = new Uint8Array(e), o = new Uint8Array(n);
+  for (let c = 0; c < n; c++)
+    o[c] = l[c >> 3] >> 7 - (c & 7) & 1 ? 255 : 0;
+  return o;
+}
+function ee(e, n) {
+  const { sampleFormat: l, bitsPerSample: o } = n;
+  switch (l) {
+    case R.Uint:
+      switch (o) {
+        case 1:
+          return T(e, n.width * n.height * n.samplesPerPixel);
+        case 8:
+          return new Uint8Array(e);
+        case 16:
+          return new Uint16Array(e);
+        case 32:
+          return new Uint32Array(e);
+      }
+      break;
+    case R.Int:
+      switch (o) {
+        case 8:
+          return new Int8Array(e);
+        case 16:
+          return new Int16Array(e);
+        case 32:
+          return new Int32Array(e);
+      }
+      break;
+    case R.Float:
+      switch (o) {
+        case 32:
+          return new Float32Array(e);
+        case 64:
+          return new Float64Array(e);
+      }
+      break;
+  }
+  throw new Error(\`Unsupported sample format/depth: SampleFormat=\${l}, BitsPerSample=\${o}\`);
+}
+function te(e) {
+  return e.layout === "pixel-interleaved" ? [e.data.buffer] : e.bands.map((n) => n.buffer);
+}
+self.addEventListener("message", async (e) => {
+  const { jobId: n, compression: l, metadata: o, buffer: c } = e.data;
+  try {
+    const d = await f(c, l, o), P = te(d), a = { jobId: n, pixels: d };
+    self.postMessage(a, { transfer: P });
+  } catch (d) {
+    const P = { jobId: n, error: String(d) };
+    self.postMessage(P);
+  }
+});
+export {
+  t as C,
+  S as D
+};
+`, Fe = typeof self < "u" && self.Blob && new Blob(["URL.revokeObjectURL(import.meta.url);", Te], { type: "text/javascript;charset=utf-8" });
+function Lr(e) {
+  let t;
+  try {
+    if (t = Fe && (self.URL || self.webkitURL).createObjectURL(Fe), !t) throw "";
+    const n = new Worker(t, {
+      type: "module",
+      name: e?.name
+    });
+    return n.addEventListener("error", () => {
+      (self.URL || self.webkitURL).revokeObjectURL(t);
+    }), n;
+  } catch {
+    return new Worker(
+      "data:text/javascript;charset=utf-8," + encodeURIComponent(Te),
+      {
+        type: "module",
+        name: e?.name
+      }
+    );
+  }
+}
+function br(e) {
+  const t = e.layout === "band-separate" ? e.bands[0] : e.data;
+  return t instanceof Float32Array ? t : new Float32Array(t);
+}
+function Ir(e) {
+  const t = e.width * e.height, n = new Float32Array(t * 4);
+  if (e.layout === "band-separate") {
+    const [r, o, i] = [e.bands[0], e.bands[1], e.bands[2]];
+    for (let a = 0; a < t; a++)
+      n[a * 4] = r[a], n[a * 4 + 1] = o[a], n[a * 4 + 2] = i[a], n[a * 4 + 3] = 1;
+  } else {
+    const { data: r, count: o } = e;
+    for (let i = 0; i < t; i++)
+      n[i * 4] = r[i * o], n[i * 4 + 1] = r[i * o + 1], n[i * 4 + 2] = r[i * o + 2], n[i * 4 + 3] = 1;
+  }
+  return n;
+}
+const Gr = async (e, { device: t, x: n, y: r, signal: o, pool: i }) => {
+  const a = () => {
+    throw o?.reason ?? new DOMException("aborted", "AbortError");
+  };
+  o?.aborted && a();
+  const s = await e.fetchTile(n, r, { boundless: !1, pool: i, signal: o });
+  o?.aborted && a();
+  const l = s.array, c = e.cachedTags.samplesPerPixel, d = { minFilter: "nearest", magFilter: "nearest" }, h = c === 1, g = h ? br(l) : Ir(l), f = t.createTexture({
+    data: g,
+    format: h ? "r32float" : "rgba32float",
+    width: l.width,
+    height: l.height,
+    sampler: d
+  });
+  return {
+    width: l.width,
+    height: l.height,
+    byteLength: g.byteLength,
+    texture: f,
+    colormapTexture: await gt(t),
+    bandCount: c,
+    nodata: l.nodata
+  };
+};
+let W;
+function jr() {
+  if (W) return W;
+  try {
+    W = new ne({ createWorker: () => new Lr() });
+  } catch (e) {
+    console.warn("[onlymapjs] COGLayer: worker decode unavailable — falling back to main-thread decode.", e), W = new ne({});
+  }
+  return W;
+}
+class Er extends Cr {
+  static layerName = "OmCOGLayer";
+  // Plain nulls (not `{type:"number", value:null}` specs): deck's typed
+  // number props reject null defaults with a console warning per instance.
+  static defaultProps = {
+    rescaleMin: null,
+    rescaleMax: null,
+    colormap: null,
+    nodataOverride: null
+  };
+  constructor(t) {
+    const n = t, r = { ...t, pool: t.pool ?? jr() };
+    if (!(n.rescaleMin != null || n.rescaleMax != null || n.colormap != null && n.colormap !== "" || n.nodataOverride != null)) {
+      super(r);
+      return;
+    }
+    super(r, {
+      getTileData: Gr,
+      renderTile: (i) => i ? pt(i, n) : null,
+      // Free the per-tile texture on cache eviction; the sprite texture is
+      // device-scoped (WeakMap above) and must NOT be destroyed here.
+      onTileUnload: (i) => {
+        const a = i.data;
+        a && typeof a == "object" && "texture" in a && a.texture.destroy();
+      }
+    });
+  }
+}
+const vr = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  OmCOGLayer: Er
+}, Symbol.toStringTag, { value: "Module" }));
+export {
+  m as C,
+  A as D,
+  vr as r
+};