maplibre-gl-raster 0.14.5 → 0.14.7

package/dist/{RasterControl-BgzJWA7T.js → RasterControl-GAiOG6eI.js}

@@ -1,9 +1,9 @@
-import { a as Photometric, c as RasterTypeKey, d as TiffTag, f as TiffTagGeo, i as Compression, l as SampleFormat, n as decode$1, o as PlanarConfiguration, r as Tiff, s as Predictor, u as SubFileType } from "./decode-BL-qbDOV.js";
 import { MapboxOverlay } from "@deck.gl/mapbox";
 import { PathLayer, PolygonLayer, TextLayer } from "@deck.gl/layers";
 import { CompositeLayer, _GlobeViewport, assert } from "@deck.gl/core";
 import { SimpleMeshLayer } from "@deck.gl/mesh-layers";
 import { TileLayer, _Tileset2D } from "@deck.gl/geo-layers";
+import { GeoTIFF, defaultDecoderPool, parseColormap } from "@developmentseed/geotiff";
 import { Popup, addProtocol, removeProtocol } from "maplibre-gl";
 //#region node_modules/@developmentseed/proj/dist/meters-per-unit.js
 /**
@@ -1665,6 +1665,739 @@ var MaskTexture = {
 	}
 };
 //#endregion
+//#region node_modules/@cogeotiff/core/build/const/tiff.endian.js
+/**
+* Tiff format
+*
+* The header of a Tiff file contains the endianness of the file
+*/
+var TiffEndian;
+(function(TiffEndian) {
+	TiffEndian[TiffEndian["Big"] = 19789] = "Big";
+	TiffEndian[TiffEndian["Little"] = 18761] = "Little";
+})(TiffEndian || (TiffEndian = {}));
+//#endregion
+//#region node_modules/@cogeotiff/core/build/const/tiff.tag.id.js
+/** Sub file type for tag 254 {@link TiffTag.SubFileType} */
+var SubFileType;
+(function(SubFileType) {
+	/** Reduced resolution version */
+	SubFileType[SubFileType["ReducedImage"] = 1] = "ReducedImage";
+	/** One page of many */
+	SubFileType[SubFileType["Page"] = 2] = "Page";
+	/** Transparency mask */
+	SubFileType[SubFileType["Mask"] = 4] = "Mask";
+})(SubFileType || (SubFileType = {}));
+var Orientation;
+(function(Orientation) {
+	Orientation[Orientation["TopLeft"] = 1] = "TopLeft";
+	Orientation[Orientation["TopRight"] = 2] = "TopRight";
+	Orientation[Orientation["BottomRight"] = 3] = "BottomRight";
+	Orientation[Orientation["BottomLeft"] = 4] = "BottomLeft";
+	Orientation[Orientation["LeftTop"] = 5] = "LeftTop";
+	Orientation[Orientation["RightTOP"] = 6] = "RightTOP";
+	Orientation[Orientation["RightBottom"] = 7] = "RightBottom";
+	Orientation[Orientation["LeftBottom"] = 8] = "LeftBottom";
+})(Orientation || (Orientation = {}));
+var RasterTypeKey;
+(function(RasterTypeKey) {
+	/**
+	* PixelIsArea (default) a pixel is treated as an area,
+	* the raster coordinate (0,0) is the top left corner of the top left pixel.
+	*/
+	RasterTypeKey[RasterTypeKey["PixelIsArea"] = 1] = "PixelIsArea";
+	/**
+	* PixelIsPoint treats pixels as point samples with empty space between the "pixel" samples.
+	* the raster coordinate (0,0) is the location of the top left raster pixel.
+	*/
+	RasterTypeKey[RasterTypeKey["PixelIsPoint"] = 2] = "PixelIsPoint";
+})(RasterTypeKey || (RasterTypeKey = {}));
+var ModelTypeCode;
+(function(ModelTypeCode) {
+	ModelTypeCode[ModelTypeCode["Unknown"] = 0] = "Unknown";
+	/** Projection Coordinate System */
+	ModelTypeCode[ModelTypeCode["Projected"] = 1] = "Projected";
+	/** Geographic latitude-longitude System */
+	ModelTypeCode[ModelTypeCode["Geographic"] = 2] = "Geographic";
+	/** Geocentric (X,Y,Z) Coordinate System */
+	ModelTypeCode[ModelTypeCode["Geocentric"] = 3] = "Geocentric";
+	ModelTypeCode[ModelTypeCode["UserDefined"] = 32767] = "UserDefined";
+})(ModelTypeCode || (ModelTypeCode = {}));
+/** Sub file type for tag 255 {@link TiffTag.OldSubFileType} */
+var OldSubFileType;
+(function(OldSubFileType) {
+	/** Full resolution image data */
+	OldSubFileType[OldSubFileType["Image"] = 1] = "Image";
+	/** Reduced resolution version */
+	OldSubFileType[OldSubFileType["ReducedImage"] = 2] = "ReducedImage";
+	/** One page of many */
+	OldSubFileType[OldSubFileType["Page"] = 3] = "Page";
+})(OldSubFileType || (OldSubFileType = {}));
+/** Tiff compression types */
+var Compression;
+(function(Compression) {
+	Compression[Compression["None"] = 1] = "None";
+	Compression[Compression["Ccittrle"] = 2] = "Ccittrle";
+	Compression[Compression["CcittT4"] = 3] = "CcittT4";
+	Compression[Compression["CcittT6"] = 4] = "CcittT6";
+	Compression[Compression["Lzw"] = 5] = "Lzw";
+	Compression[Compression["Jpeg6"] = 6] = "Jpeg6";
+	Compression[Compression["Jpeg"] = 7] = "Jpeg";
+	Compression[Compression["DeflateOther"] = 8] = "DeflateOther";
+	Compression[Compression["T85"] = 9] = "T85";
+	Compression[Compression["T43"] = 10] = "T43";
+	Compression[Compression["Next"] = 32766] = "Next";
+	Compression[Compression["Ccittrlew"] = 32771] = "Ccittrlew";
+	Compression[Compression["PackBits"] = 32773] = "PackBits";
+	Compression[Compression["ThunderScan"] = 32809] = "ThunderScan";
+	Compression[Compression["It8ctpad"] = 32895] = "It8ctpad";
+	Compression[Compression["It8lw"] = 32896] = "It8lw";
+	Compression[Compression["It8mp"] = 32897] = "It8mp";
+	Compression[Compression["It8bl"] = 32898] = "It8bl";
+	Compression[Compression["PixarFilm"] = 32908] = "PixarFilm";
+	Compression[Compression["PixarLog"] = 32909] = "PixarLog";
+	Compression[Compression["Deflate"] = 32946] = "Deflate";
+	Compression[Compression["Dcs"] = 32947] = "Dcs";
+	Compression[Compression["Jbig"] = 34661] = "Jbig";
+	Compression[Compression["SgiLog"] = 34676] = "SgiLog";
+	Compression[Compression["SgiLog24"] = 34677] = "SgiLog24";
+	Compression[Compression["Jp2000"] = 34712] = "Jp2000";
+	Compression[Compression["Lerc"] = 34887] = "Lerc";
+	Compression[Compression["Lzma"] = 34925] = "Lzma";
+	Compression[Compression["Zstd"] = 5e4] = "Zstd";
+	Compression[Compression["Webp"] = 50001] = "Webp";
+	Compression[Compression["JpegXl"] = 50002] = "JpegXl";
+	Compression[Compression["JpegXlDng17"] = 52546] = "JpegXlDng17";
+})(Compression || (Compression = {}));
+var PlanarConfiguration;
+(function(PlanarConfiguration) {
+	/** single image plane */
+	PlanarConfiguration[PlanarConfiguration["Contig"] = 1] = "Contig";
+	/** separate planes of data */
+	PlanarConfiguration[PlanarConfiguration["Separate"] = 2] = "Separate";
+})(PlanarConfiguration || (PlanarConfiguration = {}));
+var Predictor;
+(function(Predictor) {
+	Predictor[Predictor["None"] = 1] = "None";
+	/** Horizontal differencing */
+	Predictor[Predictor["Horizontal"] = 2] = "Horizontal";
+	/** Floating point */
+	Predictor[Predictor["FloatingPoint"] = 3] = "FloatingPoint";
+})(Predictor || (Predictor = {}));
+var SampleFormat;
+(function(SampleFormat) {
+	/** Unsigned integer data */
+	SampleFormat[SampleFormat["Uint"] = 1] = "Uint";
+	/** Signed integer data */
+	SampleFormat[SampleFormat["Int"] = 2] = "Int";
+	/** IEEE floating point data */
+	SampleFormat[SampleFormat["Float"] = 3] = "Float";
+	/** Untyped data */
+	SampleFormat[SampleFormat["Void"] = 4] = "Void";
+	/** Complex signed int */
+	SampleFormat[SampleFormat["ComplexInt"] = 5] = "ComplexInt";
+	/** Complex ieee floating */
+	SampleFormat[SampleFormat["ComplexFloat"] = 6] = "ComplexFloat";
+})(SampleFormat || (SampleFormat = {}));
+var Photometric;
+(function(Photometric) {
+	/** min value is white */
+	Photometric[Photometric["MinIsWhite"] = 0] = "MinIsWhite";
+	/** min value is black */
+	Photometric[Photometric["MinIsBlack"] = 1] = "MinIsBlack";
+	/** RGB color model */
+	Photometric[Photometric["Rgb"] = 2] = "Rgb";
+	/** color map indexed */
+	Photometric[Photometric["Palette"] = 3] = "Palette";
+	/** $holdout mask */
+	Photometric[Photometric["Mask"] = 4] = "Mask";
+	/** !color separations */
+	Photometric[Photometric["Separated"] = 5] = "Separated";
+	/** !CCIR 601 */
+	Photometric[Photometric["Ycbcr"] = 6] = "Ycbcr";
+	/** !1976 CIE L*a*b* */
+	Photometric[Photometric["Cielab"] = 8] = "Cielab";
+	/** ICC L*a*b* [Adobe TIFF Technote 4] */
+	Photometric[Photometric["Icclab"] = 9] = "Icclab";
+	/** ITU L*a*b* */
+	Photometric[Photometric["Itulab"] = 10] = "Itulab";
+	/** color filter array */
+	Photometric[Photometric["Cfa"] = 32803] = "Cfa";
+	/** CIE Log2(L) */
+	Photometric[Photometric["Logl"] = 32844] = "Logl";
+	Photometric[Photometric["Logluv"] = 32845] = "Logluv";
+})(Photometric || (Photometric = {}));
+/**
+* Tiff tags as defined by libtiff and libgeotiff
+*
+* - {@link https://gitlab.com/libtiff/libtiff}
+* - {@link https://github.com/OSGeo/libgeotiff/}
+*/
+var TiffTag;
+(function(TiffTag) {
+	/**
+	* Type of the sub file
+	*
+	* @see {@link SubFileType}
+	*/
+	TiffTag[TiffTag["SubFileType"] = 254] = "SubFileType";
+	/**
+	* Type of sub file
+	*
+	* @see {@link OldSubFileType}
+	*/
+	TiffTag[TiffTag["OldSubFileType"] = 255] = "OldSubFileType";
+	/** Width of image in pixels */
+	TiffTag[TiffTag["ImageWidth"] = 256] = "ImageWidth";
+	/** Height of image in pixels */
+	TiffTag[TiffTag["ImageHeight"] = 257] = "ImageHeight";
+	/**
+	* Number of bits per channel
+	*
+	* @example
+	* ```typescript
+	* [8,8,8] // 8 bit RGB
+	* [16] // 16bit
+	* ```
+	*/
+	TiffTag[TiffTag["BitsPerSample"] = 258] = "BitsPerSample";
+	/**
+	*
+	* Data type of the image
+	*
+	* See {@link SampleFormat}
+	*
+	* @example
+	* ```typescript
+	* [1] // SampleFormat.Uint
+	* [1,1,1,1] // 4 band Uint
+	* ```
+	*/
+	TiffTag[TiffTag["SampleFormat"] = 339] = "SampleFormat";
+	/**
+	* Compression Type
+	*
+	* @see {@link Compression}
+	*
+	* @example
+	* ```typescript
+	* 5 // Compression.Lzw
+	* ```
+	*/
+	TiffTag[TiffTag["Compression"] = 259] = "Compression";
+	/**
+	* Photometric interpretation
+	*
+	* @see {@link Photometric}
+	*
+	* @example
+	* ```typescript
+	* 2 // Photometric.Rgb
+	* ```
+	*/
+	TiffTag[TiffTag["Photometric"] = 262] = "Photometric";
+	/** Tile width in pixels */
+	TiffTag[TiffTag["TileWidth"] = 322] = "TileWidth";
+	/** Tile height in pixels */
+	TiffTag[TiffTag["TileHeight"] = 323] = "TileHeight";
+	/**
+	* Offsets to data tiles
+	* `0` means the tile has no data (sparse tiff)
+	*
+	* @example
+	* ```typescript
+	* [0, 3200, 1406] // three tiles, first tile does not exist
+	* ```
+	*/
+	TiffTag[TiffTag["TileOffsets"] = 324] = "TileOffsets";
+	/**
+	*  Byte counts for tiles
+	*  `0 means the tile does not exist (sparse tiff)
+	*
+	* @example
+	* ```typescript
+	* [0, 3200, 1406] // three tiles, first tile does not exist
+	* ```
+	**/
+	TiffTag[TiffTag["TileByteCounts"] = 325] = "TileByteCounts";
+	/** JPEG table stream */
+	TiffTag[TiffTag["JpegTables"] = 347] = "JpegTables";
+	TiffTag[TiffTag["StripOffsets"] = 273] = "StripOffsets";
+	TiffTag[TiffTag["StripByteCounts"] = 279] = "StripByteCounts";
+	/**
+	* GDAL metadata
+	* Generally a xml document with lots of information about the tiff and how it was created
+	*/
+	TiffTag[TiffTag["GdalMetadata"] = 42112] = "GdalMetadata";
+	/**
+	* No data value encoded as a string
+	*
+	* @example "-9999"
+	*/
+	TiffTag[TiffTag["GdalNoData"] = 42113] = "GdalNoData";
+	/**  GeoTiff Tags */
+	/**
+	* Pixel scale in meters
+	* in the format [scaleX, scaleY, scaleZ]
+	*
+	* Requires {@link ModelTiePoint} to be set and {@link ModelTransformation} not to be set
+	*
+	* @example
+	* ```typescript
+	* [100.0, 100.0, 0.0]
+	* ```
+	*/
+	TiffTag[TiffTag["ModelPixelScale"] = 33550] = "ModelPixelScale";
+	/**
+	* Position of the tiff
+	*
+	* contains a list of tie points that contain
+	* [x,y,z] of position in the in the tiff, generally [0,0,0]
+	* [x,y,z] of the position in the projected
+	*
+	* @example
+	* Mapping tiff point `[0,0,0]` to projected coordinates `[350807.4, 5316081.3, 0.0]`
+	* ```
+	* [0, 0, 0, 350807.4, 5316081.3, 0.0]
+	* ```
+	*/
+	TiffTag[TiffTag["ModelTiePoint"] = 33922] = "ModelTiePoint";
+	/**
+	* Exact affine transformation between the tiff and the projected location
+	*
+	* this tag should not be defined when {@link ModelTiePoint} or {@link ModelPixelScale} are used
+	*
+	* @example
+	*```typescript
+	*   [ 0, 100.0, 0, 400000.0,
+	* 100.0,     0, 0, 500000.0,
+	*     0,     0, 0,        0,
+	*     0,     0, 0,        1]
+	* ```
+	*/
+	TiffTag[TiffTag["ModelTransformation"] = 34264] = "ModelTransformation";
+	/**
+	* List of GeoTiff tags
+	* {@link TiffTagGeo}
+	*
+	* {@link https://docs.ogc.org/is/19-008r4/19-008r4.html#_requirements_class_geokeydirectorytag}
+	*/
+	TiffTag[TiffTag["GeoKeyDirectory"] = 34735] = "GeoKeyDirectory";
+	/**
+	* Double Parameters for GeoTiff Tags
+	*
+	* {@link TiffTagGeo}
+	*/
+	TiffTag[TiffTag["GeoDoubleParams"] = 34736] = "GeoDoubleParams";
+	/**
+	* Ascii Parameters for GeoTiff Tags
+	*
+	* {@link TiffTagGeo}
+	*/
+	TiffTag[TiffTag["GeoAsciiParams"] = 34737] = "GeoAsciiParams";
+	/**
+	* Stores the LERC version and additional compression
+	*
+	* @example
+	* ```typescript
+	* [4, 0] // version 4, no extra compression
+	* ```
+	*/
+	TiffTag[TiffTag["LercParameters"] = 50674] = "LercParameters";
+	TiffTag[TiffTag["PlanarConfiguration"] = 284] = "PlanarConfiguration";
+	/** Untyped values */
+	TiffTag[TiffTag["CellLength"] = 265] = "CellLength";
+	TiffTag[TiffTag["CellWidth"] = 264] = "CellWidth";
+	TiffTag[TiffTag["ColorMap"] = 320] = "ColorMap";
+	TiffTag[TiffTag["Copyright"] = 33432] = "Copyright";
+	TiffTag[TiffTag["DateTime"] = 306] = "DateTime";
+	TiffTag[TiffTag["ExtraSamples"] = 338] = "ExtraSamples";
+	TiffTag[TiffTag["FillOrder"] = 266] = "FillOrder";
+	TiffTag[TiffTag["FreeByteCounts"] = 289] = "FreeByteCounts";
+	TiffTag[TiffTag["FreeOffsets"] = 288] = "FreeOffsets";
+	TiffTag[TiffTag["GrayResponseCurve"] = 291] = "GrayResponseCurve";
+	TiffTag[TiffTag["GrayResponseUnit"] = 290] = "GrayResponseUnit";
+	TiffTag[TiffTag["HostComputer"] = 316] = "HostComputer";
+	TiffTag[TiffTag["ImageDescription"] = 270] = "ImageDescription";
+	TiffTag[TiffTag["Make"] = 271] = "Make";
+	TiffTag[TiffTag["MaxSampleValue"] = 281] = "MaxSampleValue";
+	TiffTag[TiffTag["MinSampleValue"] = 280] = "MinSampleValue";
+	TiffTag[TiffTag["Model"] = 272] = "Model";
+	TiffTag[TiffTag["Orientation"] = 274] = "Orientation";
+	TiffTag[TiffTag["ResolutionUnit"] = 296] = "ResolutionUnit";
+	TiffTag[TiffTag["RowsPerStrip"] = 278] = "RowsPerStrip";
+	TiffTag[TiffTag["SamplesPerPixel"] = 277] = "SamplesPerPixel";
+	TiffTag[TiffTag["Software"] = 305] = "Software";
+	TiffTag[TiffTag["Threshholding"] = 263] = "Threshholding";
+	TiffTag[TiffTag["XResolution"] = 282] = "XResolution";
+	TiffTag[TiffTag["YResolution"] = 283] = "YResolution";
+	TiffTag[TiffTag["BadFaxLines"] = 326] = "BadFaxLines";
+	TiffTag[TiffTag["CleanFaxData"] = 327] = "CleanFaxData";
+	TiffTag[TiffTag["ClipPath"] = 343] = "ClipPath";
+	TiffTag[TiffTag["ConsecutiveBadFaxLines"] = 328] = "ConsecutiveBadFaxLines";
+	TiffTag[TiffTag["Decode"] = 433] = "Decode";
+	TiffTag[TiffTag["DefaultImageColor"] = 434] = "DefaultImageColor";
+	TiffTag[TiffTag["DocumentName"] = 269] = "DocumentName";
+	TiffTag[TiffTag["DotRange"] = 336] = "DotRange";
+	TiffTag[TiffTag["HalftoneHints"] = 321] = "HalftoneHints";
+	TiffTag[TiffTag["Indexed"] = 346] = "Indexed";
+	TiffTag[TiffTag["PageName"] = 285] = "PageName";
+	TiffTag[TiffTag["PageNumber"] = 297] = "PageNumber";
+	TiffTag[TiffTag["Predictor"] = 317] = "Predictor";
+	TiffTag[TiffTag["PrimaryChromaticities"] = 319] = "PrimaryChromaticities";
+	TiffTag[TiffTag["ReferenceBlackWhite"] = 532] = "ReferenceBlackWhite";
+	TiffTag[TiffTag["SMinSampleValue"] = 340] = "SMinSampleValue";
+	TiffTag[TiffTag["SMaxSampleValue"] = 341] = "SMaxSampleValue";
+	TiffTag[TiffTag["StripRowCounts"] = 559] = "StripRowCounts";
+	TiffTag[TiffTag["SubIFDs"] = 330] = "SubIFDs";
+	TiffTag[TiffTag["T4Options"] = 292] = "T4Options";
+	TiffTag[TiffTag["T6Options"] = 293] = "T6Options";
+	TiffTag[TiffTag["TransferFunction"] = 301] = "TransferFunction";
+	TiffTag[TiffTag["WhitePoint"] = 318] = "WhitePoint";
+	TiffTag[TiffTag["XClipPathUnits"] = 344] = "XClipPathUnits";
+	TiffTag[TiffTag["XPosition"] = 286] = "XPosition";
+	TiffTag[TiffTag["YCbCrCoefficients"] = 529] = "YCbCrCoefficients";
+	TiffTag[TiffTag["YCbCrPositioning"] = 531] = "YCbCrPositioning";
+	TiffTag[TiffTag["YCbCrSubSampling"] = 530] = "YCbCrSubSampling";
+	TiffTag[TiffTag["YClipPathUnits"] = 345] = "YClipPathUnits";
+	TiffTag[TiffTag["YPosition"] = 287] = "YPosition";
+	TiffTag[TiffTag["ApertureValue"] = 37378] = "ApertureValue";
+	TiffTag[TiffTag["ColorSpace"] = 40961] = "ColorSpace";
+	TiffTag[TiffTag["DateTimeDigitized"] = 36868] = "DateTimeDigitized";
+	TiffTag[TiffTag["DateTimeOriginal"] = 36867] = "DateTimeOriginal";
+	TiffTag[TiffTag["ExifIFD"] = 34665] = "ExifIFD";
+	TiffTag[TiffTag["ExifVersion"] = 36864] = "ExifVersion";
+	TiffTag[TiffTag["ExposureTime"] = 33434] = "ExposureTime";
+	TiffTag[TiffTag["FileSource"] = 41728] = "FileSource";
+	TiffTag[TiffTag["Flash"] = 37385] = "Flash";
+	TiffTag[TiffTag["FlashpixVersion"] = 40960] = "FlashpixVersion";
+	TiffTag[TiffTag["FNumber"] = 33437] = "FNumber";
+	TiffTag[TiffTag["ImageUniqueID"] = 42016] = "ImageUniqueID";
+	TiffTag[TiffTag["LightSource"] = 37384] = "LightSource";
+	TiffTag[TiffTag["MakerNote"] = 37500] = "MakerNote";
+	TiffTag[TiffTag["ShutterSpeedValue"] = 37377] = "ShutterSpeedValue";
+	TiffTag[TiffTag["UserComment"] = 37510] = "UserComment";
+	TiffTag[TiffTag["IPTC"] = 33723] = "IPTC";
+	TiffTag[TiffTag["ICCProfile"] = 34675] = "ICCProfile";
+	TiffTag[TiffTag["XMP"] = 700] = "XMP";
+})(TiffTag || (TiffTag = {}));
+/**
+* Geotiff tags as defined by OGC GeoTiff 1.1
+*
+* {@link https://docs.ogc.org/is/19-008r4/19-008r4.html#_summary_of_geokey_ids_and_names}
+*/
+var TiffTagGeo;
+(function(TiffTagGeo) {
+	/**
+	* This GeoKey defines the type of Model coordinate reference system used, to which the transformation from the raster space is made:
+	*
+	* {@link https://docs.ogc.org/is/19-008r4/19-008r4.html#_requirements_class_gtmodeltypegeokey}
+	*
+	* {@link ModelTypeCode}
+	*/
+	TiffTagGeo[TiffTagGeo["GTModelTypeGeoKey"] = 1024] = "GTModelTypeGeoKey";
+	/**
+	* There are currently only two options: `RasterPixelIsPoint` and `RasterPixelIsArea`
+	*
+	* {@link https://docs.ogc.org/is/19-008r4/19-008r4.html#_requirements_class_gtrastertypegeokey}
+	*
+	* {@link RasterTypeKey}
+	*/
+	TiffTagGeo[TiffTagGeo["GTRasterTypeGeoKey"] = 1025] = "GTRasterTypeGeoKey";
+	/**
+	* ASCII reference to published documentation on the overall configuration of the GeoTIFF file.
+	*
+	* @example "NZGD2000 / New Zealand Transverse Mercator 2000"
+	*/
+	TiffTagGeo[TiffTagGeo["GTCitationGeoKey"] = 1026] = "GTCitationGeoKey";
+	/**
+	* Renamed from GeographicTypeGeoKey in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["GeodeticCRSGeoKey"] = 2048] = "GeodeticCRSGeoKey";
+	/**
+	* Renamed from GeogCitationGeoKey in OGC GeoTiff
+	*
+	* @example "NZTM"
+	*/
+	TiffTagGeo[TiffTagGeo["GeodeticCitationGeoKey"] = 2049] = "GeodeticCitationGeoKey";
+	/**
+	* Renamed from GeogGeodeticDatumGeoKey in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["GeodeticDatumGeoKey"] = 2050] = "GeodeticDatumGeoKey";
+	/**
+	* Renamed from "GeogPrimeMeridianGeoKey" in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["PrimeMeridianGeoKey"] = 2051] = "PrimeMeridianGeoKey";
+	/**
+	* Linear unit of measure
+	* @example 9001 // Metre
+	*/
+	TiffTagGeo[TiffTagGeo["GeogLinearUnitsGeoKey"] = 2052] = "GeogLinearUnitsGeoKey";
+	TiffTagGeo[TiffTagGeo["GeogLinearUnitSizeGeoKey"] = 2053] = "GeogLinearUnitSizeGeoKey";
+	/**
+	* Angular unit of measure
+	*
+	* @example 9102 // Degree
+	*/
+	TiffTagGeo[TiffTagGeo["GeogAngularUnitsGeoKey"] = 2054] = "GeogAngularUnitsGeoKey";
+	TiffTagGeo[TiffTagGeo["GeogAngularUnitSizeGeoKey"] = 2055] = "GeogAngularUnitSizeGeoKey";
+	/**
+	* Renamed from "GeogEllipsoidGeoKey" in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["EllipsoidGeoKey"] = 2056] = "EllipsoidGeoKey";
+	/**
+	* Renamed from "GeogSemiMajorAxisGeoKey" in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["EllipsoidSemiMajorAxisGeoKey"] = 2057] = "EllipsoidSemiMajorAxisGeoKey";
+	/**
+	* Renamed from "GeogSemiMinorAxisGeoKey" in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["EllipsoidSemiMinorAxisGeoKey"] = 2058] = "EllipsoidSemiMinorAxisGeoKey";
+	/**
+	* Renamed from "GeogInvFlatteningGeoKey" in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["EllipsoidInvFlatteningGeoKey"] = 2059] = "EllipsoidInvFlatteningGeoKey";
+	/**
+	*  Renamed from "GeogPrimeMeridianLongGeoKey" in OGC GeoTiff
+	*/
+	TiffTagGeo[TiffTagGeo["PrimeMeridianLongitudeGeoKey"] = 2061] = "PrimeMeridianLongitudeGeoKey";
+	TiffTagGeo[TiffTagGeo["GeogTOWGS84GeoKey"] = 2062] = "GeogTOWGS84GeoKey";
+	TiffTagGeo[TiffTagGeo["GeogAzimuthUnitsGeoKey"] = 2060] = "GeogAzimuthUnitsGeoKey";
+	/**
+	* EPSG code of the tiff
+	*
+	* Renamed from "ProjectedCSTypeGeoKey" in OGC GeoTiff
+	*
+	* @example
+	* ```typescript
+	* 2193 // NZTM
+	* 3857 // WebMercatorQuad
+	* ```
+	*/
+	TiffTagGeo[TiffTagGeo["ProjectedCRSGeoKey"] = 3072] = "ProjectedCRSGeoKey";
+	/**
+	* ASCII reference to published documentation on the Projected  Coordinate System
+	*
+	* Renamed from "PCSCitationGeoKey" in OGC GeoTiff
+	*
+	* @example "UTM Zone 60 N with WGS 84"
+	*/
+	TiffTagGeo[TiffTagGeo["ProjectedCitationGeoKey"] = 3073] = "ProjectedCitationGeoKey";
+	/**
+	* Specifies a map projection from the GeoTIFF CRS register or to indicate that the map projection is user-defined.
+	*
+	* {@link https://docs.ogc.org/is/19-008r4/19-008r4.html#_map_projection_geokeys}
+	*
+	* @example 2193
+	*/
+	TiffTagGeo[TiffTagGeo["ProjectionGeoKey"] = 3074] = "ProjectionGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjMethodGeoKey"] = 3075] = "ProjMethodGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjLinearUnitsGeoKey"] = 3076] = "ProjLinearUnitsGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjLinearUnitSizeGeoKey"] = 3077] = "ProjLinearUnitSizeGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjStdParallel1GeoKey"] = 3078] = "ProjStdParallel1GeoKey";
+	TiffTagGeo[TiffTagGeo["ProjStdParallel2GeoKey"] = 3079] = "ProjStdParallel2GeoKey";
+	TiffTagGeo[TiffTagGeo["ProjNatOriginLongGeoKey"] = 3080] = "ProjNatOriginLongGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjNatOriginLatGeoKey"] = 3081] = "ProjNatOriginLatGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjFalseEastingGeoKey"] = 3082] = "ProjFalseEastingGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjFalseNorthingGeoKey"] = 3083] = "ProjFalseNorthingGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjFalseOriginLongGeoKey"] = 3084] = "ProjFalseOriginLongGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjFalseOriginLatGeoKey"] = 3085] = "ProjFalseOriginLatGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjFalseOriginEastingGeoKey"] = 3086] = "ProjFalseOriginEastingGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjFalseOriginNorthingGeoKey"] = 3087] = "ProjFalseOriginNorthingGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjCenterLongGeoKey"] = 3088] = "ProjCenterLongGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjCenterLatGeoKey"] = 3089] = "ProjCenterLatGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjCenterEastingGeoKey"] = 3090] = "ProjCenterEastingGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjCenterNorthingGeoKey"] = 3091] = "ProjCenterNorthingGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjScaleAtNatOriginGeoKey"] = 3092] = "ProjScaleAtNatOriginGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjScaleAtCenterGeoKey"] = 3093] = "ProjScaleAtCenterGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjAzimuthAngleGeoKey"] = 3094] = "ProjAzimuthAngleGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjStraightVertPoleLongGeoKey"] = 3095] = "ProjStraightVertPoleLongGeoKey";
+	TiffTagGeo[TiffTagGeo["ProjRectifiedGridAngleGeoKey"] = 3096] = "ProjRectifiedGridAngleGeoKey";
+	/**
+	* This key is provided to specify the vertical coordinate reference system from the GeoTIFF CRS register or to indicate that the CRS is a user-defined vertical coordinate reference system. The value for VerticalGeoKey should follow the
+	*
+	* {@link https://docs.ogc.org/is/19-008r4/19-008r4.html#_requirements_class_verticalgeokey}
+	*
+	* @example 4979
+	*/
+	TiffTagGeo[TiffTagGeo["VerticalGeoKey"] = 4096] = "VerticalGeoKey";
+	/**
+	*
+	* @example "Geographic 3D WGS 84, Ellipsoidal height"
+	*/
+	TiffTagGeo[TiffTagGeo["VerticalCitationGeoKey"] = 4097] = "VerticalCitationGeoKey";
+	/**
+	* vertical datum for a user-defined vertical coordinate reference system.
+	*/
+	TiffTagGeo[TiffTagGeo["VerticalDatumGeoKey"] = 4098] = "VerticalDatumGeoKey";
+	/**
+	* Linear Unit for vertical CRS
+	*
+	* @example 9001
+	*/
+	TiffTagGeo[TiffTagGeo["VerticalUnitsGeoKey"] = 4099] = "VerticalUnitsGeoKey";
+})(TiffTagGeo || (TiffTagGeo = {}));
+/**
+* EPSG Angular Units. exist between [9100,  9199]
+*
+* Taken from libgeotiff
+*/
+var AngularUnit;
+(function(AngularUnit) {
+	AngularUnit[AngularUnit["Radian"] = 9101] = "Radian";
+	AngularUnit[AngularUnit["Degree"] = 9102] = "Degree";
+	AngularUnit[AngularUnit["ArcMinute"] = 9103] = "ArcMinute";
+	AngularUnit[AngularUnit["ArcDegree"] = 9104] = "ArcDegree";
+	AngularUnit[AngularUnit["Grad"] = 9105] = "Grad";
+	AngularUnit[AngularUnit["Gon"] = 9106] = "Gon";
+	AngularUnit[AngularUnit["Dms"] = 9107] = "Dms";
+})(AngularUnit || (AngularUnit = {}));
+/**
+* ESPG Liner units exist between [9000,  9099]
+*
+* Taken from libgeotiff
+*/
+var LinearUnit;
+(function(LinearUnit) {
+	LinearUnit[LinearUnit["Metre"] = 9001] = "Metre";
+	LinearUnit[LinearUnit["Foot"] = 9002] = "Foot";
+	LinearUnit[LinearUnit["FootUsSurvey"] = 9003] = "FootUsSurvey";
+	LinearUnit[LinearUnit["FootModifiedAmerican"] = 9004] = "FootModifiedAmerican";
+	LinearUnit[LinearUnit["FootClarke"] = 9005] = "FootClarke";
+	LinearUnit[LinearUnit["FootIndian"] = 9006] = "FootIndian";
+	LinearUnit[LinearUnit["Link"] = 9007] = "Link";
+	LinearUnit[LinearUnit["LinkBenoit"] = 9008] = "LinkBenoit";
+	LinearUnit[LinearUnit["LinkSears"] = 9009] = "LinkSears";
+	LinearUnit[LinearUnit["ChainBenoit"] = 9010] = "ChainBenoit";
+	LinearUnit[LinearUnit["ChainSears"] = 9011] = "ChainSears";
+	LinearUnit[LinearUnit["YardSears"] = 9012] = "YardSears";
+	LinearUnit[LinearUnit["YardIndian"] = 9013] = "YardIndian";
+	LinearUnit[LinearUnit["Fathom"] = 9014] = "Fathom";
+	LinearUnit[LinearUnit["MileInternationalNautical"] = 9015] = "MileInternationalNautical";
+})(LinearUnit || (LinearUnit = {}));
+TiffTag.TileByteCounts, TiffTag.TileOffsets, TiffTag.StripOffsets, TiffTag.StripByteCounts, TiffTag.BitsPerSample, TiffTag.SampleFormat, TiffTag.GeoKeyDirectory, TiffTag.GeoDoubleParams;
+//#endregion
+//#region node_modules/@cogeotiff/core/build/const/tiff.mime.js
+/**
+* MimeType conversion for common tif image compresson types
+*/
+var TiffMimeType;
+(function(TiffMimeType) {
+	TiffMimeType["None"] = "application/octet-stream";
+	TiffMimeType["Jbig"] = "image/jbig";
+	TiffMimeType["Dcs"] = "image/x-kodak-dcs";
+	TiffMimeType["PackBits"] = "application/packbits";
+	TiffMimeType["Jpeg"] = "image/jpeg";
+	TiffMimeType["Jp2000"] = "image/jp2";
+	TiffMimeType["JpegXl"] = "image/jpegxl";
+	TiffMimeType["Webp"] = "image/webp";
+	TiffMimeType["Zstd"] = "application/zstd";
+	TiffMimeType["Lzw"] = "application/lzw";
+	TiffMimeType["Deflate"] = "application/deflate";
+	TiffMimeType["Lerc"] = "application/lerc";
+	TiffMimeType["Lzma"] = "application/x-lzma";
+})(TiffMimeType || (TiffMimeType = {}));
+Compression.None, TiffMimeType.None, Compression.Lzw, TiffMimeType.Lzw, Compression.Jpeg6, TiffMimeType.Jpeg, Compression.Jpeg, TiffMimeType.Jpeg, Compression.DeflateOther, TiffMimeType.Deflate, Compression.Deflate, TiffMimeType.Deflate, Compression.Lerc, TiffMimeType.Lerc, Compression.Lzma, TiffMimeType.Lzma, Compression.Jp2000, TiffMimeType.Jp2000, Compression.Zstd, TiffMimeType.Zstd, Compression.Webp, TiffMimeType.Webp, Compression.JpegXl, TiffMimeType.JpegXl, Compression.Ccittrle, TiffMimeType.None, Compression.CcittT4, TiffMimeType.None, Compression.CcittT6, TiffMimeType.None, Compression.T85, TiffMimeType.Jbig, Compression.T43, TiffMimeType.Jbig, Compression.Next, TiffMimeType.None, Compression.Ccittrlew, TiffMimeType.None, Compression.PackBits, TiffMimeType.PackBits, Compression.ThunderScan, TiffMimeType.None, Compression.It8ctpad, TiffMimeType.None, Compression.It8lw, TiffMimeType.None, Compression.It8mp, TiffMimeType.None, Compression.It8bl, TiffMimeType.None, Compression.PixarFilm, TiffMimeType.None, Compression.PixarLog, TiffMimeType.None, Compression.Dcs, TiffMimeType.Dcs, Compression.Jbig, TiffMimeType.Jbig, Compression.SgiLog, TiffMimeType.None, Compression.SgiLog24, TiffMimeType.None, Compression.JpegXlDng17, TiffMimeType.JpegXl;
+//#endregion
+//#region node_modules/@cogeotiff/core/build/const/tiff.tag.value.js
+var TiffTagValueType;
+(function(TiffTagValueType) {
+	TiffTagValueType[TiffTagValueType["Uint8"] = 1] = "Uint8";
+	TiffTagValueType[TiffTagValueType["Ascii"] = 2] = "Ascii";
+	TiffTagValueType[TiffTagValueType["Uint16"] = 3] = "Uint16";
+	TiffTagValueType[TiffTagValueType["Uint32"] = 4] = "Uint32";
+	TiffTagValueType[TiffTagValueType["Rational"] = 5] = "Rational";
+	TiffTagValueType[TiffTagValueType["Int8"] = 6] = "Int8";
+	TiffTagValueType[TiffTagValueType["Undefined"] = 7] = "Undefined";
+	TiffTagValueType[TiffTagValueType["Int16"] = 8] = "Int16";
+	TiffTagValueType[TiffTagValueType["Int32"] = 9] = "Int32";
+	TiffTagValueType[TiffTagValueType["SignedRational"] = 10] = "SignedRational";
+	TiffTagValueType[TiffTagValueType["Float32"] = 11] = "Float32";
+	TiffTagValueType[TiffTagValueType["Float64"] = 12] = "Float64";
+	TiffTagValueType[TiffTagValueType["Ifd"] = 13] = "Ifd";
+	TiffTagValueType[TiffTagValueType["Uint64"] = 16] = "Uint64";
+	TiffTagValueType[TiffTagValueType["Int64"] = 17] = "Int64";
+	TiffTagValueType[TiffTagValueType["Ifd8"] = 18] = "Ifd8";
+})(TiffTagValueType || (TiffTagValueType = {}));
+//#endregion
+//#region node_modules/@cogeotiff/core/build/const/tiff.version.js
+/**
+* Tif version number that is stored at the start of a tif file
+*/
+var TiffVersion;
+(function(TiffVersion) {
+	/**
+	* Big tif's,
+	* generally uses 64bit numbers for offsets
+	* @see http://bigtiff.org/
+	**/
+	TiffVersion[TiffVersion["BigTiff"] = 43] = "BigTiff";
+	/**
+	* Original tif
+	* Uses 32 bit or smaller numbers for offsets and counters
+	*/
+	TiffVersion[TiffVersion["Tiff"] = 42] = "Tiff";
+})(TiffVersion || (TiffVersion = {}));
+//#endregion
+//#region node_modules/@cogeotiff/core/build/util/bytes.js
+var ByteSizeFloat;
+(function(ByteSizeFloat) {
+	ByteSizeFloat[ByteSizeFloat["Double"] = 8] = "Double";
+	ByteSizeFloat[ByteSizeFloat["Float32"] = 4] = "Float32";
+})(ByteSizeFloat || (ByteSizeFloat = {}));
+var ByteSize;
+(function(ByteSize) {
+	ByteSize[ByteSize["UInt64"] = 8] = "UInt64";
+	ByteSize[ByteSize["UInt32"] = 4] = "UInt32";
+	ByteSize[ByteSize["UInt16"] = 2] = "UInt16";
+	ByteSize[ByteSize["UInt8"] = 1] = "UInt8";
+})(ByteSize || (ByteSize = {}));
+//#endregion
+//#region node_modules/@cogeotiff/core/build/read/endian.js
+var buffer = /* @__PURE__ */ new ArrayBuffer(4);
+var uint32 = new Uint32Array(buffer);
+var uint8 = new Uint8Array(buffer);
+uint32[0] = 1;
+uint8[0];
+new Set([
+	TiffTag.Compression,
+	TiffTag.ImageHeight,
+	TiffTag.ImageWidth,
+	TiffTag.ModelPixelScale,
+	TiffTag.ModelTiePoint,
+	TiffTag.ModelTransformation,
+	TiffTag.TileHeight,
+	TiffTag.TileWidth
+]);
+new Set([
+	TiffTag.GeoKeyDirectory,
+	TiffTag.GeoAsciiParams,
+	TiffTag.GeoDoubleParams
+]);
+//#endregion
+//#region node_modules/@cogeotiff/core/build/read/tiff.gdal.js
+var GhostOption;
+(function(GhostOption) {
+	GhostOption["GdalStructuralMetadataSize"] = "GDAL_STRUCTURAL_METADATA_SIZE";
+	GhostOption["Layout"] = "LAYOUT";
+	GhostOption["BlockOrder"] = "BLOCK_ORDER";
+	GhostOption["BlockLeader"] = "BLOCK_LEADER";
+	GhostOption["BlockTrailer"] = "BLOCK_TRAILER";
+	GhostOption["KnownIncompatibleEdition"] = "KNOWN_INCOMPATIBLE_EDITION";
+	GhostOption["MaskInterleavedWithImagery"] = "MASK_INTERLEAVED_WITH_IMAGERY";
+})(GhostOption || (GhostOption = {}));
+var GhostOptionTileOrder;
+(function(GhostOptionTileOrder) {
+	GhostOptionTileOrder["RowMajor"] = "ROW_MAJOR";
+})(GhostOptionTileOrder || (GhostOptionTileOrder = {}));
+var GhostOptionTileLeader;
+(function(GhostOptionTileLeader) {
+	GhostOptionTileLeader["uint32"] = "SIZE_AS_UINT4";
+})(GhostOptionTileLeader || (GhostOptionTileLeader = {}));
+TiffVersion.Tiff, ByteSize.UInt32, ByteSize.UInt16, ByteSize.UInt16 + ByteSize.UInt16 + 2 * ByteSize.UInt32;
+TiffVersion.BigTiff, ByteSize.UInt64, ByteSize.UInt64, ByteSize.UInt16 + ByteSize.UInt16 + 2 * ByteSize.UInt64;
+TiffVersion.BigTiff, TiffVersion.Tiff;
+//#endregion
 //#region src/lib/raster/stats.ts
 /**
 * Parse band descriptions from the GDAL_METADATA XML tag. Looks for
@@ -3881,28 +4614,6 @@ function translation(xoff, yoff) {
 	];
 }
 /**
-* Create a scaling transform from a scalar or vector.
-*
-* You can pass either one or two scaling factors. Passing only a single scalar
-* value will scale in both dimensions equally. A vector scaling value scales
-* the dimensions independently.
-*
-* @param sx  Scaling factor in x direction.
-* @param sy  Scaling factor in y direction (defaults to sx if not provided).
-*
-* @return Transform that applies the given scaling.
-*/
-function scale$3(sx, sy = sx) {
-	return [
-		sx,
-		0,
-		0,
-		0,
-		sy,
-		0
-	];
-}
-/**
 * Apply a geotransform to a coordinate.
 *
 * That is, we apply this series of equations:
@@ -8110,2175 +8821,99 @@ var RasterTileLayer = class extends CompositeLayer {
 	}
 };
 //#endregion
-//#region node_modules/@developmentseed/geotiff/dist/colormap.js
-/**
-* Parse the GeoTIFF `ColorMap` tag into an ImageData.
-*
-* @param cmap  The colormap array from the GeoTIFF `ColorMap` tag.
-* @param nodata  Optional index of the nodata value in the colormap.
-*
-* @return The parsed colormap as an ImageData object.
-*/
-function parseColormap(cmap, nodata) {
-	const size = cmap.length / 3;
-	const rgba = new Uint8ClampedArray(size * 4);
-	const rOffset = 0;
-	const gOffset = size;
-	const bOffset = size * 2;
-	for (let i = 0; i < size; i++) {
-		rgba[4 * i + 0] = cmap[rOffset + i] >> 8;
-		rgba[4 * i + 1] = cmap[gOffset + i] >> 8;
-		rgba[4 * i + 2] = cmap[bOffset + i] >> 8;
-		rgba[4 * i + 3] = 255;
+//#region node_modules/proj4/lib/global.js
+function global_default(defs) {
+	defs("EPSG:4326", "+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees");
+	defs("EPSG:4269", "+title=NAD83 (long/lat) +proj=longlat +a=6378137.0 +b=6356752.31414036 +ellps=GRS80 +datum=NAD83 +units=degrees");
+	defs("EPSG:3857", "+title=WGS 84 / Pseudo-Mercator +proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs");
+	for (var i = 1; i <= 60; ++i) {
+		defs("EPSG:" + (32600 + i), "+proj=utm +zone=" + i + " +datum=WGS84 +units=m");
+		defs("EPSG:" + (32700 + i), "+proj=utm +zone=" + i + " +south +datum=WGS84 +units=m");
 	}
-	if (nodata !== void 0) rgba[4 * nodata + 3] = 0;
-	return new ImageData(rgba, size, 1);
+	defs("EPSG:5041", "+title=WGS 84 / UPS North (E,N) +proj=stere +lat_0=90 +lon_0=0 +k=0.994 +x_0=2000000 +y_0=2000000 +datum=WGS84 +units=m");
+	defs("EPSG:5042", "+title=WGS 84 / UPS South (E,N) +proj=stere +lat_0=-90 +lon_0=0 +k=0.994 +x_0=2000000 +y_0=2000000 +datum=WGS84 +units=m");
+	defs.WGS84 = defs["EPSG:4326"];
+	defs["EPSG:3785"] = defs["EPSG:3857"];
+	defs.GOOGLE = defs["EPSG:3857"];
+	defs["EPSG:900913"] = defs["EPSG:3857"];
+	defs["EPSG:102113"] = defs["EPSG:3857"];
 }
 //#endregion
-//#region node_modules/@chunkd/middleware/build/src/middleware/cache.js
-var SourceCache = class {
-	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(opts) {
-		this.maxSize = opts.size;
-		this.protocols = new Set(opts.protocols ?? []);
-	}
-	fetch(req, next) {
-		if (this.protocols.size > 0 && !this.protocols.has(req.source.url.protocol)) return next(req);
-		if (req.length == null) return next(req);
-		const cacheKey = `${req.source.url.toString()}@${req.offset}+${req.length}`;
-		let existing = this.cacheA.get(cacheKey);
-		if (existing) {
-			existing.hits++;
-			return existing.promise;
-		}
-		existing = this.cacheB.get(cacheKey);
-		if (existing) {
-			existing.hits++;
-			existing.saves++;
-			this.size += existing.size;
-			this.cacheA.set(cacheKey, existing);
-			return existing.promise;
-		}
-		existing = {
-			promise: next(req),
-			hits: 0,
-			saves: 0,
-			size: req.length
-		};
-		this.size += existing.size;
-		if (this.size > this.maxSize) {
-			this.size = existing.size;
-			this.cacheB = this.cacheA;
-			this.cacheA = /* @__PURE__ */ new Map();
-			this.resets++;
-		}
-		this.cacheA.set(cacheKey, existing);
-		return existing.promise;
-	}
-};
-//#endregion
-//#region node_modules/@chunkd/source/build/src/error.js
-var SourceError = class SourceError 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(msg, code, source, cause) {
-		super(msg, { cause });
-		this.code = code;
-		this.url = source.url;
-		this.source = source;
-		/** Helper to determine if this class is a SourceError, useful for when `instanceof` fails */
-		Object.defineProperty(this, "_sourceError", {
-			enumerable: false,
-			value: "SourceError"
-		});
-	}
-	/** Check that a unknown is a FsError */
-	static is(e) {
-		if (e instanceof SourceError) return true;
-		if (typeof e !== "object") return false;
-		if (e == null) return false;
-		return "_sourceError" in e && e["_sourceError"] === "SourceError";
-	}
-};
+//#region node_modules/proj4/lib/constants/values.js
+var SRS_WGS84_SEMIMAJOR = 6378137;
+var SRS_WGS84_SEMIMINOR = 6356752.314;
+var SRS_WGS84_ESQUARED = .0066943799901413165;
+var SEC_TO_RAD = 484813681109536e-20;
+var HALF_PI = Math.PI / 2;
+var SIXTH = .16666666666666666;
+var RA4 = .04722222222222222;
+var RA6 = .022156084656084655;
+var EPSLN = 1e-10;
+var D2R = .017453292519943295;
+var R2D = 57.29577951308232;
+var FORTPI = Math.PI / 4;
+var TWO_PI = Math.PI * 2;
+var SPI = 3.14159265359;
 //#endregion
-//#region node_modules/@chunkd/source/build/src/range.js
-var ContentRange = {
-	/** Convert a offset/length to a range request
-	*
-	* @example
-	* ```typescript
-	* ContentRange.toRange(10) // "bytes=10"
-	* ContentRange.toRange(0, 1024) // "bytes=0-1023"
-	* ```
-	*/
-	toRange(offset, length) {
-		if (length == null) return `bytes=${offset}`;
-		if (offset < 0) throw new Error("Cannot read from remote source with negative offset and length");
-		return `bytes=${offset}-${offset + length - 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(range) {
-		const [unit, chunks] = range.split(" ");
-		if (unit !== "bytes") throw new Error("Failed to parse content-range: " + range);
-		if (chunks == null) throw new Error("Failed to parse content-range: " + range);
-		const [, size] = chunks.split("/");
-		const result = Number(size);
-		if (isNaN(result)) throw new Error("Failed to parse content-range: " + range);
-		return result;
-	}
-};
+//#region node_modules/proj4/lib/constants/PrimeMeridian.js
+var primeMeridian = {};
+primeMeridian.greenwich = 0;
+primeMeridian.lisbon = -9.131906111111;
+primeMeridian.paris = 2.337229166667;
+primeMeridian.bogota = -74.080916666667;
+primeMeridian.madrid = -3.687938888889;
+primeMeridian.rome = 12.452333333333;
+primeMeridian.bern = 7.439583333333;
+primeMeridian.jakarta = 106.807719444444;
+primeMeridian.ferro = -17.666666666667;
+primeMeridian.brussels = 4.367975;
+primeMeridian.stockholm = 18.058277777778;
+primeMeridian.athens = 23.7163375;
+primeMeridian.oslo = 10.722916666667;
 //#endregion
-//#region node_modules/@chunkd/source/build/src/view.js
-/**
-* Wrap a source with middleware to modify requests to the sources
-*
-* @see {@link SourceMiddleware}
-* @see @chunkd/middle for example middleware
-*/
-var SourceView = class {
-	source;
-	middleware;
-	static is(s) {
-		if ("middleware" in s) return true;
-		return false;
-	}
-	constructor(source, middleware = []) {
-		this.source = source;
-		this.middleware = middleware;
-	}
-	get type() {
-		return this.source.type;
-	}
-	get url() {
-		return this.source.url;
-	}
-	get metadata() {
-		return this.source.metadata;
-	}
-	head(options) {
-		return this.source.head(options);
-	}
-	async fetch(offset, length, options) {
-		const middleware = this.middleware;
-		if (middleware == null || middleware.length === 0) return this.source.fetch(offset, length, options);
-		const handler = (req) => this.source.fetch(req.offset, req.length, options);
-		return this.run(handler, offset, length, options);
-	}
-	/** Run a request using all the middleware */
-	async run(handler, offset, length, options) {
-		const middleware = this.middleware;
-		if (middleware == null) return handler({
-			source: this,
-			offset,
-			length,
-			signal: options?.signal
-		});
-		function runMiddleware(middleware, next) {
-			return (req) => middleware.fetch(req, next);
-		}
-		for (let i = middleware.length - 1; i >= 0; i--) handler = runMiddleware(middleware[i], handler);
-		return handler({
-			source: this,
-			offset,
-			length,
-			signal: options?.signal
-		});
-	}
+//#region node_modules/proj4/lib/constants/units.js
+var units_default = {
+	mm: { to_meter: .001 },
+	cm: { to_meter: .01 },
+	ft: { to_meter: .3048 },
+	"us-ft": { to_meter: 1200 / 3937 },
+	fath: { to_meter: 1.8288 },
+	kmi: { to_meter: 1852 },
+	"us-ch": { to_meter: 20.1168402336805 },
+	"us-mi": { to_meter: 1609.34721869444 },
+	km: { to_meter: 1e3 },
+	"ind-ft": { to_meter: .30479841 },
+	"ind-yd": { to_meter: .91439523 },
+	mi: { to_meter: 1609.344 },
+	yd: { to_meter: .9144 },
+	ch: { to_meter: 20.1168 },
+	link: { to_meter: .201168 },
+	dm: { to_meter: .1 },
+	in: { to_meter: .0254 },
+	"ind-ch": { to_meter: 20.11669506 },
+	"us-in": { to_meter: .025400050800101 },
+	"us-yd": { to_meter: .914401828803658 }
 };
 //#endregion
-//#region node_modules/@chunkd/source/build/src/index.js
-function tryParseUrl(s) {
-	try {
-		return new URL(s);
-	} catch (e) {
-		return null;
+//#region node_modules/proj4/lib/match.js
+var ignoredChar = /[\s_\-\/\(\)]/g;
+function match(obj, key) {
+	if (obj[key]) return obj[key];
+	var keys = Object.keys(obj);
+	var lkey = key.toLowerCase().replace(ignoredChar, "");
+	var i = -1;
+	var testkey, processedKey;
+	while (++i < keys.length) {
+		testkey = keys[i];
+		processedKey = testkey.toLowerCase().replace(ignoredChar, "");
+		if (processedKey === lkey) return obj[testkey];
 	}
 }
 //#endregion
-//#region node_modules/@chunkd/middleware/build/src/middleware/chunk.js
+//#region node_modules/proj4/lib/projString.js
 /**
-* Chunk requests into requests of specific byte sizes
-* If a request is split into smaller chunks should that be re-run as smaller requests and combined later
-*
-* This can **GREATLY** increase cache hits when using a @see {SourceCache}
-*/
-var SourceChunk = class {
-	name = "source:chunk";
-	/** Number of bytes to chunk requests into */
-	chunkSize;
-	constructor(opts) {
-		this.chunkSize = opts.size ?? 32 * 1024;
-	}
-	async fetch(req, next) {
-		if (req.offset < 0) return next(req);
-		if (req.length == null) return next(req);
-		const startChunkId = Math.floor(req.offset / this.chunkSize);
-		const endChunkId = Math.ceil((req.offset + req.length) / this.chunkSize);
-		const maxSize = req.source.metadata?.size;
-		if (maxSize != null && req.offset + req.length > maxSize) throw new SourceError(`Request outside of bounds ${ContentRange.toRange(req.offset, req.length)}`, 416, req.source);
-		const startByte = startChunkId * this.chunkSize;
-		const maxLength = (maxSize != null ? Math.min(endChunkId * this.chunkSize, maxSize) : endChunkId * this.chunkSize) - startByte;
-		const chunkOffset = req.offset - startByte;
-		if (endChunkId - startChunkId > 1) return (await this.fetchChunks(req, startChunkId, endChunkId)).slice(chunkOffset, chunkOffset + req.length);
-		if (req.offset === startByte && req.length === maxLength) return next(req);
-		return (await next({
-			...req,
-			offset: startByte,
-			length: maxLength
-		})).slice(chunkOffset, chunkOffset + req.length);
-	}
-	async fetchChunks(req, startId, endId) {
-		const promises = [];
-		const maxEndByte = req.source.metadata?.size ?? endId * this.chunkSize;
-		for (let chunk = startId; chunk < endId; chunk++) {
-			const startByte = chunk * this.chunkSize;
-			const chunkLength = Math.min(startByte + this.chunkSize, maxEndByte) - startByte;
-			promises.push(req.source.fetch(chunk * this.chunkSize, chunkLength, req.signal ? { signal: req.signal } : void 0));
-		}
-		const results = await Promise.all(promises);
-		const outputBuffer = new Uint8Array(promises.length * this.chunkSize);
-		for (let i = 0; i < results.length; i++) outputBuffer.set(new Uint8Array(results[i]), i * this.chunkSize);
-		return outputBuffer.buffer;
-	}
-};
-//#endregion
-//#region node_modules/@chunkd/source-http/build/src/index.js
-/** Load the ETag and content-range from the response */
-function getMetadataFromResponse(response) {
-	const metadata = {};
-	const contentLength = response.headers.get("content-length");
-	if (contentLength) metadata.size = parseInt(contentLength);
-	const contentRange = response.headers.get("content-range");
-	if (contentRange != null) metadata.size = ContentRange.parseSize(contentRange);
-	metadata.eTag = response.headers.get("etag") ?? void 0;
-	metadata.contentType = response.headers.get("content-type") ?? void 0;
-	metadata.contentDisposition = response.headers.get("content-disposition") ?? void 0;
-	metadata.cacheControl = response.headers.get("cache-control") ?? void 0;
-	metadata.contentEncoding = response.headers.get("content-encoding") ?? void 0;
-	return metadata;
-}
-var SourceHttp = class SourceHttp {
-	constructor(url, headers) {
-		this.type = "http";
-		this.url = typeof url === "string" ? SourceHttp.tryUrl(url) : url;
-		this.headers = headers;
-	}
-	/** Attempt to parse a relative string into a URL */
-	static tryUrl(s) {
-		try {
-			return new URL(s);
-		} catch (_e) {
-			if (typeof document !== "undefined") return new URL(s, document.baseURI);
-			return new URL(s, import.meta.url);
-		}
-	}
-	head() {
-		if (this._head) return this._head;
-		this._head = SourceHttp.fetch(this.url, {
-			method: "HEAD",
-			headers: this.headers
-		}).then((res) => {
-			if (!res.ok) {
-				delete this._head;
-				throw new Error(`Failed to HEAD ${this.url.href}`, { cause: {
-					statusCode: res.status,
-					msg: res.statusText
-				} });
-			}
-			this.metadata = getMetadataFromResponse(res);
-			return this.metadata;
-		});
-		return this._head;
-	}
-	async fetch(offset, length, options) {
-		try {
-			const headers = {
-				range: ContentRange.toRange(offset, length),
-				...this.headers
-			};
-			const response = await SourceHttp.fetch(this.url, {
-				headers,
-				signal: options?.signal
-			});
-			if (!response.ok) throw new SourceError(`Failed to fetch ${this.url.href} ${headers.range}`, response.status, this, new Error(response.statusText));
-			const metadata = getMetadataFromResponse(response);
-			if (this.metadata == null) this.metadata = metadata;
-			else if (this.metadata.eTag && this.metadata.eTag !== metadata.eTag) throw new SourceError(`ETag conflict ${this.url.href} ${headers.range} expected: ${this.metadata.eTag} got: ${metadata.eTag}`, 409, this);
-			return response.arrayBuffer();
-		} catch (e) {
-			if (SourceError.is(e) && e.source === this) throw e;
-			throw new SourceError(`Failed to fetch: ${this.url.href}`, 500, this, e);
-		}
-	}
-};
-SourceHttp.fetch = (a, b) => fetch(a, b);
-//#endregion
-//#region node_modules/@chunkd/source-memory/build/src/index.js
-function parseMemoryUrl(s) {
-	if (typeof s !== "string") return s;
-	const url = tryParseUrl(s);
-	if (url) return url;
-	return new URL("memory://" + s);
-}
-var SourceMemory = class SourceMemory {
-	url;
-	type = "memory";
-	data;
-	metadata;
-	static toArrayBuffer(buf) {
-		if (buf instanceof ArrayBuffer) return buf;
-		if (buf.byteLength === buf.buffer.byteLength) return buf.buffer;
-		return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
-	}
-	constructor(url, bytes) {
-		const buf = SourceMemory.toArrayBuffer(bytes ?? new Uint8Array());
-		this.url = parseMemoryUrl(url);
-		this.data = buf;
-		this.metadata = { size: buf.byteLength };
-	}
-	head() {
-		return Promise.resolve({ size: this.data.byteLength });
-	}
-	fetch(offset, length) {
-		if (offset < 0) offset = this.data.byteLength + offset;
-		if (offset > this.data.byteLength) throw new SourceError(`Read offset outside of file bounds range:${ContentRange.toRange(offset, length)} fileSize:${this.data.byteLength}`, 416, this);
-		return Promise.resolve(this.data.slice(offset, length == null ? void 0 : offset + length));
-	}
-};
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/crs.js
-var PROJJSON_SCHEMA = "https://proj.org/schemas/v0.7/projjson.schema.json";
-var MODEL_TYPE_PROJECTED$1 = 1;
-var MODEL_TYPE_GEOGRAPHIC$1 = 2;
-var USER_DEFINED$1 = 32767;
-var CT_TRANSVERSE_MERCATOR = 1;
-var CT_TRANSVERSE_MERCATOR_SOUTH = 2;
-var CT_OBLIQUE_MERCATOR = 3;
-var CT_OBLIQUE_MERCATOR_LABORDE = 4;
-var CT_OBLIQUE_MERCATOR_ROSENMUND = 5;
-var CT_OBLIQUE_MERCATOR_SPHERICAL = 6;
-var CT_MERCATOR = 7;
-var CT_LAMBERT_CONFORMAL_CONIC_2SP = 8;
-var CT_LAMBERT_CONFORMAL_CONIC_1SP = 9;
-var CT_LAMBERT_AZIMUTHAL_EQUAL_AREA = 10;
-var CT_ALBERS_EQUAL_AREA = 11;
-var CT_AZIMUTHAL_EQUIDISTANT = 12;
-var CT_STEREOGRAPHIC = 14;
-var CT_POLAR_STEREOGRAPHIC = 15;
-var CT_OBLIQUE_STEREOGRAPHIC = 16;
-var CT_EQUIRECTANGULAR = 17;
-var CT_CASSINI_SOLDNER = 18;
-var CT_ORTHOGRAPHIC = 21;
-var CT_POLYCONIC = 22;
-var CT_SINUSOIDAL = 24;
-var CT_NEW_ZEALAND_MAP_GRID = 26;
-var CT_TRANSVERSE_MERCATOR_SOUTH_ORIENTED = 27;
-var ANGULAR_UNIT_DEGREE = 9102;
-var ANGULAR_UNIT_RADIAN = 9101;
-var ANGULAR_UNIT_GRAD = 9105;
-var ANGULAR_UNIT = {
-	[ANGULAR_UNIT_DEGREE]: "degree",
-	[ANGULAR_UNIT_RADIAN]: "radian",
-	[ANGULAR_UNIT_GRAD]: "grad"
-};
-var LINEAR_UNIT_METRE = 9001;
-var LINEAR_UNIT_FOOT = 9002;
-var LINEAR_UNIT_US_SURVEY_FOOT = 9003;
-var US_SURVEY_FOOT = {
-	type: "LinearUnit",
-	name: "US survey foot",
-	conversion_factor: .30480060960121924
-};
-var LINEAR_UNIT = {
-	[LINEAR_UNIT_METRE]: "metre",
-	[LINEAR_UNIT_FOOT]: "foot",
-	[LINEAR_UNIT_US_SURVEY_FOOT]: US_SURVEY_FOOT
-};
-/**
-* Parse a CRS from a GeoKeyDirectory.
-*
-* Returns the EPSG code as a number for EPSG-coded CRSes (letting the caller
-* decide how to resolve it), or a PROJJSON object built from the geo keys for
-* user-defined CRSes.
-*/
-function crsFromGeoKeys(gkd) {
-	const modelType = gkd.modelType;
-	if (modelType === MODEL_TYPE_PROJECTED$1) return _projectedCrs(gkd);
-	if (modelType === MODEL_TYPE_GEOGRAPHIC$1) return _geographicCrs(gkd);
-	throw new Error(`Unsupported GeoTIFF model type: ${modelType}`);
-}
-function _geographicCrs(gkd) {
-	const epsg = gkd.geodeticCRS;
-	if (epsg !== null && epsg !== USER_DEFINED$1) return epsg;
-	return _buildGeographicCrs(gkd, PROJJSON_SCHEMA);
-}
-function _projectedCrs(gkd) {
-	const epsg = gkd.projectedCRS;
-	if (epsg !== null && epsg !== USER_DEFINED$1) return epsg;
-	return _buildProjectedCrs(gkd);
-}
-function _buildGeographicCrs(gkd, schema) {
-	const ellipsoid = _buildEllipsoid(gkd);
-	let pmName = "Greenwich";
-	let pmLongitude = 0;
-	if (gkd.primeMeridian !== null && gkd.primeMeridian !== USER_DEFINED$1) pmName = `EPSG:${gkd.primeMeridian}`;
-	else if (gkd.primeMeridianLongitude !== null) {
-		pmLongitude = gkd.primeMeridianLongitude;
-		pmName = "User-defined";
-	}
-	let datum;
-	if (gkd.geodeticDatum !== null && gkd.geodeticDatum !== USER_DEFINED$1) datum = {
-		type: "GeodeticReferenceFrame",
-		name: `Unknown datum based upon EPSG ${gkd.geodeticDatum} ellipsoid`
-	};
-	else datum = {
-		type: "GeodeticReferenceFrame",
-		name: gkd.geodeticCitation ?? "User-defined",
-		ellipsoid,
-		prime_meridian: {
-			name: pmName,
-			longitude: pmLongitude
-		}
-	};
-	const crs = {
-		type: "GeographicCRS",
-		name: gkd.geodeticCitation ?? "User-defined",
-		datum,
-		coordinate_system: _geographicCs(gkd)
-	};
-	if (schema !== void 0) crs.$schema = schema;
-	return crs;
-}
-function _buildProjectedCrs(gkd) {
-	const baseCrs = _buildGeographicCrs(gkd);
-	const conversion = _buildConversion(gkd);
-	const cs = _projectedCs(gkd);
-	return {
-		type: "ProjectedCRS",
-		$schema: PROJJSON_SCHEMA,
-		name: gkd.projectedCitation ?? gkd.citation ?? "User-defined",
-		base_crs: baseCrs,
-		conversion,
-		coordinate_system: cs
-	};
-}
-function _buildEllipsoid(gkd) {
-	if (gkd.ellipsoid !== null && gkd.ellipsoid !== USER_DEFINED$1) {
-		const ellipsoid = { name: `EPSG ellipsoid ${gkd.ellipsoid}` };
-		if (gkd.ellipsoidSemiMajorAxis !== null) ellipsoid.semi_major_axis = gkd.ellipsoidSemiMajorAxis;
-		if (gkd.ellipsoidInvFlattening !== null) ellipsoid.inverse_flattening = gkd.ellipsoidInvFlattening;
-		else if (gkd.ellipsoidSemiMinorAxis !== null) ellipsoid.semi_minor_axis = gkd.ellipsoidSemiMinorAxis;
-		return ellipsoid;
-	}
-	if (gkd.ellipsoidSemiMajorAxis === null) throw new Error("User-defined ellipsoid requires ellipsoidSemiMajorAxis");
-	const ellipsoid = {
-		name: gkd.geodeticCitation ?? "User-defined",
-		semi_major_axis: gkd.ellipsoidSemiMajorAxis
-	};
-	if (gkd.ellipsoidInvFlattening !== null) ellipsoid.inverse_flattening = gkd.ellipsoidInvFlattening;
-	else if (gkd.ellipsoidSemiMinorAxis !== null) ellipsoid.semi_minor_axis = gkd.ellipsoidSemiMinorAxis;
-	else throw new Error("User-defined ellipsoid requires ellipsoidInvFlattening or ellipsoidSemiMinorAxis");
-	return ellipsoid;
-}
-function _buildConversion(gkd) {
-	const ct = gkd.projMethod;
-	if (ct === null) throw new Error("User-defined projected CRS requires projMethod");
-	const angular = (name, value, default_ = 0) => ({
-		name,
-		value: value ?? default_,
-		unit: "degree"
-	});
-	const linear = (name, value, default_ = 0) => ({
-		name,
-		value: value ?? default_,
-		unit: "metre"
-	});
-	const scale = (name, value, default_ = 1) => ({
-		name,
-		value: value ?? default_,
-		unit: "unity"
-	});
-	switch (ct) {
-		case CT_TRANSVERSE_MERCATOR:
-		case CT_TRANSVERSE_MERCATOR_SOUTH:
-		case CT_TRANSVERSE_MERCATOR_SOUTH_ORIENTED: {
-			const name = ct === CT_TRANSVERSE_MERCATOR ? "Transverse Mercator" : "Transverse Mercator (South Orientated)";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projNatOriginLat),
-					angular("Longitude of natural origin", gkd.projNatOriginLong),
-					scale("Scale factor at natural origin", gkd.projScaleAtNatOrigin),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_OBLIQUE_MERCATOR:
-		case CT_OBLIQUE_MERCATOR_LABORDE:
-		case CT_OBLIQUE_MERCATOR_ROSENMUND:
-		case CT_OBLIQUE_MERCATOR_SPHERICAL: {
-			const name = "Hotine Oblique Mercator (variant B)";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of projection centre", gkd.projCenterLat),
-					angular("Longitude of projection centre", gkd.projCenterLong),
-					angular("Azimuth of initial line", gkd.projAzimuthAngle),
-					angular("Angle from Rectified to Skew Grid", gkd.projAzimuthAngle),
-					scale("Scale factor on initial line", gkd.projScaleAtCenter),
-					linear("Easting at projection centre", gkd.projCenterEasting),
-					linear("Northing at projection centre", gkd.projCenterNorthing)
-				]
-			};
-		}
-		case CT_MERCATOR: {
-			const name = "Mercator (variant A)";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projNatOriginLat),
-					angular("Longitude of natural origin", gkd.projNatOriginLong),
-					scale("Scale factor at natural origin", gkd.projScaleAtNatOrigin),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_LAMBERT_CONFORMAL_CONIC_2SP: {
-			const name = "Lambert Conic Conformal (2SP)";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of false origin", gkd.projFalseOriginLat ?? gkd.projNatOriginLat),
-					angular("Longitude of false origin", gkd.projFalseOriginLong ?? gkd.projNatOriginLong),
-					angular("Latitude of 1st standard parallel", gkd.projStdParallel1),
-					angular("Latitude of 2nd standard parallel", gkd.projStdParallel2),
-					linear("Easting at false origin", gkd.projFalseOriginEasting ?? gkd.projFalseEasting),
-					linear("Northing at false origin", gkd.projFalseOriginNorthing ?? gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_LAMBERT_CONFORMAL_CONIC_1SP: {
-			const name = "Lambert Conic Conformal (1SP)";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projNatOriginLat),
-					angular("Longitude of natural origin", gkd.projNatOriginLong),
-					scale("Scale factor at natural origin", gkd.projScaleAtNatOrigin),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_LAMBERT_AZIMUTHAL_EQUAL_AREA: {
-			const name = "Lambert Azimuthal Equal Area";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projCenterLat),
-					angular("Longitude of natural origin", gkd.projCenterLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_ALBERS_EQUAL_AREA: {
-			const name = "Albers Equal Area";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of false origin", gkd.projFalseOriginLat ?? gkd.projNatOriginLat),
-					angular("Longitude of false origin", gkd.projFalseOriginLong ?? gkd.projNatOriginLong),
-					angular("Latitude of 1st standard parallel", gkd.projStdParallel1),
-					angular("Latitude of 2nd standard parallel", gkd.projStdParallel2),
-					linear("Easting at false origin", gkd.projFalseOriginEasting ?? gkd.projFalseEasting),
-					linear("Northing at false origin", gkd.projFalseOriginNorthing ?? gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_AZIMUTHAL_EQUIDISTANT: {
-			const name = "Modified Azimuthal Equidistant";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projCenterLat),
-					angular("Longitude of natural origin", gkd.projCenterLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_STEREOGRAPHIC: {
-			const name = "Stereographic";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projCenterLat),
-					angular("Longitude of natural origin", gkd.projCenterLong),
-					scale("Scale factor at natural origin", gkd.projScaleAtCenter),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_POLAR_STEREOGRAPHIC: {
-			const name = "Polar Stereographic (variant B)";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of standard parallel", gkd.projNatOriginLat ?? gkd.projStdParallel1),
-					angular("Longitude of origin", gkd.projStraightVertPoleLong ?? gkd.projNatOriginLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_OBLIQUE_STEREOGRAPHIC: {
-			const name = "Oblique Stereographic";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projCenterLat),
-					angular("Longitude of natural origin", gkd.projCenterLong),
-					scale("Scale factor at natural origin", gkd.projScaleAtCenter),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_EQUIRECTANGULAR: {
-			const name = "Equidistant Cylindrical";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of 1st standard parallel", gkd.projStdParallel1 ?? gkd.projCenterLat),
-					angular("Longitude of natural origin", gkd.projCenterLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_CASSINI_SOLDNER: {
-			const name = "Cassini-Soldner";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projNatOriginLat),
-					angular("Longitude of natural origin", gkd.projNatOriginLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_POLYCONIC: {
-			const name = "American Polyconic";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projNatOriginLat),
-					angular("Longitude of natural origin", gkd.projNatOriginLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_SINUSOIDAL: {
-			const name = "Sinusoidal";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Longitude of natural origin", gkd.projCenterLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_ORTHOGRAPHIC: {
-			const name = "Orthographic";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projCenterLat),
-					angular("Longitude of natural origin", gkd.projCenterLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		case CT_NEW_ZEALAND_MAP_GRID: {
-			const name = "New Zealand Map Grid";
-			return {
-				name,
-				method: { name },
-				parameters: [
-					angular("Latitude of natural origin", gkd.projNatOriginLat),
-					angular("Longitude of natural origin", gkd.projNatOriginLong),
-					linear("False easting", gkd.projFalseEasting),
-					linear("False northing", gkd.projFalseNorthing)
-				]
-			};
-		}
-		default: throw new Error(`Unsupported coordinate transformation type: ${ct}`);
-	}
-}
-function _geographicCs(gkd) {
-	const unit = ANGULAR_UNIT[gkd.angularUnits ?? ANGULAR_UNIT_DEGREE] ?? "degree";
-	return {
-		subtype: "ellipsoidal",
-		axis: [{
-			name: "Geodetic latitude",
-			abbreviation: "Lat",
-			direction: "north",
-			unit
-		}, {
-			name: "Geodetic longitude",
-			abbreviation: "Lon",
-			direction: "east",
-			unit
-		}]
-	};
-}
-function _projectedCs(gkd) {
-	const unit = LINEAR_UNIT[gkd.projLinearUnits ?? LINEAR_UNIT_METRE] ?? "metre";
-	return {
-		subtype: "Cartesian",
-		axis: [{
-			name: "Easting",
-			abbreviation: "E",
-			direction: "east",
-			unit
-		}, {
-			name: "Northing",
-			abbreviation: "N",
-			direction: "north",
-			unit
-		}]
-	};
-}
-/**
-* Fetch the given byte ranges from a source, coalescing nearby ranges into a
-* smaller number of underlying `source.fetch` calls. Returns one `ArrayBuffer`
-* per input range, in input order.
-*
-* Vendored from cogeotiff PR #1463 (`packages/core/src/source.coalesce.ts`),
-* reformatted to this repo's conventions. Kept here (rather than relying on the
-* upstream `Source.fetchRanges` hook) because `@developmentseed/geotiff` routes
-* tile-data reads through an uncached `dataSource` typed as `Pick<Source, "fetch">`.
-*/
-async function coalesceRanges(source, ranges, options) {
-	if (ranges.length === 0) return [];
-	const coalesce = options?.coalesce ?? 1048576;
-	const maxRangeSize = options?.maxRangeSize ?? 16777216;
-	const signal = options?.signal;
-	const merged = mergeRanges(ranges, coalesce, maxRangeSize);
-	const fetched = await dispatchMerged(source, merged, signal);
-	const result = new Array(ranges.length);
-	for (let i = 0; i < ranges.length; i++) {
-		const range = ranges[i];
-		const groupIndex = findGroupIndex(merged, range.offset);
-		const group = merged[groupIndex];
-		const groupBytes = fetched[groupIndex];
-		const start = range.offset - group.offset;
-		const end = start + range.length;
-		if (end > groupBytes.byteLength) throw new Error(`Failed to fetch bytes from offset:${range.offset} wanted:${range.length} got:${groupBytes.byteLength - start}`);
-		result[i] = groupBytes.slice(start, end);
-	}
-	return result;
-}
-/**
-* Sort ranges by offset and merge consecutive ones whose gap is `<= coalesce`
-* and whose merged size stays `<= maxRangeSize`.
-*/
-function mergeRanges(ranges, coalesce, maxRangeSize) {
-	const sorted = [...ranges].sort((a, b) => a.offset - b.offset);
-	const out = [];
-	let current = null;
-	for (const r of sorted) {
-		if (current == null) {
-			current = {
-				offset: r.offset,
-				length: r.length
-			};
-			continue;
-		}
-		const currentEnd = current.offset + current.length;
-		const nextEnd = r.offset + r.length;
-		const gap = r.offset - currentEnd;
-		const mergedEnd = Math.max(currentEnd, nextEnd);
-		const mergedSize = mergedEnd - current.offset;
-		if (gap <= coalesce && mergedSize <= maxRangeSize) current.length = mergedEnd - current.offset;
-		else {
-			out.push(current);
-			current = {
-				offset: r.offset,
-				length: r.length
-			};
-		}
-	}
-	if (current != null) out.push(current);
-	return out;
-}
-/** Binary search for the merged group whose offset is the largest `<= target`. */
-function findGroupIndex(merged, target) {
-	let lo = 0;
-	let hi = merged.length - 1;
-	while (lo < hi) {
-		const mid = lo + hi + 1 >>> 1;
-		if (merged[mid].offset <= target) lo = mid;
-		else hi = mid - 1;
-	}
-	return lo;
-}
-/** Fetch every merged range, at most {@link COALESCE_PARALLEL} requests in flight. */
-async function dispatchMerged(source, merged, signal) {
-	const out = new Array(merged.length);
-	for (let i = 0; i < merged.length; i += 6) {
-		const batch = merged.slice(i, i + 6);
-		const results = await Promise.all(batch.map((g) => source.fetch(g.offset, g.length, { signal })));
-		for (let j = 0; j < results.length; j++) out[i + j] = results[j];
-	}
-	return out;
-}
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/fetch.js
-async function fetchTile(self, x, y, { boundless = true, pool, signal } = {}) {
-	const tileFetch = fetchCogBytes(self, x, y, { signal });
-	const maskFetch = self.maskImage != null ? getTile(self.maskImage, x, y, self.dataSource, {
-		signal,
-		debug: self._debug ? { label: "mask" } : void 0
-	}) : Promise.resolve(null);
-	const [tileBytes, maskBytes] = await Promise.all([tileFetch, maskFetch]);
-	return assembleTile(self, x, y, tileBytes, maskBytes, {
-		boundless,
-		pool
-	});
-}
-/**
-* Decode already-fetched compressed tile (and optional mask) bytes into a
-* {@link Tile}. Performs no I/O — the bytes are supplied by the caller. Shared
-* by {@link fetchTile} (single-tile fetch) and {@link fetchTiles} (batched
-* fetch with range coalescing).
-*/
-async function assembleTile(self, x, y, tileBytes, maskBytes, { boundless, pool }) {
-	const { bitsPerSample: bitsPerSamples, predictor, planarConfiguration, sampleFormat: sampleFormats, lercParameters } = self.cachedTags;
-	const { sampleFormat, bitsPerSample } = getUniqueSampleFormat(sampleFormats, bitsPerSamples);
-	const tileTransform = compose(self.transform, translation(x * self.tileWidth, y * self.tileHeight));
-	const samplesPerPixel = self.image.value(TiffTag.SamplesPerPixel) ?? 1;
-	const decoderMetadata = {
-		sampleFormat,
-		bitsPerSample,
-		samplesPerPixel,
-		width: self.tileWidth,
-		height: self.tileHeight,
-		predictor,
-		planarConfiguration,
-		lercParameters
-	};
-	const [decodedPixels, mask] = await Promise.all([decodeTile(tileBytes, decoderMetadata, pool), maskBytes != null && self.maskImage != null ? decodeMask(maskBytes, self.maskImage, pool) : Promise.resolve(null)]);
-	const array = {
-		...decodedPixels,
-		count: samplesPerPixel,
-		height: self.tileHeight,
-		width: self.tileWidth,
-		mask,
-		transform: tileTransform,
-		crs: self.crs,
-		nodata: self.nodata
-	};
-	return {
-		x,
-		y,
-		array: boundless === true ? array : clipToImageBounds(self, x, y, array)
-	};
-}
-/**
-* Fetch multiple tiles from a GeoTIFF or Overview, batching the underlying
-* reads.
-*
-* Unlike repeated {@link fetchTile} calls, this resolves every requested
-* tile's byte range up front and fetches the data through {@link getTiles} /
-* {@link getMultipleBytes}, which coalesce nearby ranges into far fewer HTTP
-* range requests — a big win when the coordinates form a contiguous block, as
-* they do when assembling a coarse tile from finer covering tiles. Decoding is
-* still done per tile (via the shared {@link assembleTile}); only the I/O is
-* batched.
-*
-* @param self - The GeoTIFF or Overview to fetch tiles from.
-* @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.
-* @see {@link getTiles} for the batched, range-coalescing byte reader.
-*/
-async function fetchTiles(self, xy, { boundless = true, pool, signal } = {}) {
-	if (xy.length === 0) return [];
-	const dataFetch = fetchCogBytesMultiple(self, xy, { signal });
-	const maskFetch = self.maskImage != null ? getTiles(self.maskImage, xy, self.dataSource, {
-		signal,
-		debug: self._debug ? { label: "mask" } : void 0
-	}) : Promise.resolve(xy.map(() => null));
-	const [allTileBytes, allMaskBytes] = await Promise.all([dataFetch, maskFetch]);
-	return Promise.all(xy.map(([x, y], i) => assembleTile(self, x, y, allTileBytes[i], allMaskBytes[i] ?? null, {
-		boundless,
-		pool
-	})));
-}
-async function decodeMask(mask, maskImage, pool) {
-	const maskSampleFormats = maskImage.value(TiffTag.SampleFormat) ?? [1];
-	const maskBitsPerSample = maskImage.value(TiffTag.BitsPerSample) ?? [8];
-	const { sampleFormat, bitsPerSample } = getUniqueSampleFormat(maskSampleFormats, new Uint16Array(maskBitsPerSample));
-	const { width, height } = maskImage.tileSize;
-	const metadata = {
-		sampleFormat,
-		bitsPerSample,
-		samplesPerPixel: maskImage.value(TiffTag.SamplesPerPixel) ?? 1,
-		width,
-		height,
-		predictor: maskImage.value(TiffTag.Predictor) ?? 1,
-		planarConfiguration: maskImage.value(TiffTag.PlanarConfiguration) ?? PlanarConfiguration.Contig
-	};
-	const decoderFn = (bytes, compression, meta) => pool ? pool.decode(bytes, compression, meta) : decode$1(bytes, compression, meta);
-	const { bytes, compression } = mask;
-	const decoded = await decoderFn(bytes, compression, metadata);
-	const data = decoded.layout === "pixel-interleaved" ? decoded.data : decoded.bands[0];
-	if (data instanceof Uint8Array) return data;
-	throw new Error("Expected mask data to decode to Uint8Array");
-}
-async function decodeTile(tile, metadata, pool) {
-	const decoderFn = (bytes, compression, meta) => pool ? pool.decode(bytes, compression, meta) : decode$1(bytes, compression, meta);
-	if (Array.isArray(tile)) {
-		const bandMetadata = {
-			...metadata,
-			samplesPerPixel: 1
-		};
-		return {
-			layout: "band-separate",
-			bands: (await Promise.all(tile.map(({ bytes, compression }) => decoderFn(bytes, compression, bandMetadata)))).map((result) => result.layout === "band-separate" ? result.bands[0] : result.data)
-		};
-	} else {
-		const { bytes, compression } = tile;
-		return decoderFn(bytes, compression, metadata);
-	}
-}
-/** Fetch bytes from a COG, handling whether pixel/band interleaving. */
-async function fetchCogBytes(self, x, y, { signal } = {}) {
-	const debug = self._debug ? { label: "data" } : void 0;
-	switch (self.cachedTags.planarConfiguration) {
-		case PlanarConfiguration.Contig: {
-			const tile = await getTile(self.image, x, y, self.dataSource, {
-				signal,
-				debug
-			});
-			if (tile === null) throw new Error(`Tile at (${x}, ${y}) not found`);
-			return tile;
-		}
-		case PlanarConfiguration.Separate: return await fetchBandSeparateTileBytes(self, x, y, { signal });
-		default: throw new Error(`Unsupported PlanarConfiguration: ${self.cachedTags.planarConfiguration}`);
-	}
-}
-async function findBandSeparateTileByteRanges(self, x, y) {
-	const { x: tilesPerRow, y: tilesPerColumn } = self.image.tileCount;
-	const tilesPerBand = tilesPerRow * tilesPerColumn;
-	const numBands = self.cachedTags.samplesPerPixel;
-	const tileSizes = [...Array(numBands).keys()].map((band) => {
-		const bandIdx = band * tilesPerBand + y * tilesPerRow + x;
-		return self.image.getTileSize(bandIdx);
-	});
-	return Promise.all(tileSizes);
-}
-async function fetchBandSeparateTileBytes(self, x, y, { signal } = {}) {
-	const debug = self._debug ? { label: "data" } : void 0;
-	const buffers = (await findBandSeparateTileByteRanges(self, x, y)).map(async ({ offset, imageSize }) => {
-		const tile = await getBytes(self.image, offset, imageSize, self.dataSource, {
-			signal,
-			debug
-		});
-		if (tile === null) throw new Error(`Tile at (${x}, ${y}) not found`);
-		return tile;
-	});
-	return Promise.all(buffers);
-}
-/**
-* Batched, range-coalescing counterpart to {@link fetchCogBytes}: fetch the
-* compressed bytes for many tiles in as few HTTP range requests as possible.
-* Returns one entry per input coordinate, in input order. Throws (matching
-* {@link fetchCogBytes}) if a requested tile is sparse / not present.
-*/
-async function fetchCogBytesMultiple(self, xy, { signal } = {}) {
-	const debug = self._debug ? { label: "data" } : void 0;
-	switch (self.cachedTags.planarConfiguration) {
-		case PlanarConfiguration.Contig: return (await getTiles(self.image, xy, self.dataSource, {
-			signal,
-			debug
-		})).map((tile, i) => {
-			if (tile === null) {
-				const [x, y] = xy[i];
-				throw new Error(`Tile at (${x}, ${y}) not found`);
-			}
-			return tile;
-		});
-		case PlanarConfiguration.Separate: return fetchBandSeparateTileBytesMultiple(self, xy, { signal });
-		default: throw new Error(`Unsupported PlanarConfiguration: ${self.cachedTags.planarConfiguration}`);
-	}
-}
-/**
-* Batched, range-coalescing counterpart to {@link fetchBandSeparateTileBytes}.
-* Every band of every requested tile is flattened into a single
-* {@link getMultipleBytes} call, so coalescing can merge ranges across both
-* bands and neighbouring tiles; the results are regrouped per tile afterwards.
-*/
-async function fetchBandSeparateTileBytesMultiple(self, xy, { signal } = {}) {
-	const debug = self._debug ? { label: "data" } : void 0;
-	const numBands = self.cachedTags.samplesPerPixel;
-	const flatRanges = (await Promise.all(xy.map(([x, y]) => findBandSeparateTileByteRanges(self, x, y)))).flatMap((ranges) => ranges.map(({ offset, imageSize }) => ({
-		offset,
-		byteCount: imageSize
-	})));
-	const flatResults = await getMultipleBytes(self.image, flatRanges, self.dataSource, {
-		signal,
-		debug
-	});
-	return xy.map(([x, y], t) => flatResults.slice(t * numBands, t * numBands + numBands).map((res) => {
-		if (res === null) throw new Error(`Tile at (${x}, ${y}) not found`);
-		return res;
-	}));
-}
-/**
-* Load a tile into an ArrayBuffer.
-*
-* If the tile compression is JPEG, this will also apply the JPEG compression
-* tables to the resulting ArrayBuffer (see `image.getJpegHeader`).
-*
-* Though this function lives upstream in @cogeotiff/core, we vendor it here
-* so we can route the *tile data* read through a separate source. The tile's
-* byte range is looked up via `image.getTileSize(idx)`, which inside cogeotiff
-* uses the source that was passed to `Tiff.create` (our header source — cached
-* for small repeated reads). The actual tile bytes are then fetched from
-* `dataSource`, which is the raw HTTP source with no caching: tile data is
-* large and read once, so caching it would just evict header metadata.
-*/
-async function getTile(image, x, y, dataSource, options) {
-	const { size, tileSize: tiles } = image;
-	if (tiles == null) throw new Error("Tiff is not tiled");
-	const nyTiles = Math.ceil(size.height / tiles.height);
-	const nxTiles = Math.ceil(size.width / tiles.width);
-	if (x >= nxTiles || y >= nyTiles) throw new Error(`Tile index is outside of range x:${x} >= ${nxTiles} or y:${y} >= ${nyTiles}`);
-	const idx = y * nxTiles + x;
-	const totalTiles = nxTiles * nyTiles;
-	if (idx >= totalTiles) throw new Error(`Tile index is outside of tile range: ${idx} >= ${totalTiles}`);
-	const { offset, imageSize } = await image.getTileSize(idx);
-	return getBytes(image, offset, imageSize, dataSource, options);
-}
-/**
-* Read image bytes at the given offset from `dataSource`.
-*
-* Though this function lives upstream in @cogeotiff/core, we vendor it here
-* so we can route reads through the data source (uncached) rather than the
-* header source (cached) that cogeotiff would use by default. Tile data is
-* large and read once; caching it would evict header metadata and inflate
-* memory.
-*/
-async function getBytes(image, offset, byteCount, dataSource, options) {
-	if (byteCount === 0) return null;
-	if (options?.debug !== void 0) console.log(`[geotiff dataSource] ${options.debug.label}: offset=${offset} length=${byteCount}`);
-	const bytes = await dataSource.fetch(offset, byteCount, options);
-	if (bytes.byteLength < byteCount) throw new Error(`Failed to fetch bytes from offset:${offset} wanted:${byteCount} got:${bytes.byteLength}`);
-	const compression = image.value(TiffTag.Compression) ?? Compression.None;
-	if (compression === Compression.Jpeg) return {
-		bytes: image.getJpegHeader(bytes),
-		compression
-	};
-	return {
-		bytes,
-		compression
-	};
-}
-/**
-* Read image bytes for multiple ranges in a single batched I/O round trip.
-*
-* Vectorized counterpart to {@link getBytes}. The non-sparse ranges are
-* dispatched through {@link coalesceRanges}, which merges nearby byte ranges
-* into fewer `dataSource.fetch` calls. Returns one entry per input range, in
-* input order; sparse ranges (`offset === 0` or `byteCount === 0`) yield `null`,
-* matching {@link getBytes}.
-*
-* Vendored from cogeotiff PR #1463 (`TiffImage.getMultipleBytes`) for the same
-* reason as {@link getBytes}: tile data must read through the uncached
-* `dataSource` rather than the cached header source. Upstream also lets a
-* `Source` provide its own `fetchRanges`; `@cogeotiff/core@9.5.0` has no such
-* interface method and `dataSource` is only `Pick<Source, "fetch">`, so the
-* coalescing here is always done locally.
-*/
-async function getMultipleBytes(image, ranges, dataSource, options) {
-	if (ranges.length === 0) return [];
-	const results = new Array(ranges.length);
-	const realRanges = [];
-	const realIndices = [];
-	for (let i = 0; i < ranges.length; i++) {
-		const range = ranges[i];
-		if (range.offset === 0 || range.byteCount === 0) results[i] = null;
-		else {
-			realIndices.push(i);
-			realRanges.push({
-				offset: range.offset,
-				length: range.byteCount
-			});
-		}
-	}
-	if (realRanges.length === 0) return results;
-	if (options?.debug !== void 0) for (const r of realRanges) console.log(`[geotiff dataSource] ${options.debug.label}: offset=${r.offset} length=${r.length}`);
-	const fetched = await coalesceRanges(dataSource, realRanges, {
-		coalesce: options?.coalesce,
-		maxRangeSize: options?.maxRangeSize,
-		signal: options?.signal
-	});
-	const compression = image.value(TiffTag.Compression) ?? Compression.None;
-	for (let k = 0; k < fetched.length; k++) {
-		const i = realIndices[k];
-		const raw = fetched[k];
-		results[i] = {
-			bytes: compression === Compression.Jpeg ? image.getJpegHeader(raw) : raw,
-			compression
-		};
-	}
-	return results;
-}
-/**
-* Load multiple tiles in a single batched I/O round trip.
-*
-* Resolves the offset/size of every requested tile via `image.getTileSize`
-* (header-source reads — small entries, served by the chunk cache), then fetches
-* the tile data through {@link getMultipleBytes} (uncached `dataSource`, with
-* range coalescing). Returns one entry per input tile, in input order; sparse
-* tiles yield `null` matching {@link getBytes}.
-*
-* Vendored from cogeotiff PR #1463 (`TiffImage.getTiles`) for the same reason as
-* {@link getTile}: the tile-data read must route through `dataSource`.
-*/
-async function getTiles(image, xy, dataSource, options) {
-	if (xy.length === 0) return [];
-	const { size, tileSize } = image;
-	if (tileSize == null) throw new Error("Tiff is not tiled");
-	const nyTiles = Math.ceil(size.height / tileSize.height);
-	const nxTiles = Math.ceil(size.width / tileSize.width);
-	const totalTiles = nxTiles * nyTiles;
-	const indices = xy.map(([x, y]) => {
-		if (x >= nxTiles || y >= nyTiles) throw new Error(`Tile index is outside of range x:${x} >= ${nxTiles} or y:${y} >= ${nyTiles}`);
-		const idx = y * nxTiles + x;
-		if (idx >= totalTiles) throw new Error(`Tile index is outside of tile range: ${idx} >= ${totalTiles}`);
-		return idx;
-	});
-	return getMultipleBytes(image, (await Promise.all(indices.map((i) => image.getTileSize(i)))).map((s) => ({
-		offset: s.offset,
-		byteCount: s.imageSize
-	})), dataSource, options);
-}
-/**
-* Clip a decoded tile array to the valid image bounds.
-*
-* Edge tiles in a COG are always encoded at the full tile size, with the
-* out-of-bounds region zero-padded. When `boundless=false` is requested, this
-* function copies only the valid pixel sub-rectangle into a new typed array,
-* returning a `RasterArray` whose `width`/`height` match the actual image
-* content rather than the tile dimensions.
-*
-* Interior tiles (where the tile fits entirely within the image) are returned
-* unchanged.
-*/
-function clipToImageBounds(self, x, y, array) {
-	const { width: clippedWidth, height: clippedHeight } = self.image.getTileBounds(x, y);
-	if (clippedWidth === self.tileWidth && clippedHeight === self.tileHeight) return array;
-	const clippedMask = array.mask ? clipRows(array.mask, self.tileWidth, clippedWidth, clippedHeight, 1) : array.mask;
-	if (array.layout === "pixel-interleaved") {
-		const { count, data } = array;
-		const clipped = clipRows(data, self.tileWidth, clippedWidth, clippedHeight, count);
-		return {
-			...array,
-			width: clippedWidth,
-			height: clippedHeight,
-			data: clipped,
-			mask: clippedMask
-		};
-	}
-	const { bands } = array;
-	const clippedBands = bands.map((band) => clipRows(band, self.tileWidth, clippedWidth, clippedHeight, 1));
-	return {
-		...array,
-		width: clippedWidth,
-		height: clippedHeight,
-		bands: clippedBands,
-		mask: clippedMask
-	};
-}
-/**
-* Copy rows from a strided typed array, keeping only `clippedWidth * samplesPerPixel`
-* values per row out of `tileWidth * samplesPerPixel`.
-*/
-function clipRows(src, tileWidth, clippedWidth, clippedHeight, samplesPerPixel) {
-	const srcStride = tileWidth * samplesPerPixel;
-	const dstStride = clippedWidth * samplesPerPixel;
-	const dst = new src.constructor(dstStride * clippedHeight);
-	for (let r = 0; r < clippedHeight; r++) dst.set(src.subarray(r * srcStride, r * srcStride + dstStride), r * dstStride);
-	return dst;
-}
-function getUniqueSampleFormat(sampleFormats, bitsPerSamples) {
-	const uniqueSampleFormats = new Set(sampleFormats);
-	const uniqueBitsPerSample = new Set(bitsPerSamples);
-	if (uniqueSampleFormats.size > 1) throw new Error("Multiple sample formats are not supported.");
-	if (uniqueBitsPerSample.size > 1) throw new Error("Multiple bits per sample values are not supported.");
-	const sampleFormat = sampleFormats[0];
-	const bitsPerSample = bitsPerSamples[0];
-	if (sampleFormat === void 0 || bitsPerSample === void 0) throw new Error("SampleFormat and BitsPerSample arrays cannot be empty.");
-	return {
-		sampleFormat,
-		bitsPerSample
-	};
-}
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/gdal-metadata.js
-function parseGDALMetadata(gdalMetadata, { count }) {
-	if (gdalMetadata == null) return null;
-	const root = new DOMParser().parseFromString(gdalMetadata, "text/xml").documentElement;
-	if (root.tagName !== "GDALMetadata") throw new Error("Not a GDALMetadata XML block");
-	const bandStatistics = /* @__PURE__ */ new Map();
-	const offsets = Array(count).fill(0);
-	const scales = Array(count).fill(1);
-	const getOrCreateBand = (sample) => {
-		const idx = parseInt(sample, 10) + 1;
-		if (!bandStatistics.has(idx)) bandStatistics.set(idx, {
-			max: null,
-			min: null,
-			mean: null,
-			std: null,
-			validPercent: null
-		});
-		return bandStatistics.get(idx);
-	};
-	for (const elem of Array.from(root.querySelectorAll("Item"))) {
-		const name = elem.getAttribute("name");
-		const sample = elem.getAttribute("sample");
-		const text = elem.textContent ?? "";
-		if (sample === null) continue;
-		switch (name) {
-			case "STATISTICS_MAXIMUM":
-				getOrCreateBand(sample).max = parseFloat(text);
-				break;
-			case "STATISTICS_MEAN":
-				getOrCreateBand(sample).mean = parseFloat(text);
-				break;
-			case "STATISTICS_MINIMUM":
-				getOrCreateBand(sample).min = parseFloat(text);
-				break;
-			case "STATISTICS_STDDEV":
-				getOrCreateBand(sample).std = parseFloat(text);
-				break;
-			case "STATISTICS_VALID_PERCENT":
-				getOrCreateBand(sample).validPercent = parseFloat(text);
-				break;
-			case "OFFSET":
-				offsets[parseInt(sample, 10)] = parseFloat(text);
-				break;
-			case "SCALE":
-				scales[parseInt(sample, 10)] = parseFloat(text);
-				break;
-		}
-	}
-	return {
-		bandStatistics,
-		offsets,
-		scales
-	};
-}
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/ifd.js
-/** Pre-fetch TIFF tags for easier visualization. */
-async function prefetchTags(image, options = {}) {
-	const { signal } = options;
-	const compression = image.value(TiffTag.Compression);
-	if (compression === null) throw new Error("Compression tag should always exist.");
-	const [bitsPerSample, colorMap, gdalNoData, gdalMetadata, lercParameters, modelPixelScale, modelTiepoint, modelTransformation, photometric, planarConfiguration, predictor, sampleFormat, samplesPerPixel] = await Promise.all([
-		image.fetch(TiffTag.BitsPerSample, { signal }),
-		image.fetch(TiffTag.ColorMap, { signal }),
-		image.fetch(TiffTag.GdalNoData, { signal }),
-		image.fetch(TiffTag.GdalMetadata, { signal }),
-		image.fetch(TiffTag.LercParameters, { signal }),
-		image.fetch(TiffTag.ModelPixelScale, { signal }),
-		image.fetch(TiffTag.ModelTiePoint, { signal }),
-		image.fetch(TiffTag.ModelTransformation, { signal }),
-		image.fetch(TiffTag.Photometric, { signal }),
-		image.fetch(TiffTag.PlanarConfiguration, { signal }),
-		image.fetch(TiffTag.Predictor, { signal }),
-		image.fetch(TiffTag.SampleFormat, { signal }),
-		image.fetch(TiffTag.SamplesPerPixel, { signal })
-	]);
-	const missingTag = (tagName) => {
-		throw new Error(`${tagName} tag should always exist.`);
-	};
-	if (bitsPerSample === null) missingTag("BitsPerSample");
-	if (samplesPerPixel === null) missingTag("SamplesPerPixel");
-	if (photometric === null) missingTag("Photometric");
-	return {
-		bitsPerSample: new Uint16Array(bitsPerSample),
-		colorMap: colorMap ? new Uint16Array(colorMap) : void 0,
-		compression,
-		gdalMetadata,
-		lercParameters,
-		modelTiepoint,
-		modelPixelScale,
-		modelTransformation,
-		nodata: gdalNoData !== null ? Number(gdalNoData) : null,
-		photometric,
-		planarConfiguration: planarConfiguration ?? PlanarConfiguration.Contig,
-		predictor: predictor ?? Predictor.None,
-		sampleFormat: sampleFormat ?? [SampleFormat.Uint],
-		samplesPerPixel
-	};
-}
-function extractGeoKeyDirectory(image) {
-	const geo = (key) => image.valueGeo(key) ?? null;
-	return {
-		modelType: geo(TiffTagGeo.GTModelTypeGeoKey),
-		rasterType: geo(TiffTagGeo.GTRasterTypeGeoKey),
-		citation: geo(TiffTagGeo.GTCitationGeoKey),
-		geodeticCRS: geo(TiffTagGeo.GeodeticCRSGeoKey),
-		geodeticCitation: geo(TiffTagGeo.GeodeticCitationGeoKey),
-		geodeticDatum: geo(TiffTagGeo.GeodeticDatumGeoKey),
-		primeMeridian: geo(TiffTagGeo.PrimeMeridianGeoKey),
-		linearUnits: geo(TiffTagGeo.GeogLinearUnitsGeoKey),
-		linearUnitSize: geo(TiffTagGeo.GeogLinearUnitSizeGeoKey),
-		angularUnits: geo(TiffTagGeo.GeogAngularUnitsGeoKey),
-		angularUnitSize: geo(TiffTagGeo.GeogAngularUnitSizeGeoKey),
-		ellipsoid: geo(TiffTagGeo.EllipsoidGeoKey),
-		ellipsoidSemiMajorAxis: geo(TiffTagGeo.EllipsoidSemiMajorAxisGeoKey),
-		ellipsoidSemiMinorAxis: geo(TiffTagGeo.EllipsoidSemiMinorAxisGeoKey),
-		ellipsoidInvFlattening: geo(TiffTagGeo.EllipsoidInvFlatteningGeoKey),
-		azimuthUnits: geo(TiffTagGeo.GeogAzimuthUnitsGeoKey),
-		primeMeridianLongitude: geo(TiffTagGeo.PrimeMeridianLongitudeGeoKey),
-		toWGS84: geo(TiffTagGeo.GeogTOWGS84GeoKey),
-		projectedCRS: geo(TiffTagGeo.ProjectedCRSGeoKey),
-		projectedCitation: geo(TiffTagGeo.ProjectedCitationGeoKey),
-		projection: geo(TiffTagGeo.ProjectionGeoKey),
-		projMethod: geo(TiffTagGeo.ProjMethodGeoKey),
-		projLinearUnits: geo(TiffTagGeo.ProjLinearUnitsGeoKey),
-		projLinearUnitSize: geo(TiffTagGeo.ProjLinearUnitSizeGeoKey),
-		projStdParallel1: geo(TiffTagGeo.ProjStdParallel1GeoKey),
-		projStdParallel2: geo(TiffTagGeo.ProjStdParallel2GeoKey),
-		projNatOriginLong: geo(TiffTagGeo.ProjNatOriginLongGeoKey),
-		projNatOriginLat: geo(TiffTagGeo.ProjNatOriginLatGeoKey),
-		projFalseEasting: geo(TiffTagGeo.ProjFalseEastingGeoKey),
-		projFalseNorthing: geo(TiffTagGeo.ProjFalseNorthingGeoKey),
-		projFalseOriginLong: geo(TiffTagGeo.ProjFalseOriginLongGeoKey),
-		projFalseOriginLat: geo(TiffTagGeo.ProjFalseOriginLatGeoKey),
-		projFalseOriginEasting: geo(TiffTagGeo.ProjFalseOriginEastingGeoKey),
-		projFalseOriginNorthing: geo(TiffTagGeo.ProjFalseOriginNorthingGeoKey),
-		projCenterLong: geo(TiffTagGeo.ProjCenterLongGeoKey),
-		projCenterLat: geo(TiffTagGeo.ProjCenterLatGeoKey),
-		projCenterEasting: geo(TiffTagGeo.ProjCenterEastingGeoKey),
-		projCenterNorthing: geo(TiffTagGeo.ProjCenterNorthingGeoKey),
-		projScaleAtNatOrigin: geo(TiffTagGeo.ProjScaleAtNatOriginGeoKey),
-		projScaleAtCenter: geo(TiffTagGeo.ProjScaleAtCenterGeoKey),
-		projAzimuthAngle: geo(TiffTagGeo.ProjAzimuthAngleGeoKey),
-		projStraightVertPoleLong: geo(TiffTagGeo.ProjStraightVertPoleLongGeoKey),
-		projRectifiedGridAngle: geo(TiffTagGeo.ProjRectifiedGridAngleGeoKey),
-		verticalCRS: geo(TiffTagGeo.VerticalGeoKey),
-		verticalCitation: geo(TiffTagGeo.VerticalCitationGeoKey),
-		verticalDatum: geo(TiffTagGeo.VerticalDatumGeoKey),
-		verticalUnits: geo(TiffTagGeo.VerticalUnitsGeoKey)
-	};
-}
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/transform.js
-function createTransform({ modelTiepoint, modelPixelScale, modelTransformation, rasterType }) {
-	let transform;
-	if (modelTiepoint && modelPixelScale) transform = createFromModelTiepointAndPixelScale(modelTiepoint, modelPixelScale);
-	else if (modelTransformation) transform = createFromModelTransformation(modelTransformation);
-	else throw new Error("The image does not have an affine transformation.");
-	if (rasterType === RasterTypeKey.PixelIsPoint) transform = compose(transform, translation(-.5, -.5));
-	return transform;
-}
-function createFromModelTiepointAndPixelScale(modelTiepoint, modelPixelScale) {
-	const xOrigin = modelTiepoint[3];
-	const yOrigin = modelTiepoint[4];
-	return [
-		modelPixelScale[0],
-		0,
-		xOrigin,
-		0,
-		-modelPixelScale[1],
-		yOrigin
-	];
-}
-function createFromModelTransformation(modelTransformation) {
-	const xOrigin = modelTransformation[3];
-	const yOrigin = modelTransformation[7];
-	const rowRotation = modelTransformation[1];
-	const colRotation = modelTransformation[4];
-	return [
-		modelTransformation[0],
-		rowRotation,
-		xOrigin,
-		colRotation,
-		modelTransformation[5],
-		yOrigin
-	];
-}
-/**
-* 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.
-*/
-function index(self, x, y, op = Math.floor) {
-	const [col, row] = apply(invert$2(self.transform), x, y);
-	return [op(row), op(col)];
-}
-/**
-* 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.
-*/
-function xy(self, row, col, offset = "center") {
-	let c;
-	let r;
-	switch (offset) {
-		case "center":
-			c = col + .5;
-			r = row + .5;
-			break;
-		case "ul":
-			c = col;
-			r = row;
-			break;
-		case "ur":
-			c = col + 1;
-			r = row;
-			break;
-		case "ll":
-			c = col;
-			r = row + 1;
-			break;
-		case "lr":
-			c = col + 1;
-			r = row + 1;
-			break;
-	}
-	return apply(self.transform, c, r);
-}
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/overview.js
-/**
-* A single resolution level of a GeoTIFF — either the full-resolution image
-* or a reduced-resolution overview.  Pairs the data IFD with its
-* corresponding mask IFD (if any).
-*/
-var Overview = class {
-	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(geotiff, gkd, image, maskImage, cachedTags, dataSource) {
-		this.geotiff = geotiff;
-		this.gkd = gkd;
-		this.image = image;
-		this.maskImage = maskImage;
-		this.cachedTags = cachedTags;
-		this.dataSource = dataSource;
-	}
-	/**
-	* 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 fullTransform = this.geotiff.transform;
-		return compose(fullTransform, scale$3(this.geotiff.width / this.width, this.geotiff.height / this.height));
-	}
-	/** 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(x, y, options = {}) {
-		return await fetchTile(this, x, y, options);
-	}
-	/**
-	* 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(xy, options = {}) {
-		return await fetchTiles(this, xy, options);
-	}
-	/**
-	* 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(x, y, op = Math.floor) {
-		return index(this, x, y, op);
-	}
-	/**
-	* 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(row, col, offset = "center") {
-		return xy(this, row, col, offset);
-	}
-};
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/geotiff.js
-/**
-* A high-level GeoTIFF abstraction built on
-* {@link https://github.com/blacha/cogeotiff | @cogeotiff/core}'s `Tiff` and
-* `TiffImage` classes.
-*
-* This class separates data IFDs from mask IFDs, pairs them by resolution
-* level, and exposes sorted overviews. Intentionally mirrors the Python
-* {@link https://github.com/developmentseed/async-geotiff | async-geotiff} API
-* as closely as possible.
-*
-* Construct via {@link GeoTIFF.fromUrl}, {@link GeoTIFF.fromArrayBuffer},
-* {@link GeoTIFF.open} or {@link GeoTIFF.fromTiff}.
-*
-* @see {@link Overview} for reduced-resolution overview images.
-*/
-var GeoTIFF = class GeoTIFF {
-	/**
-	* 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(tiff, image, maskImage, gkd, overviews, cachedTags, dataSource, gdalMetadata, debug) {
-		this.tiff = tiff;
-		this.image = image;
-		this.maskImage = maskImage;
-		this.gkd = gkd;
-		this.overviews = overviews;
-		this.cachedTags = cachedTags;
-		this.dataSource = dataSource;
-		this.gdalMetadata = gdalMetadata;
-		this._debug = debug;
-	}
-	/**
-	* 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(options) {
-		const { dataSource, headerSource, signal, debug } = options;
-		const tiff = await new Tiff(headerSource).init({ signal });
-		tiff.options = void 0;
-		return GeoTIFF.fromTiff(tiff, dataSource, {
-			signal,
-			debug
-		});
-	}
-	/**
-	* 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(tiff, dataSource, options = {}) {
-		const { signal, debug = false } = options;
-		const images = tiff.images;
-		if (images.length === 0) throw new Error("TIFF does not contain any IFDs");
-		await Promise.all(images.map((image) => image.init(true, { signal })));
-		const primaryImage = images[0];
-		const gkd = extractGeoKeyDirectory(primaryImage);
-		const dataIFDs = /* @__PURE__ */ new Map();
-		const maskIFDs = /* @__PURE__ */ new Map();
-		for (let i = 1; i < images.length; i++) {
-			const image = images[i];
-			const size = image.size;
-			const key = `${size.width},${size.height}`;
-			if (isMaskIfd(image)) maskIFDs.set(key, image);
-			else dataIFDs.set(key, image);
-		}
-		const primaryKey = `${primaryImage.size.width},${primaryImage.size.height}`;
-		const primaryMask = maskIFDs.get(primaryKey) ?? null;
-		const dataEntries = Array.from(dataIFDs.entries());
-		dataEntries.sort((a, b) => {
-			const sa = a[1].size;
-			const sb = b[1].size;
-			return sb.width * sb.height - sa.width * sa.height;
-		});
-		const cachedTags = await prefetchTags(primaryImage, { signal });
-		const geotiff = new GeoTIFF(tiff, primaryImage, primaryMask, gkd, [], cachedTags, dataSource, parseGDALMetadata(cachedTags.gdalMetadata, { count: cachedTags.samplesPerPixel }), debug);
-		geotiff.overviews = dataEntries.map(([key, dataImage]) => {
-			return new Overview(geotiff, gkd, dataImage, maskIFDs.get(key) ?? null, cachedTags, dataSource);
-		});
-		return geotiff;
-	}
-	/**
-	* 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(input) {
-		const source = new SourceMemory("memory://input.tif", input);
-		return await GeoTIFF.open({
-			dataSource: source,
-			headerSource: source
-		});
-	}
-	/**
-	* 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(url, { chunkSize = 64 * 1024, cacheSize = 8 * 1024 * 1024, signal, debug } = {}) {
-		const source = new SourceHttp(url, {});
-		source.metadata = { size: Number.POSITIVE_INFINITY };
-		const view = new SourceView(source, [new SourceChunk({ size: chunkSize }), new SourceCache({ size: cacheSize })]);
-		return await GeoTIFF.open({
-			dataSource: source,
-			headerSource: view,
-			signal,
-			debug
-		});
-	}
-	/**
-	* 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() {
-		if (this._crs === void 0) this._crs = crsFromGeoKeys(this.gkd);
-		return 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 stats = this.gdalMetadata?.bandStatistics;
-		return stats && stats.size > 0 ? stats : 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(TiffTag.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, modelTiepoint, modelTransformation } = this.cachedTags;
-		return createTransform({
-			modelTiepoint,
-			modelPixelScale,
-			modelTransformation,
-			rasterType: this.gkd.rasterType
-		});
-	}
-	/** 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(x, y, options = {}) {
-		return await fetchTile(this, x, y, options);
-	}
-	/**
-	* 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(xy, options = {}) {
-		return await fetchTiles(this, xy, options);
-	}
-	/**
-	* 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(x, y, op = Math.floor) {
-		return index(this, x, y, op);
-	}
-	/**
-	* 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(row, col, offset = "center") {
-		return xy(this, row, col, offset);
-	}
-};
-/**
-* Determine whether a TiffImage is a mask IFD.
-*
-* A mask IFD has SubFileType with the Mask bit set (value 4) AND
-* PhotometricInterpretation === Mask (4).
-*/
-function isMaskIfd(image) {
-	const subFileType = image.value(TiffTag.SubFileType);
-	const photometric = image.value(TiffTag.Photometric);
-	return subFileType !== null && (subFileType & SubFileType.Mask) !== 0 && photometric === Photometric.Mask;
-}
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/pool/wrapper.js
-/**
-* Wraps a Worker, tracking in-flight jobs and routing responses via jobId.
-*/
-var WorkerWrapper = class {
-	worker;
-	jobIdCounter = 0;
-	jobs = /* @__PURE__ */ new Map();
-	constructor(worker) {
-		this.worker = worker;
-		this.worker.addEventListener("message", (e) => this.onMessage(e));
-	}
-	get jobCount() {
-		return this.jobs.size;
-	}
-	onMessage(e) {
-		const { jobId, error, pixels } = e.data;
-		const job = this.jobs.get(jobId);
-		this.jobs.delete(jobId);
-		if (!job) return;
-		if (error) job.reject(new Error(error));
-		else job.resolve(pixels);
-	}
-	submitJob(request, transferables) {
-		const jobId = this.jobIdCounter++;
-		return new Promise((resolve, reject) => {
-			this.jobs.set(jobId, {
-				resolve,
-				reject
-			});
-			this.worker.postMessage({
-				...request,
-				jobId
-			}, { transfer: transferables });
-		});
-	}
-	terminate() {
-		this.worker.terminate();
-	}
-};
-//#endregion
-//#region node_modules/@developmentseed/geotiff/dist/pool/pool.js
-var defaultSize = typeof navigator !== "undefined" ? navigator.hardwareConcurrency ?? 2 : 2;
-/**
-* Manages a pool of Web Workers for off-main-thread tile decoding.
-*
-* Use {@link defaultDecoderPool} to create a pool backed by the built-in,
-* default decompressors.
-*
-* When no `createWorker` factory is provided, decoding falls back to the main
-* thread. This lets the pool be constructed unconditionally and wired up with
-* a worker later (or never, for SSR / Node environments).
-*/
-var DecoderPool = class {
-	workerWrappers;
-	constructor(options = {}) {
-		const { size = defaultSize, createWorker } = options;
-		this.workerWrappers = [];
-		if (createWorker && size > 0) for (let i = 0; i < size; i++) this.workerWrappers.push(new WorkerWrapper(createWorker()));
-	}
-	/** 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(bytes, compression, metadata) {
-		if (!this.hasWorkers) return decode$1(bytes, compression, metadata);
-		const worker = this.leastLoaded();
-		const request = {
-			compression,
-			metadata,
-			buffer: bytes
-		};
-		return await worker.submitJob(request, [bytes]);
-	}
-	/** Terminate all workers and release resources. */
-	destroy() {
-		for (const w of this.workerWrappers) w.terminate();
-		this.workerWrappers.length = 0;
-	}
-	leastLoaded() {
-		let best = this.workerWrappers[0];
-		for (let i = 1; i < this.workerWrappers.length; i++) if (this.workerWrappers[i].jobCount < best.jobCount) best = this.workerWrappers[i];
-		return best;
-	}
-};
-/**
-* A default DecoderPool instance.
-*
-* It will be created on first call of `defaultDecoderPool`.
-*/
-var DEFAULT_POOL = null;
-/**
-* Create a default `DecoderPool` backed by the built-in worker.
-*
-* A cached decoder pool instance is returned on subsequent calls.
-*
-* You may want to create it lazily (rather than as a module-level singleton)
-* to keep the `new URL(…, import.meta.url)` out of the module's static
-* initialisation, so bundlers that build IIFE/UMD outputs don't try to inline
-* the worker at build time.
-*
-* @example
-* Create a default decoder pool:
-* ```
-* const pool = defaultDecoderPool();
-* ```
-*/
-function defaultDecoderPool() {
-	if (DEFAULT_POOL !== null) return DEFAULT_POOL;
-	DEFAULT_POOL = new DecoderPool({ createWorker: () => new Worker(new URL(
-		/* @vite-ignore */
-		"/assets/worker-CcHZ_QZT.js",
-		"" + import.meta.url
-	), { type: "module" }) });
-	return DEFAULT_POOL;
-}
-//#endregion
-//#region node_modules/proj4/lib/global.js
-function global_default(defs) {
-	defs("EPSG:4326", "+title=WGS 84 (long/lat) +proj=longlat +ellps=WGS84 +datum=WGS84 +units=degrees");
-	defs("EPSG:4269", "+title=NAD83 (long/lat) +proj=longlat +a=6378137.0 +b=6356752.31414036 +ellps=GRS80 +datum=NAD83 +units=degrees");
-	defs("EPSG:3857", "+title=WGS 84 / Pseudo-Mercator +proj=merc +a=6378137 +b=6378137 +lat_ts=0.0 +lon_0=0.0 +x_0=0.0 +y_0=0 +k=1.0 +units=m +nadgrids=@null +no_defs");
-	for (var i = 1; i <= 60; ++i) {
-		defs("EPSG:" + (32600 + i), "+proj=utm +zone=" + i + " +datum=WGS84 +units=m");
-		defs("EPSG:" + (32700 + i), "+proj=utm +zone=" + i + " +south +datum=WGS84 +units=m");
-	}
-	defs("EPSG:5041", "+title=WGS 84 / UPS North (E,N) +proj=stere +lat_0=90 +lon_0=0 +k=0.994 +x_0=2000000 +y_0=2000000 +datum=WGS84 +units=m");
-	defs("EPSG:5042", "+title=WGS 84 / UPS South (E,N) +proj=stere +lat_0=-90 +lon_0=0 +k=0.994 +x_0=2000000 +y_0=2000000 +datum=WGS84 +units=m");
-	defs.WGS84 = defs["EPSG:4326"];
-	defs["EPSG:3785"] = defs["EPSG:3857"];
-	defs.GOOGLE = defs["EPSG:3857"];
-	defs["EPSG:900913"] = defs["EPSG:3857"];
-	defs["EPSG:102113"] = defs["EPSG:3857"];
-}
-//#endregion
-//#region node_modules/proj4/lib/constants/values.js
-var SRS_WGS84_SEMIMAJOR = 6378137;
-var SRS_WGS84_SEMIMINOR = 6356752.314;
-var SRS_WGS84_ESQUARED = .0066943799901413165;
-var SEC_TO_RAD = 484813681109536e-20;
-var HALF_PI = Math.PI / 2;
-var SIXTH = .16666666666666666;
-var RA4 = .04722222222222222;
-var RA6 = .022156084656084655;
-var EPSLN = 1e-10;
-var D2R = .017453292519943295;
-var R2D = 57.29577951308232;
-var FORTPI = Math.PI / 4;
-var TWO_PI = Math.PI * 2;
-var SPI = 3.14159265359;
-//#endregion
-//#region node_modules/proj4/lib/constants/PrimeMeridian.js
-var primeMeridian = {};
-primeMeridian.greenwich = 0;
-primeMeridian.lisbon = -9.131906111111;
-primeMeridian.paris = 2.337229166667;
-primeMeridian.bogota = -74.080916666667;
-primeMeridian.madrid = -3.687938888889;
-primeMeridian.rome = 12.452333333333;
-primeMeridian.bern = 7.439583333333;
-primeMeridian.jakarta = 106.807719444444;
-primeMeridian.ferro = -17.666666666667;
-primeMeridian.brussels = 4.367975;
-primeMeridian.stockholm = 18.058277777778;
-primeMeridian.athens = 23.7163375;
-primeMeridian.oslo = 10.722916666667;
-//#endregion
-//#region node_modules/proj4/lib/constants/units.js
-var units_default = {
-	mm: { to_meter: .001 },
-	cm: { to_meter: .01 },
-	ft: { to_meter: .3048 },
-	"us-ft": { to_meter: 1200 / 3937 },
-	fath: { to_meter: 1.8288 },
-	kmi: { to_meter: 1852 },
-	"us-ch": { to_meter: 20.1168402336805 },
-	"us-mi": { to_meter: 1609.34721869444 },
-	km: { to_meter: 1e3 },
-	"ind-ft": { to_meter: .30479841 },
-	"ind-yd": { to_meter: .91439523 },
-	mi: { to_meter: 1609.344 },
-	yd: { to_meter: .9144 },
-	ch: { to_meter: 20.1168 },
-	link: { to_meter: .201168 },
-	dm: { to_meter: .1 },
-	in: { to_meter: .0254 },
-	"ind-ch": { to_meter: 20.11669506 },
-	"us-in": { to_meter: .025400050800101 },
-	"us-yd": { to_meter: .914401828803658 }
-};
-//#endregion
-//#region node_modules/proj4/lib/match.js
-var ignoredChar = /[\s_\-\/\(\)]/g;
-function match(obj, key) {
-	if (obj[key]) return obj[key];
-	var keys = Object.keys(obj);
-	var lkey = key.toLowerCase().replace(ignoredChar, "");
-	var i = -1;
-	var testkey, processedKey;
-	while (++i < keys.length) {
-		testkey = keys[i];
-		processedKey = testkey.toLowerCase().replace(ignoredChar, "");
-		if (processedKey === lkey) return obj[testkey];
-	}
-}
-//#endregion
-//#region node_modules/proj4/lib/projString.js
-/**
-* @param {string} defData
-* @returns {import('./defs').ProjectionDefinition}
+* @param {string} defData
+* @returns {import('./defs').ProjectionDefinition}
 */
 function projString_default(defData) {
 	/** @type {import('./defs').ProjectionDefinition} */
@@ -17649,667 +16284,958 @@ var COGLayer = class extends RasterTileLayer {
 		};
 		return wrapped;
 	}
-	_renderTileCallback() {
-		const userFn = this.props.renderTile ?? this.state.defaultRenderTile;
-		if (!userFn) return;
-		return userFn;
+	_renderTileCallback() {
+		const userFn = this.props.renderTile ?? this.state.defaultRenderTile;
+		if (!userFn) return;
+		return userFn;
+	}
+};
+//#endregion
+//#region node_modules/flatqueue/index.js
+/**
+* @typedef {Float64ArrayConstructor | Float32ArrayConstructor |
+*   Uint32ArrayConstructor | Int32ArrayConstructor | Uint16ArrayConstructor |
+*   Int16ArrayConstructor | Uint8ArrayConstructor | Int8ArrayConstructor} TypedArrayConstructor
+*/
+/** @template [T=number] */
+var FlatQueue = class {
+	/**
+	* Creates an empty queue. If `capacity` is provided, the queue is backed by fixed-size typed
+	* arrays for better performance and memory use, but can't grow beyond `capacity`. `values` uses
+	* `ValuesArray` (default `Float64Array`) and `ids` uses `IdsArray` (default `Uint32Array`); pass
+	* narrower constructors like `Uint16Array` if your values or ids are known to fit them.
+	*
+	* @param {number} [capacity]
+	* @param {TypedArrayConstructor} [ValuesArray]
+	* @param {TypedArrayConstructor} [IdsArray]
+	*/
+	constructor(capacity = Infinity, ValuesArray = Float64Array, IdsArray = Uint32Array) {
+		const fixed = capacity !== Infinity;
+		/** @type {T[]} */
+		this.ids = fixed ? new IdsArray(capacity) : [];
+		/** @type {number[]} */
+		this.values = fixed ? new ValuesArray(capacity) : [];
+		/** Maximum number of items the queue can hold; `Infinity` for regular-array queues, which grow on demand. */
+		this.capacity = capacity;
+		/** Number of items in the queue. */
+		this.length = 0;
+	}
+	/** Removes all items from the queue. */
+	clear() {
+		this.length = 0;
+	}
+	/**
+	* Adds `item` to the queue with the specified `priority`.
+	*
+	* `priority` must be a number. Items are sorted and returned from low to high priority. Multiple items
+	* with the same priority value can be added to the queue, but there is no guaranteed order between these items.
+	*
+	* For fixed-capacity queues, throws a `RangeError` if the queue is already full.
+	*
+	* @param {T} item
+	* @param {number} priority
+	*/
+	push(item, priority) {
+		if (this.length === this.capacity) throw new RangeError("Queue is at capacity.");
+		let pos = this.length++;
+		while (pos > 0) {
+			const parent = pos - 1 >> 1;
+			const parentValue = this.values[parent];
+			if (priority >= parentValue) break;
+			this.ids[pos] = this.ids[parent];
+			this.values[pos] = parentValue;
+			pos = parent;
+		}
+		this.ids[pos] = item;
+		this.values[pos] = priority;
+	}
+	/**
+	* Removes and returns the item from the head of this queue, which is one of
+	* the items with the lowest priority. If this queue is empty, returns `undefined`.
+	*/
+	pop() {
+		if (this.length === 0) return void 0;
+		const ids = this.ids, values = this.values, top = ids[0], last = --this.length;
+		if (last > 0) {
+			const id = ids[last];
+			const value = values[last];
+			let pos = 0;
+			const halfLen = last >> 1;
+			while (pos < halfLen) {
+				const left = (pos << 1) + 1;
+				const right = left + 1;
+				const child = left + (+(right < last) & +(values[right] < values[left]));
+				if (values[child] >= value) break;
+				ids[pos] = ids[child];
+				values[pos] = values[child];
+				pos = child;
+			}
+			ids[pos] = id;
+			values[pos] = value;
+		}
+		return top;
+	}
+	/** Returns the item from the head of this queue without removing it. If this queue is empty, returns `undefined`. */
+	peek() {
+		return this.length > 0 ? this.ids[0] : void 0;
+	}
+	/**
+	* Returns the priority value of the item at the head of this queue without
+	* removing it. If this queue is empty, returns `undefined`.
+	*/
+	peekValue() {
+		return this.length > 0 ? this.values[0] : void 0;
+	}
+	/**
+	* Shrinks the internal arrays to `this.length`. No-op for queues with fixed capacity.
+	*
+	* `pop()` and `clear()` calls don't free memory automatically to avoid unnecessary resize operations.
+	* This also means that items that have been added to the queue can't be garbage collected until
+	* a new item is pushed in their place, or this method is called.
+	*/
+	shrink() {
+		if (Array.isArray(this.ids)) this.ids.length = this.length;
+		if (Array.isArray(this.values)) this.values.length = this.length;
+	}
+};
+//#endregion
+//#region node_modules/flatbush/index.js
+var ARRAY_TYPES = [
+	Int8Array,
+	Uint8Array,
+	Uint8ClampedArray,
+	Int16Array,
+	Uint16Array,
+	Int32Array,
+	Uint32Array,
+	Float32Array,
+	Float64Array
+];
+var VERSION = 3;
+/** @typedef {Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor} TypedArrayConstructor */
+/** @typedef {Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array} TypedArray */
+var Flatbush = class Flatbush {
+	/**
+	* Recreate a Flatbush index from raw `ArrayBuffer` or `SharedArrayBuffer` data.
+	* @param {ArrayBufferLike} data
+	* @param {number} [byteOffset=0] byte offset to the start of the Flatbush buffer in the referenced ArrayBuffer.
+	* @returns {Flatbush} index
+	*/
+	static from(data, byteOffset = 0) {
+		if (byteOffset % 8 !== 0) throw new Error("byteOffset must be 8-byte aligned.");
+		if (!data || data.byteLength === void 0 || "buffer" in data) throw new Error("Data must be an instance of ArrayBuffer or SharedArrayBuffer.");
+		const [magic, versionAndType] = new Uint8Array(data, byteOffset + 0, 2);
+		if (magic !== 251) throw new Error("Data does not appear to be in a Flatbush format.");
+		const version = versionAndType >> 4;
+		if (version !== VERSION) throw new Error(`Got v${version} data when expected v${VERSION}.`);
+		const ArrayType = ARRAY_TYPES[versionAndType & 15];
+		if (!ArrayType) throw new Error("Unrecognized array type.");
+		const [nodeSize] = new Uint16Array(data, byteOffset + 2, 1);
+		const [numItems] = new Uint32Array(data, byteOffset + 4, 1);
+		return new Flatbush(numItems, nodeSize, ArrayType, void 0, data, byteOffset);
+	}
+	/**
+	* Create a Flatbush index that will hold a given number of items.
+	* @param {number} numItems
+	* @param {number} [nodeSize=16] Size of the tree node (16 by default).
+	* @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
+	* @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used to store data (`ArrayBuffer` by default).
+	* @param {ArrayBufferLike} [data] (Only used internally)
+	* @param {number} [byteOffset=0] (Only used internally)
+	*/
+	constructor(numItems, nodeSize = 16, ArrayType = Float64Array, ArrayBufferType = ArrayBuffer, data, byteOffset = 0) {
+		if (numItems === void 0) throw new Error("Missing required argument: numItems.");
+		if (isNaN(numItems) || numItems <= 0) throw new Error(`Unexpected numItems value: ${numItems}.`);
+		this.numItems = +numItems;
+		this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
+		this.byteOffset = byteOffset;
+		let n = numItems;
+		let numNodes = n;
+		this._levelBounds = [n * 4];
+		do {
+			n = Math.ceil(n / this.nodeSize);
+			numNodes += n;
+			this._levelBounds.push(numNodes * 4);
+		} while (n !== 1);
+		this.ArrayType = ArrayType;
+		this.IndexArrayType = numNodes < 16384 ? Uint16Array : Uint32Array;
+		const arrayTypeIndex = ARRAY_TYPES.indexOf(ArrayType);
+		const nodesByteSize = numNodes * 4 * ArrayType.BYTES_PER_ELEMENT;
+		if (arrayTypeIndex < 0) throw new Error(`Unexpected typed array class: ${ArrayType}.`);
+		/** @type {new(b: ArrayBufferLike, o: number, l: number) => TypedArray} */
+		const BoxCtor = ArrayType;
+		/** @type {new(b: ArrayBufferLike, o: number, l: number) => Uint16Array | Uint32Array} */
+		const IdxCtor = this.IndexArrayType;
+		if (data) {
+			this.data = data;
+			this._boxes = new BoxCtor(data, byteOffset + 8, numNodes * 4);
+			this._indices = new IdxCtor(data, byteOffset + 8 + nodesByteSize, numNodes);
+			this._pos = numNodes * 4;
+			this.minX = this._boxes[this._pos - 4];
+			this.minY = this._boxes[this._pos - 3];
+			this.maxX = this._boxes[this._pos - 2];
+			this.maxY = this._boxes[this._pos - 1];
+		} else {
+			const data = this.data = new ArrayBufferType(8 + nodesByteSize + numNodes * this.IndexArrayType.BYTES_PER_ELEMENT);
+			this._boxes = new BoxCtor(data, 8, numNodes * 4);
+			this._indices = new IdxCtor(data, 8 + nodesByteSize, numNodes);
+			this._pos = 0;
+			this.minX = Infinity;
+			this.minY = Infinity;
+			this.maxX = -Infinity;
+			this.maxY = -Infinity;
+			new Uint8Array(data, 0, 2).set([251, (VERSION << 4) + arrayTypeIndex]);
+			new Uint16Array(data, 2, 1)[0] = nodeSize;
+			new Uint32Array(data, 4, 1)[0] = numItems;
+		}
+		/** @type FlatQueue<number> */
+		this._queue = new FlatQueue();
+	}
+	/**
+	* Add a given rectangle to the index.
+	* @param {number} minX
+	* @param {number} minY
+	* @param {number} maxX
+	* @param {number} maxY
+	* @returns {number} A zero-based, incremental number that represents the newly added rectangle.
+	*/
+	add(minX, minY, maxX = minX, maxY = minY) {
+		const index = this._pos >> 2;
+		const boxes = this._boxes;
+		this._indices[index] = index;
+		boxes[this._pos++] = minX;
+		boxes[this._pos++] = minY;
+		boxes[this._pos++] = maxX;
+		boxes[this._pos++] = maxY;
+		if (minX < this.minX) this.minX = minX;
+		if (minY < this.minY) this.minY = minY;
+		if (maxX > this.maxX) this.maxX = maxX;
+		if (maxY > this.maxY) this.maxY = maxY;
+		return index;
+	}
+	/** Perform indexing of the added rectangles. */
+	finish() {
+		if (this._pos >> 2 !== this.numItems) throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
+		const boxes = this._boxes;
+		if (this.numItems <= this.nodeSize) {
+			boxes[this._pos++] = this.minX;
+			boxes[this._pos++] = this.minY;
+			boxes[this._pos++] = this.maxX;
+			boxes[this._pos++] = this.maxY;
+			return;
+		}
+		const width = this.maxX - this.minX || 1;
+		const height = this.maxY - this.minY || 1;
+		const hilbertValues = new Int32Array(this.numItems);
+		const hilbertMax = 65535;
+		for (let i = 0, pos = 0; i < this.numItems; i++) {
+			const minX = boxes[pos++];
+			const minY = boxes[pos++];
+			const maxX = boxes[pos++];
+			const maxY = boxes[pos++];
+			hilbertValues[i] = hilbert(Math.floor(hilbertMax * ((minX + maxX) / 2 - this.minX) / width), Math.floor(hilbertMax * ((minY + maxY) / 2 - this.minY) / height));
+		}
+		sort(hilbertValues, boxes, this._indices, 0, this.numItems - 1, this.nodeSize);
+		for (let i = 0, pos = 0; i < this._levelBounds.length - 1; i++) {
+			const end = this._levelBounds[i];
+			while (pos < end) {
+				const nodeIndex = pos;
+				let nodeMinX = boxes[pos++];
+				let nodeMinY = boxes[pos++];
+				let nodeMaxX = boxes[pos++];
+				let nodeMaxY = boxes[pos++];
+				for (let j = 1; j < this.nodeSize && pos < end; j++) {
+					nodeMinX = Math.min(nodeMinX, boxes[pos++]);
+					nodeMinY = Math.min(nodeMinY, boxes[pos++]);
+					nodeMaxX = Math.max(nodeMaxX, boxes[pos++]);
+					nodeMaxY = Math.max(nodeMaxY, boxes[pos++]);
+				}
+				this._indices[this._pos >> 2] = nodeIndex;
+				boxes[this._pos++] = nodeMinX;
+				boxes[this._pos++] = nodeMinY;
+				boxes[this._pos++] = nodeMaxX;
+				boxes[this._pos++] = nodeMaxY;
+			}
+		}
 	}
-};
-//#endregion
-//#region node_modules/flatqueue/index.js
-/**
-* @typedef {Float64ArrayConstructor | Float32ArrayConstructor |
-*   Uint32ArrayConstructor | Int32ArrayConstructor | Uint16ArrayConstructor |
-*   Int16ArrayConstructor | Uint8ArrayConstructor | Int8ArrayConstructor} TypedArrayConstructor
-*/
-/** @template [T=number] */
-var FlatQueue = class {
 	/**
-	* Creates an empty queue. If `capacity` is provided, the queue is backed by fixed-size typed
-	* arrays for better performance and memory use, but can't grow beyond `capacity`. `values` uses
-	* `ValuesArray` (default `Float64Array`) and `ids` uses `IdsArray` (default `Uint32Array`); pass
-	* narrower constructors like `Uint16Array` if your values or ids are known to fit them.
-	*
-	* @param {number} [capacity]
-	* @param {TypedArrayConstructor} [ValuesArray]
-	* @param {TypedArrayConstructor} [IdsArray]
+	* Search the index by a bounding box.
+	* @param {number} minX
+	* @param {number} minY
+	* @param {number} maxX
+	* @param {number} maxY
+	* @param {(index: number, x0: number, y0: number, x1: number, y1: number) => boolean} [filterFn] An optional function that is called on every found item; if supplied, only items for which this function returns true will be included in the results array.
+	* @returns {number[]} An array of indices of items intersecting or touching the given bounding box.
 	*/
-	constructor(capacity = Infinity, ValuesArray = Float64Array, IdsArray = Uint32Array) {
-		const fixed = capacity !== Infinity;
-		/** @type {T[]} */
-		this.ids = fixed ? new IdsArray(capacity) : [];
-		/** @type {number[]} */
-		this.values = fixed ? new ValuesArray(capacity) : [];
-		/** Maximum number of items the queue can hold; `Infinity` for regular-array queues, which grow on demand. */
-		this.capacity = capacity;
-		/** Number of items in the queue. */
-		this.length = 0;
-	}
-	/** Removes all items from the queue. */
-	clear() {
-		this.length = 0;
+	search(minX, minY, maxX, maxY, filterFn) {
+		if (this._pos !== this._boxes.length) throw new Error("Data not yet indexed - call index.finish().");
+		const { _boxes: boxes, _levelBounds: levelBounds, _indices: indices, nodeSize } = this;
+		const numItems4 = this.numItems * 4;
+		/** @type number | undefined */
+		let nodeIndex = boxes.length - 4;
+		let level = levelBounds.length - 1;
+		const q = [];
+		const results = [];
+		let contained = false;
+		while (nodeIndex !== void 0) {
+			const end = Math.min(nodeIndex + nodeSize * 4, levelBounds[level]);
+			const isNode = nodeIndex >= numItems4;
+			if (contained) this._collectContained(nodeIndex, end, level, isNode, q, results, filterFn);
+			else for (let pos = nodeIndex; pos < end; pos += 4) {
+				const x0 = boxes[pos];
+				if (maxX < x0) continue;
+				const y0 = boxes[pos + 1];
+				if (maxY < y0) continue;
+				const x1 = boxes[pos + 2];
+				if (minX > x1) continue;
+				const y1 = boxes[pos + 3];
+				if (minY > y1) continue;
+				const index = indices[pos >> 2] | 0;
+				if (isNode) {
+					const c = +(minX <= x0 && minY <= y0 && maxX >= x1 && maxY >= y1);
+					q.push(index | c, level - 1);
+				} else if (filterFn === void 0 || filterFn(index, x0, y0, x1, y1)) results.push(index);
+			}
+			level = q.pop();
+			nodeIndex = q.pop();
+			if (nodeIndex !== void 0) {
+				contained = (nodeIndex & 1) === 1;
+				nodeIndex &= -2;
+			}
+		}
+		return results;
 	}
 	/**
-	* Adds `item` to the queue with the specified `priority`.
-	*
-	* `priority` must be a number. Items are sorted and returned from low to high priority. Multiple items
-	* with the same priority value can be added to the queue, but there is no guaranteed order between these items.
-	*
-	* For fixed-capacity queues, throws a `RangeError` if the queue is already full.
-	*
-	* @param {T} item
-	* @param {number} priority
+	* Collect children of a node whose bbox is fully inside the query, skipping intersection tests.
+	* @param {number} nodeIndex
+	* @param {number} end
+	* @param {number} level
+	* @param {boolean} isNode whether the children are tree nodes (vs leaf items)
+	* @param {number[]} q the traversal queue
+	* @param {number[]} results
+	* @param {((index: number, x0: number, y0: number, x1: number, y1: number) => boolean) | undefined} filterFn
 	*/
-	push(item, priority) {
-		if (this.length === this.capacity) throw new RangeError("Queue is at capacity.");
-		let pos = this.length++;
-		while (pos > 0) {
-			const parent = pos - 1 >> 1;
-			const parentValue = this.values[parent];
-			if (priority >= parentValue) break;
-			this.ids[pos] = this.ids[parent];
-			this.values[pos] = parentValue;
-			pos = parent;
+	_collectContained(nodeIndex, end, level, isNode, q, results, filterFn) {
+		const boxes = this._boxes;
+		const indices = this._indices;
+		if (isNode) for (let pos = nodeIndex; pos < end; pos += 4) q.push(indices[pos >> 2] | 1, level - 1);
+		else for (let pos = nodeIndex; pos < end; pos += 4) {
+			const index = indices[pos >> 2] | 0;
+			if (filterFn === void 0 || filterFn(index, boxes[pos], boxes[pos + 1], boxes[pos + 2], boxes[pos + 3])) results.push(index);
 		}
-		this.ids[pos] = item;
-		this.values[pos] = priority;
 	}
 	/**
-	* Removes and returns the item from the head of this queue, which is one of
-	* the items with the lowest priority. If this queue is empty, returns `undefined`.
+	* Search items in order of distance from the given point.
+	* @param {number} x
+	* @param {number} y
+	* @param {number} [maxResults=Infinity]
+	* @param {number} [maxDistance=Infinity]
+	* @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
+	* @returns {number[]} An array of indices of items found.
 	*/
-	pop() {
-		if (this.length === 0) return void 0;
-		const ids = this.ids, values = this.values, top = ids[0], last = --this.length;
-		if (last > 0) {
-			const id = ids[last];
-			const value = values[last];
-			let pos = 0;
-			const halfLen = last >> 1;
-			while (pos < halfLen) {
-				const left = (pos << 1) + 1;
-				const right = left + 1;
-				const child = left + (+(right < last) & +(values[right] < values[left]));
-				if (values[child] >= value) break;
-				ids[pos] = ids[child];
-				values[pos] = values[child];
-				pos = child;
+	neighbors(x, y, maxResults = Infinity, maxDistance = Infinity, filterFn) {
+		if (this._pos !== this._boxes.length) throw new Error("Data not yet indexed - call index.finish().");
+		const { _boxes: boxes, _levelBounds: levelBounds, _indices: indices, _queue: q, nodeSize } = this;
+		const numItems4 = this.numItems * 4;
+		const nodeSize4 = nodeSize * 4;
+		const results = [];
+		const maxDistSquared = maxDistance * maxDistance;
+		q.push(boxes.length - 4 << 1, 0);
+		while (q.length) {
+			const top = q.ids[0];
+			if (top & 1) {
+				if (q.values[0] > maxDistSquared) break;
+				q.pop();
+				results.push(top >> 1);
+				if (results.length === maxResults) break;
+				continue;
 			}
-			ids[pos] = id;
-			values[pos] = value;
+			q.pop();
+			const nodeIndex = top >> 1;
+			const isLeafLevel = nodeIndex < numItems4;
+			const end = Math.min(nodeIndex + nodeSize4, upperBound(nodeIndex, levelBounds));
+			for (let pos = nodeIndex; pos < end; pos += 4) {
+				const childIndex = indices[pos >> 2] | 0;
+				const minX = boxes[pos];
+				const minY = boxes[pos + 1];
+				const maxX = boxes[pos + 2];
+				const maxY = boxes[pos + 3];
+				const dx = x < minX ? minX - x : x > maxX ? x - maxX : 0;
+				const dy = y < minY ? minY - y : y > maxY ? y - maxY : 0;
+				const dist = dx * dx + dy * dy;
+				if (dist > maxDistSquared) continue;
+				if (isLeafLevel) {
+					if (filterFn === void 0 || filterFn(childIndex)) q.push(childIndex << 1 | 1, dist);
+				} else q.push(childIndex << 1, dist);
+			}
+		}
+		q.clear();
+		return results;
+	}
+};
+/**
+* Binary search for the first value in the array bigger than the given.
+* @param {number} value
+* @param {number[]} arr
+*/
+function upperBound(value, arr) {
+	let i = 0;
+	let j = arr.length - 1;
+	while (i < j) {
+		const m = i + j >> 1;
+		if (arr[m] > value) j = m;
+		else i = m + 1;
+	}
+	return arr[i];
+}
+/**
+* Custom quicksort that partially sorts bbox data alongside the hilbert values.
+* @param {Int32Array} values
+* @param {TypedArray} boxes
+* @param {Uint16Array | Uint32Array} indices
+* @param {number} left
+* @param {number} right
+* @param {number} nodeSize
+*/
+function sort(values, boxes, indices, left, right, nodeSize) {
+	const stack = [left, right];
+	while (stack.length) {
+		const r = stack.pop() || 0;
+		const l = stack.pop() || 0;
+		if (r - l <= nodeSize && Math.floor(l / nodeSize) >= Math.floor(r / nodeSize)) continue;
+		const a = values[l];
+		const b = values[l + r >> 1];
+		const c = values[r];
+		const pivot = a > b !== a > c ? a : b < a !== b < c ? b : c;
+		let i = l - 1;
+		let j = r + 1;
+		while (true) {
+			do
+				i++;
+			while (values[i] < pivot);
+			do
+				j--;
+			while (values[j] > pivot);
+			if (i >= j) break;
+			swap(values, boxes, indices, i, j);
 		}
-		return top;
+		stack.push(l, j, j + 1, r);
 	}
-	/** Returns the item from the head of this queue without removing it. If this queue is empty, returns `undefined`. */
-	peek() {
-		return this.length > 0 ? this.ids[0] : void 0;
+}
+/**
+* Swap two values and two corresponding boxes.
+* @param {Int32Array} values
+* @param {TypedArray} boxes
+* @param {Uint16Array | Uint32Array} indices
+* @param {number} i
+* @param {number} j
+*/
+function swap(values, boxes, indices, i, j) {
+	const temp = values[i];
+	values[i] = values[j];
+	values[j] = temp;
+	const k = 4 * i;
+	const m = 4 * j;
+	const a = boxes[k];
+	const b = boxes[k + 1];
+	const c = boxes[k + 2];
+	const d = boxes[k + 3];
+	boxes[k] = boxes[m];
+	boxes[k + 1] = boxes[m + 1];
+	boxes[k + 2] = boxes[m + 2];
+	boxes[k + 3] = boxes[m + 3];
+	boxes[m] = a;
+	boxes[m + 1] = b;
+	boxes[m + 2] = c;
+	boxes[m + 3] = d;
+	const e = indices[i];
+	indices[i] = indices[j];
+	indices[j] = e;
+}
+/**
+* Fast Hilbert curve algorithm by http://threadlocalmutex.com/
+* Ported from C++ https://github.com/rawrunprotected/hilbert_curves (public domain)
+* @param {number} x
+* @param {number} y
+*/
+function hilbert(x, y) {
+	let a = x ^ y;
+	let b = 65535 ^ a;
+	let c = 65535 ^ (x | y);
+	let d = x & (y ^ 65535);
+	let A = a | b >> 1;
+	let B = a >> 1 ^ a;
+	let C = c ^ (c >> 1 ^ b & d >> 1);
+	let D = d ^ (a & c >> 1 ^ d >> 1);
+	a = A & A >> 2 ^ B & B >> 2;
+	b = A & B >> 2 ^ B & (A ^ B) >> 2;
+	c = C ^ (A & C >> 2 ^ B & D >> 2);
+	d = D ^ (B & C >> 2 ^ (A ^ B) & D >> 2);
+	A = a & a >> 4 ^ b & b >> 4;
+	B = a & b >> 4 ^ b & (a ^ b) >> 4;
+	C = c ^ (a & c >> 4 ^ b & d >> 4);
+	D = d ^ (b & c >> 4 ^ (a ^ b) & d >> 4);
+	c = C ^ (A & C >> 8 ^ B & D >> 8);
+	d = D ^ (B & C >> 8 ^ (A ^ B) & D >> 8);
+	c ^= c >> 1;
+	d ^= d >> 1;
+	a = x ^ y;
+	b = d | 65535 ^ (a | c);
+	a = (a | a << 8) & 16711935;
+	a = (a | a << 4) & 252645135;
+	a = (a | a << 2) & 858993459;
+	a = (a | a << 1) & 1431655765;
+	b = (b | b << 8) & 16711935;
+	b = (b | b << 4) & 252645135;
+	b = (b | b << 2) & 858993459;
+	b = (b | b << 1) & 1431655765;
+	return ((b << 1 | a) >>> 0) - 2147483648;
+}
+//#endregion
+//#region node_modules/@developmentseed/deck.gl-geotiff/dist/mosaic-layer/mosaic-tileset-2d.js
+var MosaicTileset2D = class extends _Tileset2D {
+	/** Closure returning the parent layer's current sources array. Re-evaluated
+	* on each `getTileIndices` call so updates to the layer's `sources` prop
+	* propagate without recreating the tileset. */
+	getSources;
+	/** Access the spatial index on the MosaicLayer instance. */
+	getIndex;
+	constructor(getSources, getIndex, opts) {
+		super(opts);
+		this.getIndex = getIndex;
+		this.getSources = getSources;
 	}
-	/**
-	* Returns the priority value of the item at the head of this queue without
-	* removing it. If this queue is empty, returns `undefined`.
-	*/
-	peekValue() {
-		return this.length > 0 ? this.values[0] : void 0;
+	/** The Tileset2D cache key for a source. */
+	getTileId(tileIndex) {
+		return tileIndex.id;
 	}
-	/**
-	* Shrinks the internal arrays to `this.length`. No-op for queues with fixed capacity.
-	*
-	* `pop()` and `clear()` calls don't free memory automatically to avoid unnecessary resize operations.
-	* This also means that items that have been added to the queue can't be garbage collected until
-	* a new item is pushed in their place, or this method is called.
-	*/
-	shrink() {
-		if (Array.isArray(this.ids)) this.ids.length = this.length;
-		if (Array.isArray(this.values)) this.values.length = this.length;
+	/** Must override to provide a zoom level for the tile. */
+	getTileZoom(_tileIndex) {
+		return 0;
 	}
-};
-//#endregion
-//#region node_modules/flatbush/index.js
-var ARRAY_TYPES = [
-	Int8Array,
-	Uint8Array,
-	Uint8ClampedArray,
-	Int16Array,
-	Uint16Array,
-	Int32Array,
-	Uint32Array,
-	Float32Array,
-	Float64Array
-];
-var VERSION = 3;
-/** @typedef {Int8ArrayConstructor | Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Int16ArrayConstructor | Uint16ArrayConstructor | Int32ArrayConstructor | Uint32ArrayConstructor | Float32ArrayConstructor | Float64ArrayConstructor} TypedArrayConstructor */
-/** @typedef {Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array} TypedArray */
-var Flatbush = class Flatbush {
-	/**
-	* Recreate a Flatbush index from raw `ArrayBuffer` or `SharedArrayBuffer` data.
-	* @param {ArrayBufferLike} data
-	* @param {number} [byteOffset=0] byte offset to the start of the Flatbush buffer in the referenced ArrayBuffer.
-	* @returns {Flatbush} index
-	*/
-	static from(data, byteOffset = 0) {
-		if (byteOffset % 8 !== 0) throw new Error("byteOffset must be 8-byte aligned.");
-		if (!data || data.byteLength === void 0 || "buffer" in data) throw new Error("Data must be an instance of ArrayBuffer or SharedArrayBuffer.");
-		const [magic, versionAndType] = new Uint8Array(data, byteOffset + 0, 2);
-		if (magic !== 251) throw new Error("Data does not appear to be in a Flatbush format.");
-		const version = versionAndType >> 4;
-		if (version !== VERSION) throw new Error(`Got v${version} data when expected v${VERSION}.`);
-		const ArrayType = ARRAY_TYPES[versionAndType & 15];
-		if (!ArrayType) throw new Error("Unrecognized array type.");
-		const [nodeSize] = new Uint16Array(data, byteOffset + 2, 1);
-		const [numItems] = new Uint32Array(data, byteOffset + 4, 1);
-		return new Flatbush(numItems, nodeSize, ArrayType, void 0, data, byteOffset);
+	/** Must override because our tileIndex does not have x, y, z */
+	getTileMetadata(tileIndex) {
+		const { id, bbox } = tileIndex;
+		return {
+			id,
+			bbox
+		};
 	}
-	/**
-	* Create a Flatbush index that will hold a given number of items.
-	* @param {number} numItems
-	* @param {number} [nodeSize=16] Size of the tree node (16 by default).
-	* @param {TypedArrayConstructor} [ArrayType=Float64Array] The array type used for coordinates storage (`Float64Array` by default).
-	* @param {ArrayBufferConstructor | SharedArrayBufferConstructor} [ArrayBufferType=ArrayBuffer] The array buffer type used to store data (`ArrayBuffer` by default).
-	* @param {ArrayBufferLike} [data] (Only used internally)
-	* @param {number} [byteOffset=0] (Only used internally)
-	*/
-	constructor(numItems, nodeSize = 16, ArrayType = Float64Array, ArrayBufferType = ArrayBuffer, data, byteOffset = 0) {
-		if (numItems === void 0) throw new Error("Missing required argument: numItems.");
-		if (isNaN(numItems) || numItems <= 0) throw new Error(`Unexpected numItems value: ${numItems}.`);
-		this.numItems = +numItems;
-		this.nodeSize = Math.min(Math.max(+nodeSize, 2), 65535);
-		this.byteOffset = byteOffset;
-		let n = numItems;
-		let numNodes = n;
-		this._levelBounds = [n * 4];
-		do {
-			n = Math.ceil(n / this.nodeSize);
-			numNodes += n;
-			this._levelBounds.push(numNodes * 4);
-		} while (n !== 1);
-		this.ArrayType = ArrayType;
-		this.IndexArrayType = numNodes < 16384 ? Uint16Array : Uint32Array;
-		const arrayTypeIndex = ARRAY_TYPES.indexOf(ArrayType);
-		const nodesByteSize = numNodes * 4 * ArrayType.BYTES_PER_ELEMENT;
-		if (arrayTypeIndex < 0) throw new Error(`Unexpected typed array class: ${ArrayType}.`);
-		/** @type {new(b: ArrayBufferLike, o: number, l: number) => TypedArray} */
-		const BoxCtor = ArrayType;
-		/** @type {new(b: ArrayBufferLike, o: number, l: number) => Uint16Array | Uint32Array} */
-		const IdxCtor = this.IndexArrayType;
-		if (data) {
-			this.data = data;
-			this._boxes = new BoxCtor(data, byteOffset + 8, numNodes * 4);
-			this._indices = new IdxCtor(data, byteOffset + 8 + nodesByteSize, numNodes);
-			this._pos = numNodes * 4;
-			this.minX = this._boxes[this._pos - 4];
-			this.minY = this._boxes[this._pos - 3];
-			this.maxX = this._boxes[this._pos - 2];
-			this.maxY = this._boxes[this._pos - 1];
-		} else {
-			const data = this.data = new ArrayBufferType(8 + nodesByteSize + numNodes * this.IndexArrayType.BYTES_PER_ELEMENT);
-			this._boxes = new BoxCtor(data, 8, numNodes * 4);
-			this._indices = new IdxCtor(data, 8 + nodesByteSize, numNodes);
-			this._pos = 0;
-			this.minX = Infinity;
-			this.minY = Infinity;
-			this.maxX = -Infinity;
-			this.maxY = -Infinity;
-			new Uint8Array(data, 0, 2).set([251, (VERSION << 4) + arrayTypeIndex]);
-			new Uint16Array(data, 2, 1)[0] = nodeSize;
-			new Uint32Array(data, 4, 1)[0] = numItems;
-		}
-		/** @type FlatQueue<number> */
-		this._queue = new FlatQueue();
+	getParentIndex(tileIndex) {
+		return tileIndex;
+	}
+	getTileIndices({ viewport, maxZoom, minZoom }) {
+		if (viewport.zoom < (minZoom ?? -Infinity)) return [];
+		if (viewport.zoom > (maxZoom ?? Infinity)) return [];
+		const index = this.getIndex();
+		if (!index) return [];
+		const viewportBounds = viewport.getBounds();
+		const indices = index.search(...viewportBounds);
+		const sources = this.getSources();
+		const selectedSources = indices.map((sourceIndex) => {
+			const source = sources[sourceIndex];
+			return {
+				x: 0,
+				y: 0,
+				z: 0,
+				...source,
+				id: source.id ?? String(sourceIndex)
+			};
+		});
+		const { maxRequests } = this.opts;
+		if (selectedSources.length <= maxRequests) return selectedSources;
+		return sortItemsByDistanceFromViewportCenter(selectedSources, viewport, (source) => {
+			const [minX, minY, maxX, maxY] = source.bbox;
+			return [(minX + maxX) * .5, (minY + maxY) * .5];
+		});
 	}
-	/**
-	* Add a given rectangle to the index.
-	* @param {number} minX
-	* @param {number} minY
-	* @param {number} maxX
-	* @param {number} maxY
-	* @returns {number} A zero-based, incremental number that represents the newly added rectangle.
-	*/
-	add(minX, minY, maxX = minX, maxY = minY) {
-		const index = this._pos >> 2;
-		const boxes = this._boxes;
-		this._indices[index] = index;
-		boxes[this._pos++] = minX;
-		boxes[this._pos++] = minY;
-		boxes[this._pos++] = maxX;
-		boxes[this._pos++] = maxY;
-		if (minX < this.minX) this.minX = minX;
-		if (minY < this.minY) this.minY = minY;
-		if (maxX > this.maxX) this.maxX = maxX;
-		if (maxY > this.maxY) this.maxY = maxY;
-		return index;
+};
+//#endregion
+//#region node_modules/@developmentseed/deck.gl-geotiff/dist/mosaic-layer/mosaic-layer.js
+var defaultProps = { sources: [] };
+/**
+* A deck.gl layer for rendering a mosaic of raster sources.
+*
+* The `renderSource` prop is called whenever a source is present in the current
+* viewport.
+*/
+var MosaicLayer = class extends CompositeLayer {
+	static layerName = "MosaicLayer";
+	static defaultProps = defaultProps;
+	initializeState(context) {
+		super.initializeState(context);
+		this._buildSpatialIndex();
 	}
-	/** Perform indexing of the added rectangles. */
-	finish() {
-		if (this._pos >> 2 !== this.numItems) throw new Error(`Added ${this._pos >> 2} items when expected ${this.numItems}.`);
-		const boxes = this._boxes;
-		if (this.numItems <= this.nodeSize) {
-			boxes[this._pos++] = this.minX;
-			boxes[this._pos++] = this.minY;
-			boxes[this._pos++] = this.maxX;
-			boxes[this._pos++] = this.maxY;
+	updateState(params) {
+		super.updateState(params);
+		const { props, oldProps } = params;
+		if (props.sources !== oldProps.sources) this._buildSpatialIndex();
+	}
+	_buildSpatialIndex() {
+		const { sources } = this.props;
+		if (sources.length === 0) {
+			this.setState({ index: null });
 			return;
 		}
-		const width = this.maxX - this.minX || 1;
-		const height = this.maxY - this.minY || 1;
-		const hilbertValues = new Int32Array(this.numItems);
-		const hilbertMax = 65535;
-		for (let i = 0, pos = 0; i < this.numItems; i++) {
-			const minX = boxes[pos++];
-			const minY = boxes[pos++];
-			const maxX = boxes[pos++];
-			const maxY = boxes[pos++];
-			hilbertValues[i] = hilbert(Math.floor(hilbertMax * ((minX + maxX) / 2 - this.minX) / width), Math.floor(hilbertMax * ((minY + maxY) / 2 - this.minY) / height));
-		}
-		sort(hilbertValues, boxes, this._indices, 0, this.numItems - 1, this.nodeSize);
-		for (let i = 0, pos = 0; i < this._levelBounds.length - 1; i++) {
-			const end = this._levelBounds[i];
-			while (pos < end) {
-				const nodeIndex = pos;
-				let nodeMinX = boxes[pos++];
-				let nodeMinY = boxes[pos++];
-				let nodeMaxX = boxes[pos++];
-				let nodeMaxY = boxes[pos++];
-				for (let j = 1; j < this.nodeSize && pos < end; j++) {
-					nodeMinX = Math.min(nodeMinX, boxes[pos++]);
-					nodeMinY = Math.min(nodeMinY, boxes[pos++]);
-					nodeMaxX = Math.max(nodeMaxX, boxes[pos++]);
-					nodeMaxY = Math.max(nodeMaxY, boxes[pos++]);
-				}
-				this._indices[this._pos >> 2] = nodeIndex;
-				boxes[this._pos++] = nodeMinX;
-				boxes[this._pos++] = nodeMinY;
-				boxes[this._pos++] = nodeMaxX;
-				boxes[this._pos++] = nodeMaxY;
-			}
-		}
+		const index = new Flatbush(sources.length);
+		for (const source of sources) index.add(...source.bbox);
+		index.finish();
+		this.setState({ index });
 	}
-	/**
-	* Search the index by a bounding box.
-	* @param {number} minX
-	* @param {number} minY
-	* @param {number} maxX
-	* @param {number} maxY
-	* @param {(index: number, x0: number, y0: number, x1: number, y1: number) => boolean} [filterFn] An optional function that is called on every found item; if supplied, only items for which this function returns true will be included in the results array.
-	* @returns {number[]} An array of indices of items intersecting or touching the given bounding box.
-	*/
-	search(minX, minY, maxX, maxY, filterFn) {
-		if (this._pos !== this._boxes.length) throw new Error("Data not yet indexed - call index.finish().");
-		const { _boxes: boxes, _levelBounds: levelBounds, _indices: indices, nodeSize } = this;
-		const numItems4 = this.numItems * 4;
-		/** @type number | undefined */
-		let nodeIndex = boxes.length - 4;
-		let level = levelBounds.length - 1;
-		const q = [];
-		const results = [];
-		let contained = false;
-		while (nodeIndex !== void 0) {
-			const end = Math.min(nodeIndex + nodeSize * 4, levelBounds[level]);
-			const isNode = nodeIndex >= numItems4;
-			if (contained) this._collectContained(nodeIndex, end, level, isNode, q, results, filterFn);
-			else for (let pos = nodeIndex; pos < end; pos += 4) {
-				const x0 = boxes[pos];
-				if (maxX < x0) continue;
-				const y0 = boxes[pos + 1];
-				if (maxY < y0) continue;
-				const x1 = boxes[pos + 2];
-				if (minX > x1) continue;
-				const y1 = boxes[pos + 3];
-				if (minY > y1) continue;
-				const index = indices[pos >> 2] | 0;
-				if (isNode) {
-					const c = +(minX <= x0 && minY <= y0 && maxX >= x1 && maxY >= y1);
-					q.push(index | c, level - 1);
-				} else if (filterFn === void 0 || filterFn(index, x0, y0, x1, y1)) results.push(index);
-			}
-			level = q.pop();
-			nodeIndex = q.pop();
-			if (nodeIndex !== void 0) {
-				contained = (nodeIndex & 1) === 1;
-				nodeIndex &= -2;
+	renderTileLayer(renderSource) {
+		const { id, minZoom, maxZoom, debounceTime, extent, maxCacheByteSize, maxCacheSize, maxRequests, onSourceLoad, onSourceError, onSourceUnload, onViewportLoad } = this.props;
+		const getSources = () => this.props.sources;
+		const getIndex = () => this.state.index;
+		class MosaicTileset2DFactory extends MosaicTileset2D {
+			constructor(opts) {
+				super(getSources, getIndex, opts);
 			}
 		}
-		return results;
+		return new TileLayer({
+			id: `mosaic-layer-${id}`,
+			TilesetClass: MosaicTileset2DFactory,
+			minZoom,
+			maxZoom,
+			debounceTime,
+			extent,
+			...maxCacheByteSize !== void 0 && { maxCacheByteSize },
+			maxCacheSize,
+			maxRequests,
+			getTileData: async (data) => {
+				const index = data.index;
+				const { signal } = data;
+				return {
+					source: index,
+					data: this.props.getSource && await this.props.getSource(index, { signal }),
+					signal
+				};
+			},
+			renderSubLayers: (props) => {
+				const { data } = props;
+				const { source, signal, data: userData } = data;
+				return renderSource(source, {
+					data: userData,
+					signal
+				});
+			},
+			...onSourceLoad && { onTileLoad: (tile) => {
+				const source = tile.index;
+				onSourceLoad(source, { data: tile.content?.data });
+			} },
+			...onSourceError && { onTileError: (error, tile) => {
+				if (!tile) return;
+				const source = tile.index;
+				onSourceError(source, { error });
+			} },
+			...onSourceUnload && { onTileUnload: (tile) => {
+				const source = tile.index;
+				onSourceUnload(source, { data: tile.content?.data });
+			} },
+			...onViewportLoad && { onViewportLoad: (tiles) => {
+				onViewportLoad(tiles.map((tile) => ({
+					source: tile.index,
+					data: tile.content?.data
+				})));
+			} }
+		});
 	}
-	/**
-	* Collect children of a node whose bbox is fully inside the query, skipping intersection tests.
-	* @param {number} nodeIndex
-	* @param {number} end
-	* @param {number} level
-	* @param {boolean} isNode whether the children are tree nodes (vs leaf items)
-	* @param {number[]} q the traversal queue
-	* @param {number[]} results
-	* @param {((index: number, x0: number, y0: number, x1: number, y1: number) => boolean) | undefined} filterFn
-	*/
-	_collectContained(nodeIndex, end, level, isNode, q, results, filterFn) {
-		const boxes = this._boxes;
-		const indices = this._indices;
-		if (isNode) for (let pos = nodeIndex; pos < end; pos += 4) q.push(indices[pos >> 2] | 1, level - 1);
-		else for (let pos = nodeIndex; pos < end; pos += 4) {
-			const index = indices[pos >> 2] | 0;
-			if (filterFn === void 0 || filterFn(index, boxes[pos], boxes[pos + 1], boxes[pos + 2], boxes[pos + 3])) results.push(index);
+	renderLayers() {
+		const { sources, renderSource } = this.props;
+		if (!sources) return null;
+		return this.renderTileLayer(renderSource);
+	}
+};
+//#endregion
+//#region node_modules/@chunkd/middleware/build/src/middleware/cache.js
+var SourceCache = class {
+	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(opts) {
+		this.maxSize = opts.size;
+		this.protocols = new Set(opts.protocols ?? []);
+	}
+	fetch(req, next) {
+		if (this.protocols.size > 0 && !this.protocols.has(req.source.url.protocol)) return next(req);
+		if (req.length == null) return next(req);
+		const cacheKey = `${req.source.url.toString()}@${req.offset}+${req.length}`;
+		let existing = this.cacheA.get(cacheKey);
+		if (existing) {
+			existing.hits++;
+			return existing.promise;
+		}
+		existing = this.cacheB.get(cacheKey);
+		if (existing) {
+			existing.hits++;
+			existing.saves++;
+			this.size += existing.size;
+			this.cacheA.set(cacheKey, existing);
+			return existing.promise;
+		}
+		existing = {
+			promise: next(req),
+			hits: 0,
+			saves: 0,
+			size: req.length
+		};
+		this.size += existing.size;
+		if (this.size > this.maxSize) {
+			this.size = existing.size;
+			this.cacheB = this.cacheA;
+			this.cacheA = /* @__PURE__ */ new Map();
+			this.resets++;
 		}
+		this.cacheA.set(cacheKey, existing);
+		return existing.promise;
+	}
+};
+//#endregion
+//#region node_modules/@chunkd/source/build/src/error.js
+var SourceError = class SourceError 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(msg, code, source, cause) {
+		super(msg, { cause });
+		this.code = code;
+		this.url = source.url;
+		this.source = source;
+		/** Helper to determine if this class is a SourceError, useful for when `instanceof` fails */
+		Object.defineProperty(this, "_sourceError", {
+			enumerable: false,
+			value: "SourceError"
+		});
+	}
+	/** Check that a unknown is a FsError */
+	static is(e) {
+		if (e instanceof SourceError) return true;
+		if (typeof e !== "object") return false;
+		if (e == null) return false;
+		return "_sourceError" in e && e["_sourceError"] === "SourceError";
 	}
+};
+//#endregion
+//#region node_modules/@chunkd/source/build/src/range.js
+var ContentRange = {
+	/** Convert a offset/length to a range request
+	*
+	* @example
+	* ```typescript
+	* ContentRange.toRange(10) // "bytes=10"
+	* ContentRange.toRange(0, 1024) // "bytes=0-1023"
+	* ```
+	*/
+	toRange(offset, length) {
+		if (length == null) return `bytes=${offset}`;
+		if (offset < 0) throw new Error("Cannot read from remote source with negative offset and length");
+		return `bytes=${offset}-${offset + length - 1}`;
+	},
 	/**
-	* Search items in order of distance from the given point.
-	* @param {number} x
-	* @param {number} y
-	* @param {number} [maxResults=Infinity]
-	* @param {number} [maxDistance=Infinity]
-	* @param {(index: number) => boolean} [filterFn] An optional function for filtering the results.
-	* @returns {number[]} An array of indices of items found.
+	* 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
 	*/
-	neighbors(x, y, maxResults = Infinity, maxDistance = Infinity, filterFn) {
-		if (this._pos !== this._boxes.length) throw new Error("Data not yet indexed - call index.finish().");
-		const { _boxes: boxes, _levelBounds: levelBounds, _indices: indices, _queue: q, nodeSize } = this;
-		const numItems4 = this.numItems * 4;
-		const nodeSize4 = nodeSize * 4;
-		const results = [];
-		const maxDistSquared = maxDistance * maxDistance;
-		q.push(boxes.length - 4 << 1, 0);
-		while (q.length) {
-			const top = q.ids[0];
-			if (top & 1) {
-				if (q.values[0] > maxDistSquared) break;
-				q.pop();
-				results.push(top >> 1);
-				if (results.length === maxResults) break;
-				continue;
-			}
-			q.pop();
-			const nodeIndex = top >> 1;
-			const isLeafLevel = nodeIndex < numItems4;
-			const end = Math.min(nodeIndex + nodeSize4, upperBound(nodeIndex, levelBounds));
-			for (let pos = nodeIndex; pos < end; pos += 4) {
-				const childIndex = indices[pos >> 2] | 0;
-				const minX = boxes[pos];
-				const minY = boxes[pos + 1];
-				const maxX = boxes[pos + 2];
-				const maxY = boxes[pos + 3];
-				const dx = x < minX ? minX - x : x > maxX ? x - maxX : 0;
-				const dy = y < minY ? minY - y : y > maxY ? y - maxY : 0;
-				const dist = dx * dx + dy * dy;
-				if (dist > maxDistSquared) continue;
-				if (isLeafLevel) {
-					if (filterFn === void 0 || filterFn(childIndex)) q.push(childIndex << 1 | 1, dist);
-				} else q.push(childIndex << 1, dist);
-			}
-		}
-		q.clear();
-		return results;
+	parseSize(range) {
+		const [unit, chunks] = range.split(" ");
+		if (unit !== "bytes") throw new Error("Failed to parse content-range: " + range);
+		if (chunks == null) throw new Error("Failed to parse content-range: " + range);
+		const [, size] = chunks.split("/");
+		const result = Number(size);
+		if (isNaN(result)) throw new Error("Failed to parse content-range: " + range);
+		return result;
 	}
 };
+//#endregion
+//#region node_modules/@chunkd/source/build/src/view.js
 /**
-* Binary search for the first value in the array bigger than the given.
-* @param {number} value
-* @param {number[]} arr
-*/
-function upperBound(value, arr) {
-	let i = 0;
-	let j = arr.length - 1;
-	while (i < j) {
-		const m = i + j >> 1;
-		if (arr[m] > value) j = m;
-		else i = m + 1;
-	}
-	return arr[i];
-}
-/**
-* Custom quicksort that partially sorts bbox data alongside the hilbert values.
-* @param {Int32Array} values
-* @param {TypedArray} boxes
-* @param {Uint16Array | Uint32Array} indices
-* @param {number} left
-* @param {number} right
-* @param {number} nodeSize
+* Wrap a source with middleware to modify requests to the sources
+*
+* @see {@link SourceMiddleware}
+* @see @chunkd/middle for example middleware
 */
-function sort(values, boxes, indices, left, right, nodeSize) {
-	const stack = [left, right];
-	while (stack.length) {
-		const r = stack.pop() || 0;
-		const l = stack.pop() || 0;
-		if (r - l <= nodeSize && Math.floor(l / nodeSize) >= Math.floor(r / nodeSize)) continue;
-		const a = values[l];
-		const b = values[l + r >> 1];
-		const c = values[r];
-		const pivot = a > b !== a > c ? a : b < a !== b < c ? b : c;
-		let i = l - 1;
-		let j = r + 1;
-		while (true) {
-			do
-				i++;
-			while (values[i] < pivot);
-			do
-				j--;
-			while (values[j] > pivot);
-			if (i >= j) break;
-			swap(values, boxes, indices, i, j);
-		}
-		stack.push(l, j, j + 1, r);
+var SourceView = class {
+	source;
+	middleware;
+	static is(s) {
+		if ("middleware" in s) return true;
+		return false;
 	}
-}
-/**
-* Swap two values and two corresponding boxes.
-* @param {Int32Array} values
-* @param {TypedArray} boxes
-* @param {Uint16Array | Uint32Array} indices
-* @param {number} i
-* @param {number} j
-*/
-function swap(values, boxes, indices, i, j) {
-	const temp = values[i];
-	values[i] = values[j];
-	values[j] = temp;
-	const k = 4 * i;
-	const m = 4 * j;
-	const a = boxes[k];
-	const b = boxes[k + 1];
-	const c = boxes[k + 2];
-	const d = boxes[k + 3];
-	boxes[k] = boxes[m];
-	boxes[k + 1] = boxes[m + 1];
-	boxes[k + 2] = boxes[m + 2];
-	boxes[k + 3] = boxes[m + 3];
-	boxes[m] = a;
-	boxes[m + 1] = b;
-	boxes[m + 2] = c;
-	boxes[m + 3] = d;
-	const e = indices[i];
-	indices[i] = indices[j];
-	indices[j] = e;
-}
-/**
-* Fast Hilbert curve algorithm by http://threadlocalmutex.com/
-* Ported from C++ https://github.com/rawrunprotected/hilbert_curves (public domain)
-* @param {number} x
-* @param {number} y
-*/
-function hilbert(x, y) {
-	let a = x ^ y;
-	let b = 65535 ^ a;
-	let c = 65535 ^ (x | y);
-	let d = x & (y ^ 65535);
-	let A = a | b >> 1;
-	let B = a >> 1 ^ a;
-	let C = c ^ (c >> 1 ^ b & d >> 1);
-	let D = d ^ (a & c >> 1 ^ d >> 1);
-	a = A & A >> 2 ^ B & B >> 2;
-	b = A & B >> 2 ^ B & (A ^ B) >> 2;
-	c = C ^ (A & C >> 2 ^ B & D >> 2);
-	d = D ^ (B & C >> 2 ^ (A ^ B) & D >> 2);
-	A = a & a >> 4 ^ b & b >> 4;
-	B = a & b >> 4 ^ b & (a ^ b) >> 4;
-	C = c ^ (a & c >> 4 ^ b & d >> 4);
-	D = d ^ (b & c >> 4 ^ (a ^ b) & d >> 4);
-	c = C ^ (A & C >> 8 ^ B & D >> 8);
-	d = D ^ (B & C >> 8 ^ (A ^ B) & D >> 8);
-	c ^= c >> 1;
-	d ^= d >> 1;
-	a = x ^ y;
-	b = d | 65535 ^ (a | c);
-	a = (a | a << 8) & 16711935;
-	a = (a | a << 4) & 252645135;
-	a = (a | a << 2) & 858993459;
-	a = (a | a << 1) & 1431655765;
-	b = (b | b << 8) & 16711935;
-	b = (b | b << 4) & 252645135;
-	b = (b | b << 2) & 858993459;
-	b = (b | b << 1) & 1431655765;
-	return ((b << 1 | a) >>> 0) - 2147483648;
-}
-//#endregion
-//#region node_modules/@developmentseed/deck.gl-geotiff/dist/mosaic-layer/mosaic-tileset-2d.js
-var MosaicTileset2D = class extends _Tileset2D {
-	/** Closure returning the parent layer's current sources array. Re-evaluated
-	* on each `getTileIndices` call so updates to the layer's `sources` prop
-	* propagate without recreating the tileset. */
-	getSources;
-	/** Access the spatial index on the MosaicLayer instance. */
-	getIndex;
-	constructor(getSources, getIndex, opts) {
-		super(opts);
-		this.getIndex = getIndex;
-		this.getSources = getSources;
+	constructor(source, middleware = []) {
+		this.source = source;
+		this.middleware = middleware;
 	}
-	/** The Tileset2D cache key for a source. */
-	getTileId(tileIndex) {
-		return tileIndex.id;
+	get type() {
+		return this.source.type;
 	}
-	/** Must override to provide a zoom level for the tile. */
-	getTileZoom(_tileIndex) {
-		return 0;
+	get url() {
+		return this.source.url;
 	}
-	/** Must override because our tileIndex does not have x, y, z */
-	getTileMetadata(tileIndex) {
-		const { id, bbox } = tileIndex;
-		return {
-			id,
-			bbox
-		};
+	get metadata() {
+		return this.source.metadata;
 	}
-	getParentIndex(tileIndex) {
-		return tileIndex;
+	head(options) {
+		return this.source.head(options);
 	}
-	getTileIndices({ viewport, maxZoom, minZoom }) {
-		if (viewport.zoom < (minZoom ?? -Infinity)) return [];
-		if (viewport.zoom > (maxZoom ?? Infinity)) return [];
-		const index = this.getIndex();
-		if (!index) return [];
-		const viewportBounds = viewport.getBounds();
-		const indices = index.search(...viewportBounds);
-		const sources = this.getSources();
-		const selectedSources = indices.map((sourceIndex) => {
-			const source = sources[sourceIndex];
-			return {
-				x: 0,
-				y: 0,
-				z: 0,
-				...source,
-				id: source.id ?? String(sourceIndex)
-			};
+	async fetch(offset, length, options) {
+		const middleware = this.middleware;
+		if (middleware == null || middleware.length === 0) return this.source.fetch(offset, length, options);
+		const handler = (req) => this.source.fetch(req.offset, req.length, options);
+		return this.run(handler, offset, length, options);
+	}
+	/** Run a request using all the middleware */
+	async run(handler, offset, length, options) {
+		const middleware = this.middleware;
+		if (middleware == null) return handler({
+			source: this,
+			offset,
+			length,
+			signal: options?.signal
 		});
-		const { maxRequests } = this.opts;
-		if (selectedSources.length <= maxRequests) return selectedSources;
-		return sortItemsByDistanceFromViewportCenter(selectedSources, viewport, (source) => {
-			const [minX, minY, maxX, maxY] = source.bbox;
-			return [(minX + maxX) * .5, (minY + maxY) * .5];
+		function runMiddleware(middleware, next) {
+			return (req) => middleware.fetch(req, next);
+		}
+		for (let i = middleware.length - 1; i >= 0; i--) handler = runMiddleware(middleware[i], handler);
+		return handler({
+			source: this,
+			offset,
+			length,
+			signal: options?.signal
 		});
 	}
 };
 //#endregion
-//#region node_modules/@developmentseed/deck.gl-geotiff/dist/mosaic-layer/mosaic-layer.js
-var defaultProps = { sources: [] };
+//#region node_modules/@chunkd/middleware/build/src/middleware/chunk.js
 /**
-* A deck.gl layer for rendering a mosaic of raster sources.
+* Chunk requests into requests of specific byte sizes
+* If a request is split into smaller chunks should that be re-run as smaller requests and combined later
 *
-* The `renderSource` prop is called whenever a source is present in the current
-* viewport.
+* This can **GREATLY** increase cache hits when using a @see {SourceCache}
 */
-var MosaicLayer = class extends CompositeLayer {
-	static layerName = "MosaicLayer";
-	static defaultProps = defaultProps;
-	initializeState(context) {
-		super.initializeState(context);
-		this._buildSpatialIndex();
+var SourceChunk = class {
+	name = "source:chunk";
+	/** Number of bytes to chunk requests into */
+	chunkSize;
+	constructor(opts) {
+		this.chunkSize = opts.size ?? 32 * 1024;
 	}
-	updateState(params) {
-		super.updateState(params);
-		const { props, oldProps } = params;
-		if (props.sources !== oldProps.sources) this._buildSpatialIndex();
+	async fetch(req, next) {
+		if (req.offset < 0) return next(req);
+		if (req.length == null) return next(req);
+		const startChunkId = Math.floor(req.offset / this.chunkSize);
+		const endChunkId = Math.ceil((req.offset + req.length) / this.chunkSize);
+		const maxSize = req.source.metadata?.size;
+		if (maxSize != null && req.offset + req.length > maxSize) throw new SourceError(`Request outside of bounds ${ContentRange.toRange(req.offset, req.length)}`, 416, req.source);
+		const startByte = startChunkId * this.chunkSize;
+		const maxLength = (maxSize != null ? Math.min(endChunkId * this.chunkSize, maxSize) : endChunkId * this.chunkSize) - startByte;
+		const chunkOffset = req.offset - startByte;
+		if (endChunkId - startChunkId > 1) return (await this.fetchChunks(req, startChunkId, endChunkId)).slice(chunkOffset, chunkOffset + req.length);
+		if (req.offset === startByte && req.length === maxLength) return next(req);
+		return (await next({
+			...req,
+			offset: startByte,
+			length: maxLength
+		})).slice(chunkOffset, chunkOffset + req.length);
 	}
-	_buildSpatialIndex() {
-		const { sources } = this.props;
-		if (sources.length === 0) {
-			this.setState({ index: null });
-			return;
+	async fetchChunks(req, startId, endId) {
+		const promises = [];
+		const maxEndByte = req.source.metadata?.size ?? endId * this.chunkSize;
+		for (let chunk = startId; chunk < endId; chunk++) {
+			const startByte = chunk * this.chunkSize;
+			const chunkLength = Math.min(startByte + this.chunkSize, maxEndByte) - startByte;
+			promises.push(req.source.fetch(chunk * this.chunkSize, chunkLength, req.signal ? { signal: req.signal } : void 0));
 		}
-		const index = new Flatbush(sources.length);
-		for (const source of sources) index.add(...source.bbox);
-		index.finish();
-		this.setState({ index });
+		const results = await Promise.all(promises);
+		const outputBuffer = new Uint8Array(promises.length * this.chunkSize);
+		for (let i = 0; i < results.length; i++) outputBuffer.set(new Uint8Array(results[i]), i * this.chunkSize);
+		return outputBuffer.buffer;
 	}
-	renderTileLayer(renderSource) {
-		const { id, minZoom, maxZoom, debounceTime, extent, maxCacheByteSize, maxCacheSize, maxRequests, onSourceLoad, onSourceError, onSourceUnload, onViewportLoad } = this.props;
-		const getSources = () => this.props.sources;
-		const getIndex = () => this.state.index;
-		class MosaicTileset2DFactory extends MosaicTileset2D {
-			constructor(opts) {
-				super(getSources, getIndex, opts);
-			}
+};
+//#endregion
+//#region node_modules/@chunkd/source-http/build/src/index.js
+/** Load the ETag and content-range from the response */
+function getMetadataFromResponse(response) {
+	const metadata = {};
+	const contentLength = response.headers.get("content-length");
+	if (contentLength) metadata.size = parseInt(contentLength);
+	const contentRange = response.headers.get("content-range");
+	if (contentRange != null) metadata.size = ContentRange.parseSize(contentRange);
+	metadata.eTag = response.headers.get("etag") ?? void 0;
+	metadata.contentType = response.headers.get("content-type") ?? void 0;
+	metadata.contentDisposition = response.headers.get("content-disposition") ?? void 0;
+	metadata.cacheControl = response.headers.get("cache-control") ?? void 0;
+	metadata.contentEncoding = response.headers.get("content-encoding") ?? void 0;
+	return metadata;
+}
+var SourceHttp = class SourceHttp {
+	constructor(url, headers) {
+		this.type = "http";
+		this.url = typeof url === "string" ? SourceHttp.tryUrl(url) : url;
+		this.headers = headers;
+	}
+	/** Attempt to parse a relative string into a URL */
+	static tryUrl(s) {
+		try {
+			return new URL(s);
+		} catch (_e) {
+			if (typeof document !== "undefined") return new URL(s, document.baseURI);
+			return new URL(s, import.meta.url);
 		}
-		return new TileLayer({
-			id: `mosaic-layer-${id}`,
-			TilesetClass: MosaicTileset2DFactory,
-			minZoom,
-			maxZoom,
-			debounceTime,
-			extent,
-			...maxCacheByteSize !== void 0 && { maxCacheByteSize },
-			maxCacheSize,
-			maxRequests,
-			getTileData: async (data) => {
-				const index = data.index;
-				const { signal } = data;
-				return {
-					source: index,
-					data: this.props.getSource && await this.props.getSource(index, { signal }),
-					signal
-				};
-			},
-			renderSubLayers: (props) => {
-				const { data } = props;
-				const { source, signal, data: userData } = data;
-				return renderSource(source, {
-					data: userData,
-					signal
-				});
-			},
-			...onSourceLoad && { onTileLoad: (tile) => {
-				const source = tile.index;
-				onSourceLoad(source, { data: tile.content?.data });
-			} },
-			...onSourceError && { onTileError: (error, tile) => {
-				if (!tile) return;
-				const source = tile.index;
-				onSourceError(source, { error });
-			} },
-			...onSourceUnload && { onTileUnload: (tile) => {
-				const source = tile.index;
-				onSourceUnload(source, { data: tile.content?.data });
-			} },
-			...onViewportLoad && { onViewportLoad: (tiles) => {
-				onViewportLoad(tiles.map((tile) => ({
-					source: tile.index,
-					data: tile.content?.data
-				})));
-			} }
+	}
+	head() {
+		if (this._head) return this._head;
+		this._head = SourceHttp.fetch(this.url, {
+			method: "HEAD",
+			headers: this.headers
+		}).then((res) => {
+			if (!res.ok) {
+				delete this._head;
+				throw new Error(`Failed to HEAD ${this.url.href}`, { cause: {
+					statusCode: res.status,
+					msg: res.statusText
+				} });
+			}
+			this.metadata = getMetadataFromResponse(res);
+			return this.metadata;
 		});
+		return this._head;
 	}
-	renderLayers() {
-		const { sources, renderSource } = this.props;
-		if (!sources) return null;
-		return this.renderTileLayer(renderSource);
+	async fetch(offset, length, options) {
+		try {
+			const headers = {
+				range: ContentRange.toRange(offset, length),
+				...this.headers
+			};
+			const response = await SourceHttp.fetch(this.url, {
+				headers,
+				signal: options?.signal
+			});
+			if (!response.ok) throw new SourceError(`Failed to fetch ${this.url.href} ${headers.range}`, response.status, this, new Error(response.statusText));
+			const metadata = getMetadataFromResponse(response);
+			if (this.metadata == null) this.metadata = metadata;
+			else if (this.metadata.eTag && this.metadata.eTag !== metadata.eTag) throw new SourceError(`ETag conflict ${this.url.href} ${headers.range} expected: ${this.metadata.eTag} got: ${metadata.eTag}`, 409, this);
+			return response.arrayBuffer();
+		} catch (e) {
+			if (SourceError.is(e) && e.source === this) throw e;
+			throw new SourceError(`Failed to fetch: ${this.url.href}`, 500, this, e);
+		}
 	}
 };
+SourceHttp.fetch = (a, b) => fetch(a, b);
 //#endregion
 //#region src/lib/raster/repair-geokeys.ts
 var MODEL_TYPE_PROJECTED = 1;
@@ -24218,6 +23144,6 @@ var RasterControl = class {
 	}
 };
 //#endregion
-export { DEFAULT_TITILER_ENDPOINT as A, COLORMAP_ROW_COUNT as B, throttle as C, loadVrt as D, isVrtUrl as E, loadColormapSprite as F, statsForBand as G, colormaps_default as H, sampleColormapStops as I, mergeAutoStats as J, MAX_SAMPLE_TILES as K, COLORMAP_DISPLAY_NAMES as L, isMosaicJsonUrl as M, PALETTE_COLORMAP as N, parseVrt as O, isKnownColormap as P, createResilientEpsgResolver as Q, COLORMAP_NAMES as R, generateId as S, isVrtFile as T, DEFAULT_INDEX_RANGE as U, colormapDisplayName as V, autoRangeFor as W, percentileFromHistogram as X, mergeBandStats as Y, readBandNames as Z, parseMosaic as _, NORMALIZED_DIFFERENCE_INDICES as a, debounce as b, readPixelValues as c, MAX_MOSAIC_ASSETS as d, MosaicUnsupportedError as f, mosaicMinZoom as g, mosaicInitialView as h, CUSTOM_NORMALIZED_DIFFERENCE as i, TITILER_TMS as j, loadGeoTIFF as k, DEFAULT_ENGINE as l, loadMosaic as m, Colorbar as n, guessBandForRole as o, assetUrlToHttps as p, computeAutoStats as q, CUSTOM_INDEX_ID as r, indexById as s, RasterControl as t, LayerManager as u, clamp as v, VrtUnsupportedError as w, formatNumericValue as x, classNames as y, COLORMAP_OPTIONS as z };
+export { Photometric as $, DEFAULT_TITILER_ENDPOINT as A, COLORMAP_ROW_COUNT as B, throttle as C, loadVrt as D, isVrtUrl as E, loadColormapSprite as F, statsForBand as G, colormaps_default as H, sampleColormapStops as I, mergeAutoStats as J, MAX_SAMPLE_TILES as K, COLORMAP_DISPLAY_NAMES as L, isMosaicJsonUrl as M, PALETTE_COLORMAP as N, parseVrt as O, isKnownColormap as P, Compression as Q, COLORMAP_NAMES as R, generateId as S, isVrtFile as T, DEFAULT_INDEX_RANGE as U, colormapDisplayName as V, autoRangeFor as W, percentileFromHistogram as X, mergeBandStats as Y, readBandNames as Z, parseMosaic as _, NORMALIZED_DIFFERENCE_INDICES as a, debounce as b, readPixelValues as c, MAX_MOSAIC_ASSETS as d, PlanarConfiguration as et, MosaicUnsupportedError as f, mosaicMinZoom as g, mosaicInitialView as h, CUSTOM_NORMALIZED_DIFFERENCE as i, createResilientEpsgResolver as it, TITILER_TMS as j, loadGeoTIFF as k, DEFAULT_ENGINE as l, loadMosaic as m, Colorbar as n, SampleFormat as nt, guessBandForRole as o, assetUrlToHttps as p, computeAutoStats as q, CUSTOM_INDEX_ID as r, TiffTag as rt, indexById as s, RasterControl as t, Predictor as tt, LayerManager as u, clamp as v, VrtUnsupportedError as w, formatNumericValue as x, classNames as y, COLORMAP_OPTIONS as z };
 
-//# sourceMappingURL=RasterControl-BgzJWA7T.js.map
+//# sourceMappingURL=RasterControl-GAiOG6eI.js.map