maplibre-gl-raster 0.1.0

package/dist/decode-BMFOVF9X.js

@@ -0,0 +1,1966 @@
+//#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 = {}));
+/**
+* Convert tiff tag values when being read.
+*/
+var TiffTagConvertArray = {
+	[TiffTag.TileByteCounts]: true,
+	[TiffTag.TileOffsets]: true,
+	[TiffTag.StripOffsets]: true,
+	[TiffTag.StripByteCounts]: true,
+	[TiffTag.BitsPerSample]: true,
+	[TiffTag.SampleFormat]: true,
+	[TiffTag.GeoKeyDirectory]: true,
+	[TiffTag.GeoDoubleParams]: true
+};
+//#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 = {}));
+var TiffCompressionMimeType = {
+	[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
+};
+/**
+* Lookup the related mimetype for a compression id
+*
+* @param c Compression id
+* @returns mime type for compression
+*/
+function getCompressionMimeType(c) {
+	if (c == null) return null;
+	return TiffCompressionMimeType[c];
+}
+//#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/read/tiff.value.reader.js
+function getTiffTagSize(fieldType) {
+	switch (fieldType) {
+		case TiffTagValueType.Uint8:
+		case TiffTagValueType.Ascii:
+		case TiffTagValueType.Int8:
+		case TiffTagValueType.Undefined: return 1;
+		case TiffTagValueType.Uint16:
+		case TiffTagValueType.Int16: return 2;
+		case TiffTagValueType.Uint32:
+		case TiffTagValueType.Int32:
+		case TiffTagValueType.Float32:
+		case TiffTagValueType.Ifd: return 4;
+		case TiffTagValueType.Rational:
+		case TiffTagValueType.SignedRational:
+		case TiffTagValueType.Float64:
+		case TiffTagValueType.Uint64:
+		case TiffTagValueType.Int64:
+		case TiffTagValueType.Ifd8: return 8;
+		default: throw new Error(`Invalid fieldType ${String(fieldType)}`);
+	}
+}
+//#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 = {}));
+/** Shifting `<< 32` does not work in javascript */
+var POW_32 = 2 ** 32;
+/**
+* Read a uint64 at the offset
+*
+* This is not precise for large numbers
+* @see {DataView.getBigUint64}
+* @param offset offset to read
+*/
+function getUint64(view, offset, isLittleEndian) {
+	const left = view.getUint32(offset, isLittleEndian);
+	const right = view.getUint32(offset + 4, isLittleEndian);
+	const combined = isLittleEndian ? left + POW_32 * right : POW_32 * left + right;
+	if (!Number.isSafeInteger(combined)) throw new Error(combined + " exceeds MAX_SAFE_INTEGER. Precision may is lost");
+	return combined;
+}
+function getUint(view, offset, bs, isLittleEndian) {
+	switch (bs) {
+		case ByteSize.UInt8: return view.getUint8(offset);
+		case ByteSize.UInt16: return view.getUint16(offset, isLittleEndian);
+		case ByteSize.UInt32: return view.getUint32(offset, isLittleEndian);
+		case ByteSize.UInt64: return getUint64(view, offset, isLittleEndian);
+	}
+}
+//#endregion
+//#region node_modules/@cogeotiff/core/build/read/data.view.offset.js
+/**
+* Does a DataviewOffset include the absolute bytes of the source file
+*
+* @param view DataViewOffset to check
+* @param targetOffset the absolute offset in the file
+* @param count number of bytes to include
+*/
+function hasBytes(view, targetOffset, count) {
+	if (targetOffset < view.sourceOffset) return false;
+	if (view.sourceOffset + view.byteLength < targetOffset + count) return false;
+	return true;
+}
+//#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;
+var isLittleEndian = uint8[0] === 1;
+//#endregion
+//#region node_modules/@cogeotiff/core/build/read/tiff.tag.factory.js
+function readTagValue(fieldType, bytes, offset, isLittleEndian) {
+	switch (fieldType) {
+		case TiffTagValueType.Ascii: return String.fromCharCode(bytes.getUint8(offset));
+		case TiffTagValueType.Undefined:
+		case TiffTagValueType.Uint8: return bytes.getUint8(offset);
+		case TiffTagValueType.Int8: return bytes.getInt8(offset);
+		case TiffTagValueType.Uint16: return bytes.getUint16(offset, isLittleEndian);
+		case TiffTagValueType.Int16: return bytes.getInt16(offset, isLittleEndian);
+		case TiffTagValueType.Uint32:
+		case TiffTagValueType.Ifd: return bytes.getUint32(offset, isLittleEndian);
+		case TiffTagValueType.Int32: return bytes.getInt32(offset, isLittleEndian);
+		case TiffTagValueType.Rational: return [bytes.getUint32(offset, isLittleEndian), bytes.getUint32(offset + 4, isLittleEndian)];
+		case TiffTagValueType.SignedRational: return [bytes.getInt32(offset, isLittleEndian), bytes.getInt32(offset + 4, isLittleEndian)];
+		case TiffTagValueType.Float64: return bytes.getFloat64(offset, isLittleEndian);
+		case TiffTagValueType.Float32: return bytes.getFloat32(offset, isLittleEndian);
+		case TiffTagValueType.Uint64: return getUint64(bytes, offset, isLittleEndian);
+		default: throw new Error(`Unknown read type "${fieldType}" "${TiffTagValueType[fieldType]}"`);
+	}
+}
+/**
+* Convert a tiff tag value to a typed array if the local endian matches the tiff endian
+*
+* @param tiff
+* @param bytes
+* @param offset Offset in the data view to read from
+* @param length Number of bytes to read
+* @param type type of tiff tag
+* @returns the value if the type is a typed array and the endianness matches otherwise null
+*/
+function readTypedValue(tiff, bytes, offset, length, type) {
+	switch (type) {
+		case TiffTagValueType.Uint8: return new Uint8Array(bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length));
+		case TiffTagValueType.Uint16:
+			if (tiff.isLittleEndian !== isLittleEndian) return null;
+			return new Uint16Array(bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length));
+		case TiffTagValueType.Uint32:
+			if (tiff.isLittleEndian !== isLittleEndian) return null;
+			return new Uint32Array(bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length));
+	}
+	return null;
+}
+function readValue(tiff, tagId, bytes, offset, type, count) {
+	const typeSize = getTiffTagSize(type);
+	const dataLength = count * typeSize;
+	if (count === 1) {
+		const val = readTagValue(type, bytes, offset, tiff.isLittleEndian);
+		if (tagId && TiffTagConvertArray[tagId]) return [val];
+		return val;
+	}
+	switch (type) {
+		case TiffTagValueType.Ascii: return String.fromCharCode.apply(null, new Uint8Array(bytes.buffer, offset, dataLength - 1));
+	}
+	if (tagId === TiffTag.TileOffsets || tagId === TiffTag.TileByteCounts || tagId === TiffTag.StripOffsets || tagId === TiffTag.StripByteCounts) {
+		const typedOutput = readTypedValue(tiff, bytes, offset, dataLength, type);
+		if (typedOutput) return typedOutput;
+	}
+	const output = [];
+	for (let i = 0; i < dataLength; i += typeSize) output.push(readTagValue(type, bytes, offset + i, tiff.isLittleEndian));
+	return output;
+}
+/**
+* Determine if all the data for the tiff tag is loaded in and use that to create the specific CogTiffTag
+*
+* @see {@link Tag}
+*
+* @param tiff
+* @param view Bytes to read from
+* @param offset Offset in the dataview to read a tag
+*/
+function createTag(tiff, view, offset) {
+	const tagId = view.getUint16(offset + 0, tiff.isLittleEndian);
+	const dataType = view.getUint16(offset + 2, tiff.isLittleEndian);
+	const dataCount = getUint(view, offset + 4, tiff.ifdConfig.pointer, tiff.isLittleEndian);
+	const dataLength = getTiffTagSize(dataType) * dataCount;
+	if (dataLength <= tiff.ifdConfig.pointer) {
+		const value = readValue(tiff, tagId, view, offset + 4 + tiff.ifdConfig.pointer, dataType, dataCount);
+		return {
+			type: "inline",
+			id: tagId,
+			name: TiffTag[tagId],
+			count: dataCount,
+			value,
+			dataType,
+			tagOffset: offset
+		};
+	}
+	const dataOffset = getUint(view, offset + 4 + tiff.ifdConfig.pointer, tiff.ifdConfig.pointer, tiff.isLittleEndian);
+	switch (tagId) {
+		case TiffTag.TileOffsets:
+		case TiffTag.TileByteCounts:
+		case TiffTag.StripByteCounts:
+		case TiffTag.StripOffsets:
+			const tag = {
+				type: "offset",
+				id: tagId,
+				name: TiffTag[tagId],
+				count: dataCount,
+				dataType,
+				dataOffset,
+				isLoaded: false,
+				value: [],
+				tagOffset: offset
+			};
+			if (hasBytes(view, dataOffset, dataLength)) {
+				const val = readTypedValue(tiff, view, dataOffset - view.sourceOffset, dataLength, dataType);
+				if (val) {
+					tag.value = val;
+					tag.isLoaded = true;
+				} else setBytes(tag, view);
+			}
+			return tag;
+	}
+	if (hasBytes(view, dataOffset, dataLength)) {
+		const value = readValue(tiff, tagId, view, dataOffset - view.sourceOffset, dataType, dataCount);
+		return {
+			type: "inline",
+			id: tagId,
+			name: TiffTag[tagId],
+			count: dataCount,
+			value,
+			dataType,
+			tagOffset: offset
+		};
+	}
+	return {
+		type: "lazy",
+		id: tagId,
+		name: TiffTag[tagId],
+		count: dataCount,
+		dataOffset,
+		dataType,
+		tagOffset: offset
+	};
+}
+/** Fetch the value from a {@link TagLazy} tag */
+async function fetchLazy(tag, tiff, options) {
+	if (tag.value != null) return tag.value;
+	const dataLength = getTiffTagSize(tag.dataType) * tag.count;
+	const bytes = await tiff.source.fetch(tag.dataOffset, dataLength, options);
+	const view = new DataView(bytes);
+	tag.value = readValue(tiff, tag.id, view, 0, tag.dataType, tag.count);
+	return tag.value;
+}
+/**
+* Fetch all the values from a {@link TagOffset}
+*/
+async function fetchAllOffsets(tiff, tag, options) {
+	const dataTypeSize = getTiffTagSize(tag.dataType);
+	if (tag.view == null) {
+		const bytes = await tiff.source.fetch(tag.dataOffset, dataTypeSize * tag.count, options);
+		tag.view = new DataView(bytes);
+		tag.view.sourceOffset = tag.dataOffset;
+	}
+	tag.value = readValue(tiff, tag.id, tag.view, 0, tag.dataType, tag.count);
+	tag.view = void 0;
+	tag.isLoaded = true;
+	return tag.value;
+}
+function setBytes(tag, view) {
+	const dataTypeSize = getTiffTagSize(tag.dataType);
+	const startBytes = view.byteOffset + tag.dataOffset - view.sourceOffset;
+	tag.view = new DataView(view.buffer.slice(startBytes, startBytes + dataTypeSize * tag.count));
+	tag.view.sourceOffset = tag.dataOffset;
+}
+/** Partially fetch the values of a {@link TagOffset} and return the value for the offset */
+async function getValueAt(tiff, tag, index, options) {
+	if (index > tag.count || index < 0) throw new Error("TagOffset: out of bounds :" + index);
+	if (tag.value[index] != null) return tag.value[index];
+	const dataTypeSize = getTiffTagSize(tag.dataType);
+	if (tag.view == null) {
+		const bytes = await tiff.source.fetch(tag.dataOffset + index * dataTypeSize, dataTypeSize, options);
+		const value = readValue(tiff, void 0, new DataView(bytes), 0, tag.dataType, 1);
+		if (typeof value !== "number") throw new Error("Value is not a number");
+		tag.value[index] = value;
+		return value;
+	}
+	const value = readValue(tiff, void 0, tag.view, index * dataTypeSize, tag.dataType, 1);
+	if (typeof value !== "number") throw new Error("Value is not a number");
+	tag.value[index] = value;
+	return value;
+}
+function getValueAtSync(tiff, tag, index) {
+	if (index > tag.count || index < 0) throw new Error("TagOffset: out of bounds :" + index);
+	if (tag.value[index] != null) return tag.value[index];
+	if (tag.view == null) return null;
+	const dataTypeSize = getTiffTagSize(tag.dataType);
+	const value = readValue(tiff, void 0, tag.view, index * dataTypeSize, tag.dataType, 1);
+	if (typeof value !== "number") throw new Error("Value is not a number");
+	tag.value[index] = value;
+	return value;
+}
+/** Tags that are commonly accessed for geotiffs */
+var ImportantTags = new Set([
+	TiffTag.Compression,
+	TiffTag.ImageHeight,
+	TiffTag.ImageWidth,
+	TiffTag.ModelPixelScale,
+	TiffTag.ModelTiePoint,
+	TiffTag.ModelTransformation,
+	TiffTag.TileHeight,
+	TiffTag.TileWidth
+]);
+var ImportantGeoTags = new Set([
+	TiffTag.GeoKeyDirectory,
+	TiffTag.GeoAsciiParams,
+	TiffTag.GeoDoubleParams
+]);
+var TiffImage = class {
+	/**
+	* Id of the tif image, generally the image index inside the tif
+	* where 0 is the root image, and every sub image is +1
+	*
+	* @example 0, 1, 2
+	*/
+	id;
+	/** Reference to the TIFF that owns this image */
+	tiff;
+	/** Has loadGeoTiffTags been called */
+	isGeoTagsLoaded = false;
+	/** Sub tags stored in TiffTag.GeoKeyDirectory */
+	tagsGeo = /* @__PURE__ */ new Map();
+	/** All IFD tags that have been read for the image */
+	tags;
+	constructor(tiff, id, tags) {
+		this.tiff = tiff;
+		this.id = id;
+		this.tags = tags;
+	}
+	/**
+	* Force loading of important tags if they have not already been loaded
+	*
+	* @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
+	*/
+	async init(loadGeoTags = true, options) {
+		const requiredTags = [];
+		ImportantTags.forEach((tag) => {
+			requiredTags.push(this.fetch(tag, options));
+		});
+		if (loadGeoTags) ImportantGeoTags.forEach((tag) => {
+			requiredTags.push(this.fetch(tag, options));
+		});
+		await Promise.all(requiredTags);
+		if (loadGeoTags) await this.loadGeoTiffTags();
+	}
+	/**
+	* Get the value of a TiffTag if it has been loaded, null otherwise.
+	*
+	* If the value is not loaded use {@link TiffImage.fetch} to load the value
+	* Or use {@link TiffImage.has} to check if the tag exists
+	*
+	*
+	* @returns value if loaded, null otherwise
+	*/
+	value(tag) {
+		const sourceTag = this.tags.get(tag);
+		if (sourceTag == null) return null;
+		if (sourceTag.type === "offset" && sourceTag.isLoaded === false) return null;
+		return sourceTag.value;
+	}
+	/**
+	* Does the tag exist
+	*
+	* @example
+	* ```typescript
+	* img.has(TiffTag.ImageWidth) // true
+	* ```
+	*
+	* @param tag Tag to check
+	* @returns true if the tag exists, false otherwise
+	*/
+	has(tag) {
+		return this.tags.has(tag);
+	}
+	/**
+	* Load a tag.
+	*
+	* If it is not currently loaded, fetch the required data for the tag.
+	*
+	* @example
+	* ```typescript
+	* await img.fetch(TiffTag.ImageWidth) // 512 (px)
+	* ```
+	*
+	* @param tag tag to fetch
+	*/
+	async fetch(tag, options) {
+		const sourceTag = this.tags.get(tag);
+		if (sourceTag == null) return null;
+		if (sourceTag.type === "inline") return sourceTag.value;
+		if (sourceTag.type === "lazy") return fetchLazy(sourceTag, this.tiff, options);
+		if (sourceTag.isLoaded) return sourceTag.value;
+		if (sourceTag.type === "offset") return fetchAllOffsets(this.tiff, sourceTag, options);
+		throw new Error("Cannot fetch:" + tag);
+	}
+	/**
+	* Get the associated TiffTagGeo
+	*
+	* @example
+	* ```typescript
+	* image.valueGeo(TiffTagGeo.GTRasterTypeGeoKey)
+	* ```
+	* @throws if {@link loadGeoTiffTags} has not been called
+	*/
+	valueGeo(tag) {
+		if (this.isGeoTagsLoaded === false) throw new Error("loadGeoTiffTags() has not been called");
+		return this.tagsGeo.get(tag);
+	}
+	/**
+	* Load and parse the GDAL_NODATA Tifftag
+	*
+	* @throws if the tag is not loaded
+	* @returns null if the tag does not exist
+	*/
+	get noData() {
+		const tag = this.tags.get(TiffTag.GdalNoData);
+		if (tag == null) return null;
+		if (tag.value != null) return Number(tag.value);
+		throw new Error("GdalNoData tag is not loaded");
+	}
+	/**
+	* Load and unpack the GeoKeyDirectory
+	*
+	* @see {TiffTag.GeoKeyDirectory}
+	*/
+	async loadGeoTiffTags() {
+		if (this.isGeoTagsLoaded) return;
+		const sourceTag = this.tags.get(TiffTag.GeoKeyDirectory);
+		if (sourceTag == null) {
+			this.isGeoTagsLoaded = true;
+			return;
+		}
+		if (sourceTag.type === "lazy" && sourceTag.value == null) await Promise.all([
+			this.fetch(TiffTag.GeoKeyDirectory),
+			this.fetch(TiffTag.GeoAsciiParams),
+			this.fetch(TiffTag.GeoDoubleParams)
+		]);
+		this.isGeoTagsLoaded = true;
+		if (sourceTag.value == null) return;
+		const geoTags = sourceTag.value;
+		if (typeof geoTags === "number") throw new Error("Invalid geo tags found");
+		for (let i = 4; i <= geoTags[3] * 4; i += 4) {
+			const key = geoTags[i];
+			const locationTagId = geoTags[i + 1];
+			const offset = geoTags[i + 3];
+			if (locationTagId === 0) {
+				this.tagsGeo.set(key, offset);
+				continue;
+			}
+			const tag = this.tags.get(locationTagId);
+			if (tag == null || tag.value == null) continue;
+			const count = geoTags[i + 2];
+			if (typeof tag.value === "string") this.tagsGeo.set(key, tag.value.slice(offset, offset + count - 1).trim());
+			else if (Array.isArray(tag.value)) if (count === 1) this.tagsGeo.set(key, tag.value[offset]);
+			else this.tagsGeo.set(key, tag.value.slice(offset, offset + count));
+			else throw new Error("Failed to extract GeoTiffTags");
+		}
+	}
+	/**
+	* Get the origin point for the image
+	*
+	* @returns origin point of the image
+	*/
+	get origin() {
+		const tiePoints = this.value(TiffTag.ModelTiePoint);
+		if (tiePoints != null && tiePoints.length === 6) return [
+			tiePoints[3],
+			tiePoints[4],
+			tiePoints[5]
+		];
+		const modelTransformation = this.value(TiffTag.ModelTransformation);
+		if (modelTransformation != null) return [
+			modelTransformation[3],
+			modelTransformation[7],
+			modelTransformation[11]
+		];
+		if (this.value(TiffTag.SubFileType) === SubFileType.ReducedImage && this.id !== 0) return this.tiff.images[0].origin;
+		throw new Error("Image does not have a geo transformation.");
+	}
+	/** Is there enough geo information on this image to figure out where its actually located */
+	get isGeoLocated() {
+		if (this.value(TiffTag.ModelPixelScale) != null || this.value(TiffTag.ModelTransformation) != null) return true;
+		if (this.isSubImage && this.id !== 0) return this.tiff.images[0].isGeoLocated;
+		return false;
+	}
+	/**
+	* Get the resolution of the image
+	*
+	* @returns [x,y,z] pixel scale
+	*/
+	get resolution() {
+		const modelPixelScale = this.value(TiffTag.ModelPixelScale);
+		if (modelPixelScale != null) return [
+			modelPixelScale[0],
+			-modelPixelScale[1],
+			modelPixelScale[2]
+		];
+		const modelTransformation = this.value(TiffTag.ModelTransformation);
+		if (modelTransformation != null) return [
+			modelTransformation[0],
+			modelTransformation[5],
+			modelTransformation[10]
+		];
+		if (this.isSubImage && this.id !== 0) {
+			const firstImg = this.tiff.images[0];
+			const [resX, resY, resZ] = firstImg.resolution;
+			const firstImgSize = firstImg.size;
+			const imgSize = this.size;
+			return [
+				resX * firstImgSize.width / imgSize.width,
+				resY * firstImgSize.height / imgSize.height,
+				resZ
+			];
+		}
+		throw new Error("Image does not have a geo transformation.");
+	}
+	/**
+	* Is this image a reduced size image
+	* @see {@link TiffTag.SubFileType}
+	* @returns true if SubFileType is Reduces image, false otherwise
+	*/
+	get isSubImage() {
+		return this.value(TiffTag.SubFileType) === SubFileType.ReducedImage;
+	}
+	/**
+	* Bounding box of the image
+	*
+	* @returns [minX, minY, maxX, maxY] bounding box
+	*/
+	get bbox() {
+		const size = this.size;
+		const origin = this.origin;
+		const resolution = this.resolution;
+		if (origin == null || size == null || resolution == null) throw new Error("Unable to calculate bounding box");
+		const x1 = origin[0];
+		const y1 = origin[1];
+		const x2 = x1 + resolution[0] * size.width;
+		const y2 = y1 + resolution[1] * size.height;
+		return [
+			Math.min(x1, x2),
+			Math.min(y1, y2),
+			Math.max(x1, x2),
+			Math.max(y1, y2)
+		];
+	}
+	/**
+	* Get the compression used by the tile
+	*
+	* @see {@link TiffCompressionMimeType}
+	*
+	* @returns Compression type eg webp
+	*/
+	get compression() {
+		const compression = this.value(TiffTag.Compression);
+		if (compression == null) return null;
+		return TiffCompressionMimeType[compression];
+	}
+	/**
+	* Attempt to read the EPSG Code from TiffGeoTags
+	*
+	* looks at TiffTagGeo.ProjectionGeoKey, TiffTagGeo.ProjectedCRSGeoKey and TiffTagGeo.GeodeticCRSGeoKey
+	*
+	* @returns EPSG Code if it exists and is not user defined.
+	*/
+	get epsg() {
+		const proj = this.valueGeo(TiffTagGeo.ProjectionGeoKey);
+		if (proj != null && proj !== 32767) return proj;
+		let projection = null;
+		switch (this.valueGeo(TiffTagGeo.GTModelTypeGeoKey)) {
+			case ModelTypeCode.Unknown: return null;
+			case ModelTypeCode.Projected:
+				projection = this.valueGeo(TiffTagGeo.ProjectedCRSGeoKey);
+				break;
+			case ModelTypeCode.Geographic:
+				projection = this.valueGeo(TiffTagGeo.GeodeticCRSGeoKey);
+				break;
+			case ModelTypeCode.Geocentric:
+				projection = this.valueGeo(TiffTagGeo.GeodeticCRSGeoKey);
+				break;
+			case ModelTypeCode.UserDefined: return null;
+		}
+		if (projection === 32767) return null;
+		return projection;
+	}
+	/**
+	* Get the size of the image
+	*
+	* @returns Size in pixels
+	*/
+	get size() {
+		const width = this.value(TiffTag.ImageWidth);
+		const height = this.value(TiffTag.ImageHeight);
+		if (width == null || height == null) throw new Error("Tiff has no height or width");
+		return {
+			width,
+			height
+		};
+	}
+	/**
+	* Determine if this image is tiled
+	*/
+	isTiled() {
+		return this.value(TiffTag.TileWidth) !== null;
+	}
+	/**
+	* Get size of individual tiles
+	*/
+	get tileSize() {
+		const width = this.value(TiffTag.TileWidth);
+		const height = this.value(TiffTag.TileHeight);
+		if (width == null || height == null) throw new Error("Tiff is not tiled");
+		return {
+			width,
+			height
+		};
+	}
+	/**
+	* Number of tiles used to create this image
+	*/
+	get tileCount() {
+		const size = this.size;
+		const tileSize = this.tileSize;
+		return {
+			x: Math.ceil(size.width / tileSize.width),
+			y: Math.ceil(size.height / tileSize.height)
+		};
+	}
+	/**
+	* Get the pointer to where the tiles start in the Tiff file
+	*
+	* @remarks Used to read tiled tiffs
+	*
+	* @returns file offset to where the tiffs are stored
+	*/
+	get tileOffset() {
+		const tileOffset = this.tags.get(TiffTag.TileOffsets);
+		if (tileOffset == null) throw new Error("No tile offsets found");
+		return tileOffset;
+	}
+	/**
+	* Get the number of strip's inside this tiff
+	*
+	* @remarks Used to read striped tiffs
+	*
+	* @returns number of strips present
+	*/
+	get stripCount() {
+		return this.tags.get(TiffTag.StripByteCounts)?.count ?? 0;
+	}
+	getTileBounds(x, y) {
+		const { size, tileSize } = this;
+		const top = y * tileSize.height;
+		const left = x * tileSize.width;
+		return {
+			x: left,
+			y: top,
+			width: left + tileSize.width >= size.width ? size.width - left : tileSize.width,
+			height: top + tileSize.height >= size.height ? size.height - top : tileSize.height
+		};
+	}
+	/**
+	* Read a strip into a ArrayBuffer
+	*
+	* Image has to be striped see {@link stripCount}
+	*
+	* @param index Strip index to read
+	*/
+	async getStrip(index, options) {
+		if (this.isTiled()) throw new Error("Cannot read stripes, tiff is tiled: " + index);
+		const byteCounts = this.tags.get(TiffTag.StripByteCounts);
+		const offsets = this.tags.get(TiffTag.StripOffsets);
+		if (index >= byteCounts.count) throw new Error("Cannot read strip, index out of bounds");
+		const [byteCount, offset] = await Promise.all([getOffset(this.tiff, offsets, index, options), getOffset(this.tiff, byteCounts, index, options)]);
+		return this.getBytes(byteCount, offset, options);
+	}
+	/** The jpeg header is stored in the IFD, read the JPEG header and adjust the byte array to include it */
+	getJpegHeader(bytes) {
+		const tables = this.value(TiffTag.JpegTables);
+		if (tables == null) throw new Error("Unable to find Jpeg header");
+		const tableData = tables.slice(0, tables.length - 2);
+		const actualBytes = new Uint8Array(bytes.byteLength + tableData.length - 2);
+		actualBytes.set(tableData, 0);
+		actualBytes.set(new Uint8Array(bytes).slice(2), tableData.length);
+		return actualBytes.buffer.slice(actualBytes.byteOffset, actualBytes.byteOffset + actualBytes.byteLength);
+	}
+	/** Read image bytes at the given offset */
+	async getBytes(offset, byteCount, options) {
+		if (byteCount === 0) return null;
+		const bytes = await this.tiff.source.fetch(offset, byteCount, options);
+		if (bytes.byteLength < byteCount) throw new Error(`Failed to fetch bytes from offset:${offset} wanted:${byteCount} got:${bytes.byteLength}`);
+		let compression = this.value(TiffTag.Compression);
+		if (compression == null) compression = Compression.None;
+		const mimeType = getCompressionMimeType(compression) ?? TiffMimeType.None;
+		if (compression === Compression.Jpeg) return {
+			mimeType,
+			bytes: this.getJpegHeader(bytes),
+			compression
+		};
+		return {
+			mimeType,
+			bytes,
+			compression
+		};
+	}
+	/**
+	* Load a tile into a ArrayBuffer
+	*
+	* if the tile compression is JPEG, This will also apply the JPEG compression tables to the resulting ArrayBuffer see {@link getJpegHeader}
+	*
+	* @param x Tile x offset
+	* @param y Tile y offset
+	*/
+	async getTile(x, y, options) {
+		const size = this.size;
+		const tiles = this.tileSize;
+		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 this.getTileSize(idx, options);
+		return this.getBytes(offset, imageSize, options);
+	}
+	/**
+	* Does this tile exist in the tiff and does it actually have a value
+	*
+	* Sparse tiffs can have a lot of empty tiles, they set the tile size to `0 bytes` when the tile is empty
+	* this checks the tile byte size to validate if it actually has any data.
+	*
+	* @param x Tile x offset
+	* @param y Tile y offset
+	*
+	* @returns if the tile exists and has data
+	*/
+	async hasTile(x, y, options) {
+		const tiles = this.tileSize;
+		const size = this.size;
+		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) return false;
+		const idx = y * nxTiles + x;
+		return (await this.getTileSize(idx, options)).offset > 0;
+	}
+	/**
+	* Load the offset and byteCount of a tile
+	*
+	* if the tiff is sparse, offset and byteCount will be zero if the tile is empty
+	*
+	* @param index index in the tile array
+	* @returns Offset and byteCount for the tile
+	*/
+	async getTileSize(index, options) {
+		const byteCounts = this.tags.get(TiffTag.TileByteCounts);
+		const tileOffset = getOffsetSync(this.tiff, this.tileOffset, index);
+		const tileSize = getOffsetSync(this.tiff, byteCounts, index);
+		if (tileOffset != null && tileSize != null) return {
+			offset: tileOffset,
+			imageSize: tileSize
+		};
+		const leaderBytes = this.tiff.options?.tileLeaderByteSize;
+		if (leaderBytes) {
+			const offset = tileOffset ?? await getOffset(this.tiff, this.tileOffset, index, options);
+			if (offset === 0) return {
+				offset: 0,
+				imageSize: 0
+			};
+			const bytes = await this.tiff.source.fetch(offset - leaderBytes, leaderBytes, options);
+			return {
+				offset,
+				imageSize: getUint(new DataView(bytes), 0, leaderBytes, this.tiff.isLittleEndian)
+			};
+		}
+		if (byteCounts == null) throw new Error("No tile byte counts found");
+		const [offset, imageSize] = await Promise.all([tileOffset ?? getOffset(this.tiff, this.tileOffset, index, options), tileSize ?? getOffset(this.tiff, byteCounts, index, options)]);
+		return {
+			offset,
+			imageSize
+		};
+	}
+};
+function getOffset(tiff, x, index, options) {
+	const val = getOffsetSync(tiff, x, index);
+	if (val != null) return Promise.resolve(val);
+	return getValueAt(tiff, x, index, options);
+}
+function getOffsetSync(tiff, x, index) {
+	if (index < 0) throw new Error(`Tiff: ${tiff.source.url.href} out of bounds ${TiffTag[x.id]} index:${index} total:${x.count}`);
+	if (index >= x.count) return 0;
+	if (x.type === "inline") return x.value[index];
+	if (x.isLoaded) return x.value[index];
+	return getValueAtSync(tiff, x, index);
+}
+//#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 = {}));
+/**
+* GDAL has made a ghost set of options for Tiff files
+* this class represents the optimizations that GDAL has applied
+*/
+var TiffGhostOptions = class {
+	options = /* @__PURE__ */ new Map();
+	/**
+	* Has GDAL optimized this tiff
+	*/
+	get isCogOptimized() {
+		if (this.isBroken) return false;
+		return this.options.get(GhostOption.Layout) === "IFDS_BEFORE_DATA";
+	}
+	/**
+	* Has GDAL determined this tiff is now broken
+	*/
+	get isBroken() {
+		return this.options.get(GhostOption.KnownIncompatibleEdition) === "YES";
+	}
+	/**
+	* Load the ghost options from a source
+	* @param bytes the ghost header bytes
+	*/
+	process(bytes, offset, ghostSize) {
+		let key = "";
+		let value = "";
+		let setValue = false;
+		for (let i = 0; i < ghostSize; i++) {
+			const charCode = bytes.getUint8(offset + i);
+			if (charCode === 0) break;
+			const char = String.fromCharCode(charCode);
+			if (char === "\n") {
+				this.options.set(key.trim(), value.trim());
+				key = "";
+				value = "";
+				setValue = false;
+			} else if (char === "=") setValue = true;
+			else if (setValue) value += char;
+			else key += char;
+		}
+	}
+	/**
+	* If the tile leader is set, how many bytes are allocated to the tile size
+	*/
+	get tileLeaderByteSize() {
+		switch (this.options.get(GhostOption.BlockLeader)) {
+			case GhostOptionTileLeader.uint32: return ByteSize.UInt32;
+			default: return null;
+		}
+	}
+	get isMaskInterleaved() {
+		return this.options.get(GhostOption.MaskInterleavedWithImagery) === "YES";
+	}
+};
+//#endregion
+//#region node_modules/@cogeotiff/core/build/read/tiff.ifd.config.js
+var TagTiffConfig = {
+	version: TiffVersion.Tiff,
+	pointer: ByteSize.UInt32,
+	offset: ByteSize.UInt16,
+	/**
+	* Each tag entry is specified as
+	* UInt16:TagCode
+	* UInt16:TagType
+	* UInt32:TagCount
+	* UInt32:Pointer To Value or value
+	*/
+	ifd: ByteSize.UInt16 + ByteSize.UInt16 + 2 * ByteSize.UInt32
+};
+var TagTiffBigConfig = {
+	version: TiffVersion.BigTiff,
+	/** Size of most pointers */
+	pointer: ByteSize.UInt64,
+	/** Size of offsets */
+	offset: ByteSize.UInt64,
+	/**
+	* Each tag entry is specified as
+	* UInt16:TagCode
+	* UInt16:TagType
+	* UInt64:TagCount
+	* UInt64:Pointer To Value or value
+	*/
+	ifd: ByteSize.UInt16 + ByteSize.UInt16 + 2 * ByteSize.UInt64
+};
+TiffVersion.BigTiff, TiffVersion.Tiff;
+//#endregion
+//#region node_modules/@cogeotiff/core/build/util/util.hex.js
+/**
+* Convert a number to a formatted hex string
+*
+* @param num number to convert
+* @param padding number of 0's to pad the digit with
+* @param prefix should a `0x` be prefixed to the string
+*
+* @returns hex string eg 0x0015
+**/
+function toHex(num, padding = 4, prefix = true) {
+	const hex = num.toString(16).padStart(padding, "0");
+	if (prefix) return "0x" + hex;
+	return hex;
+}
+//#endregion
+//#region node_modules/@cogeotiff/core/build/tiff.js
+var Tiff = class Tiff {
+	/** Read 16KB blocks at a time */
+	static DefaultReadSize = 16 * 1024;
+	/** Read 16KB blocks at a time */
+	defaultReadSize = Tiff.DefaultReadSize;
+	/** Where this cog is fetching its data from */
+	source;
+	/** Big or small Tiff */
+	version = TiffVersion.Tiff;
+	/** List of images, o is the base image */
+	images = [];
+	/** Ghost header options */
+	options;
+	/** Configuration for the size of the IFD */
+	ifdConfig = TagTiffConfig;
+	/** Is the tiff being read is little Endian */
+	isLittleEndian = false;
+	/** Has init() been called */
+	isInitialized = false;
+	_initPromise;
+	/** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
+	constructor(source, options = { defaultReadSize: Tiff.DefaultReadSize }) {
+		this.source = source;
+		this.defaultReadSize = options.defaultReadSize;
+	}
+	/** Create a tiff and initialize it by reading the tiff headers */
+	static create(source, options = { defaultReadSize: Tiff.DefaultReadSize }) {
+		return new Tiff(source, options).init(options);
+	}
+	/**
+	* Initialize the tiff loading in the header and all image headers.
+	*
+	* This is only required if the Tiff was created with the constructor, if you
+	* used {@link create} this will have already been called.
+	*/
+	init(options) {
+		if (this.isInitialized) return Promise.resolve(this);
+		if (this._initPromise) return this._initPromise;
+		this._initPromise = this.readHeader(options);
+		return this._initPromise;
+	}
+	/**
+	* Find a image which has a resolution similar to the provided resolution
+	*
+	* @param resolution resolution to find
+	*/
+	getImageByResolution(resolution) {
+		const firstImage = this.images[0];
+		const firstImageSize = firstImage.size;
+		const [refX] = firstImage.resolution;
+		const resolutionBaseX = refX * firstImageSize.width;
+		for (let i = this.images.length - 1; i > 0; i--) {
+			const img = this.images[i];
+			if (resolutionBaseX / img.size.width - resolution <= .01) return img;
+		}
+		return firstImage;
+	}
+	/** Read the Starting header and all Image headers from the source */
+	async readHeader(options) {
+		if (this.isInitialized) return this;
+		const bytes = new DataView(await this.source.fetch(0, getMaxLength(this.source, 0, this.defaultReadSize), options));
+		if (bytes.byteLength === 0) throw new Error("Unable to read empty tiff");
+		bytes.sourceOffset = 0;
+		let offset = 0;
+		const endian = bytes.getUint16(offset, this.isLittleEndian);
+		offset += 2;
+		this.isLittleEndian = endian === TiffEndian.Little;
+		this.version = bytes.getUint16(offset, this.isLittleEndian);
+		offset += 2;
+		let nextOffsetIfd;
+		if (this.version === TiffVersion.BigTiff) {
+			this.ifdConfig = TagTiffBigConfig;
+			const pointerSize = bytes.getUint16(offset, this.isLittleEndian);
+			offset += 2;
+			if (pointerSize !== 8) throw new Error("Only 8byte pointers are supported");
+			const zeros = bytes.getUint16(offset, this.isLittleEndian);
+			offset += 2;
+			if (zeros !== 0) throw new Error("Invalid big tiff header");
+			nextOffsetIfd = getUint(bytes, offset, this.ifdConfig.pointer, this.isLittleEndian);
+			offset += this.ifdConfig.pointer;
+		} else if (this.version === TiffVersion.Tiff) {
+			nextOffsetIfd = getUint(bytes, offset, this.ifdConfig.pointer, this.isLittleEndian);
+			offset += this.ifdConfig.pointer;
+		} else throw new Error(`Only tiff supported version:${String(this.version)}`);
+		const ghostSize = nextOffsetIfd - offset;
+		if (ghostSize > 0 && ghostSize < 16 * 1024) {
+			this.options = new TiffGhostOptions();
+			this.options.process(bytes, offset, ghostSize);
+		}
+		while (nextOffsetIfd !== 0) {
+			let lastView = bytes;
+			if (!hasBytes(lastView, nextOffsetIfd, 1024)) {
+				const bytes = await this.source.fetch(nextOffsetIfd, getMaxLength(this.source, nextOffsetIfd, this.defaultReadSize), options);
+				lastView = new DataView(bytes);
+				lastView.sourceOffset = nextOffsetIfd;
+			}
+			nextOffsetIfd = this.readIfd(nextOffsetIfd, lastView);
+		}
+		await Promise.all(this.images.map((i) => i.init(true, options)));
+		this.isInitialized = true;
+		return this;
+	}
+	/**
+	* Read a IFD at a the provided offset
+	*
+	* @param offset file offset to read the header from
+	* @param view offset that contains the bytes for the header
+	*/
+	readIfd(offset, view) {
+		const viewOffset = offset - view.sourceOffset;
+		const tagCount = getUint(view, viewOffset, this.ifdConfig.offset, this.isLittleEndian);
+		const tags = /* @__PURE__ */ new Map();
+		if (!hasBytes(view, offset, tagCount * this.ifdConfig.ifd)) throw new Error("IFD out of range @ " + toHex(offset) + " IFD" + this.images.length);
+		const ifdSize = this.ifdConfig.ifd;
+		const startOffset = viewOffset + this.ifdConfig.offset;
+		for (let i = 0; i < tagCount; i++) {
+			const tag = createTag(this, view, startOffset + i * ifdSize);
+			tags.set(tag.id, tag);
+		}
+		this.images.push(new TiffImage(this, this.images.length, tags));
+		return getUint(view, startOffset + tagCount * ifdSize, this.ifdConfig.pointer, this.isLittleEndian);
+	}
+};
+function getMaxLength(source, offset, length) {
+	const size = source.metadata?.size;
+	if (size == null || size < 0) return length;
+	if (offset + length > size) return size - offset;
+	return length;
+}
+//#endregion
+//#region node_modules/@developmentseed/geotiff/dist/codecs/canvas.js
+async function decode$2(bytes, metadata) {
+	const blob = new Blob([bytes]);
+	const imageBitmap = await createImageBitmap(blob);
+	const canvas = new OffscreenCanvas(imageBitmap.width, imageBitmap.height);
+	const ctx = canvas.getContext("2d");
+	ctx.drawImage(imageBitmap, 0, 0);
+	imageBitmap.close();
+	const { width, height } = canvas;
+	const rgba = ctx.getImageData(0, 0, width, height).data;
+	const samplesPerPixel = metadata.samplesPerPixel;
+	if (samplesPerPixel === 4) return {
+		layout: "pixel-interleaved",
+		data: rgba
+	};
+	if (samplesPerPixel === 3) {
+		const pixelCount = width * height;
+		const rgb = new Uint8ClampedArray(pixelCount * 3);
+		for (let i = 0, j = 0; i < rgb.length; i += 3, j += 4) {
+			rgb[i] = rgba[j];
+			rgb[i + 1] = rgba[j + 1];
+			rgb[i + 2] = rgba[j + 2];
+		}
+		return {
+			layout: "pixel-interleaved",
+			data: rgb
+		};
+	}
+	throw new Error(`Unsupported SamplesPerPixel for JPEG: ${samplesPerPixel}`);
+}
+//#endregion
+//#region node_modules/@developmentseed/geotiff/dist/codecs/decompression-stream.js
+function assert(expression, msg = "") {
+	if (!expression) throw new Error(msg);
+}
+async function decompressWithDecompressionStream(data, { format, signal }) {
+	const response = data instanceof Response ? data : new Response(data);
+	assert(response.body, "Response does not contain body.");
+	try {
+		return await new Response(response.body.pipeThrough(new DecompressionStream(format), { signal })).arrayBuffer();
+	} catch {
+		signal?.throwIfAborted();
+		throw new Error(`Failed to decode ${format}`);
+	}
+}
+//#endregion
+//#region node_modules/@developmentseed/geotiff/dist/codecs/deflate.js
+async function decode$1(bytes) {
+	return decompressWithDecompressionStream(bytes, { format: "deflate" });
+}
+//#endregion
+//#region node_modules/@developmentseed/geotiff/dist/codecs/predictor.js
+/**
+* Undo TIFF horizontal differencing (predictor 2) or floating-point
+* prediction (predictor 3) in-place on a decoded tile buffer.
+*
+* Mirrors the applyPredictor logic in geotiff.js.
+*/
+/** Undo horizontal differencing for integer samples (predictor 2). */
+function decodeRowAcc(row, stride) {
+	const r = row;
+	let offset = 0;
+	let length = row.length - stride;
+	do {
+		for (let i = stride; i > 0; i--) {
+			r[offset + stride] = (r[offset + stride] ?? 0) + (r[offset] ?? 0);
+			offset++;
+		}
+		length -= stride;
+	} while (length > 0);
+}
+/** Undo floating-point horizontal differencing (predictor 3). */
+function decodeRowFloatingPoint(row, stride, bytesPerSample) {
+	let index = 0;
+	let count = row.length;
+	const wc = count / bytesPerSample;
+	while (count > stride) {
+		for (let i = stride; i > 0; i--) {
+			row[index + stride] += row[index];
+			index++;
+		}
+		count -= stride;
+	}
+	const copy = row.slice();
+	for (let i = 0; i < wc; i++) for (let b = 0; b < bytesPerSample; b++) row[bytesPerSample * i + b] = copy[(bytesPerSample - b - 1) * wc + i];
+}
+/**
+* Apply TIFF predictor decoding to a raw decoded tile buffer in-place.
+*
+* @param block              Decoded tile bytes.
+* @param predictor          Predictor enum value.
+* @param width              Tile width in pixels.
+* @param height             Tile height in pixels.
+* @param bitsPerSample      Bits per sample (all samples must be equal).
+* @param samplesPerPixel    Number of bands.
+* @param planarConfiguration  PlanarConfiguration enum value.
+*/
+function applyPredictor(block, predictor, width, height, bitsPerSample, samplesPerPixel, planarConfiguration) {
+	if (predictor === Predictor.None) return block;
+	const bytesPerSample = bitsPerSample / 8;
+	const stride = planarConfiguration === PlanarConfiguration.Separate ? 1 : samplesPerPixel;
+	for (let i = 0; i < height; i++) {
+		const byteOffset = i * stride * width * bytesPerSample;
+		if (byteOffset >= block.byteLength) break;
+		if (predictor === Predictor.Horizontal) {
+			let row;
+			const length = stride * width;
+			switch (bitsPerSample) {
+				case 8:
+					row = new Uint8Array(block, byteOffset, length);
+					break;
+				case 16:
+					row = new Uint16Array(block, byteOffset, length);
+					break;
+				case 32:
+					row = new Uint32Array(block, byteOffset, length);
+					break;
+				default: throw new Error(`Predictor 2 not supported for ${bitsPerSample} bits per sample.`);
+			}
+			decodeRowAcc(row, stride);
+		} else if (predictor === Predictor.FloatingPoint) decodeRowFloatingPoint(new Uint8Array(block, byteOffset, stride * width * bytesPerSample), stride, bytesPerSample);
+	}
+	return block;
+}
+//#endregion
+//#region node_modules/@developmentseed/geotiff/dist/decode.js
+async function decodeUncompressed(bytes) {
+	return bytes;
+}
+/**
+* The global registry of decoders for each compression type.
+*
+* This maps a {@link Compression} value to a function that returns a promise of
+* a {@link Decoder}.
+*/
+var DECODER_REGISTRY = /* @__PURE__ */ new Map();
+DECODER_REGISTRY.set(Compression.None, () => Promise.resolve(decodeUncompressed));
+DECODER_REGISTRY.set(Compression.Deflate, () => Promise.resolve(decode$1));
+DECODER_REGISTRY.set(Compression.DeflateOther, () => Promise.resolve(decode$1));
+DECODER_REGISTRY.set(Compression.Lzw, () => import("./lzw-YEsReV21.js").then((m) => m.decode));
+DECODER_REGISTRY.set(Compression.Zstd, () => import("./zstd-DBZv9xja.js").then((m) => m.decode));
+DECODER_REGISTRY.set(Compression.Jpeg, () => Promise.resolve(decode$2));
+DECODER_REGISTRY.set(Compression.Jpeg6, () => Promise.resolve(decode$2));
+DECODER_REGISTRY.set(Compression.Webp, () => Promise.resolve(decode$2));
+DECODER_REGISTRY.set(Compression.Lerc, () => import("./lerc-B7WY-v3y.js").then((m) => m.decode));
+/**
+* Decode a tile's bytes according to its compression and image metadata.
+*/
+async function decode(bytes, compression, metadata) {
+	const loader = DECODER_REGISTRY.get(compression);
+	if (!loader) throw new Error(`Unsupported compression: ${compression}`);
+	const result = await (await loader())(bytes, metadata);
+	if (result instanceof ArrayBuffer) {
+		const { predictor, width, height, bitsPerSample, samplesPerPixel, planarConfiguration } = metadata;
+		return {
+			layout: "pixel-interleaved",
+			data: toTypedArray(applyPredictor(result, predictor, width, height, bitsPerSample, samplesPerPixel, planarConfiguration), metadata)
+		};
+	}
+	return result;
+}
+/**
+* Unpack a 1-bit packed mask buffer (MSB-first) into a Uint8Array of 0/255.
+* Each input byte holds 8 pixels; bit 7 is the first pixel in that byte.
+*/
+function unpackBitPacked(buffer, pixelCount) {
+	const packed = new Uint8Array(buffer);
+	const out = new Uint8Array(pixelCount);
+	for (let i = 0; i < pixelCount; i++) out[i] = packed[i >> 3] >> 7 - (i & 7) & 1 ? 255 : 0;
+	return out;
+}
+/**
+* Convert a raw ArrayBuffer of pixel data into a typed array based on the
+* sample format and bits per sample. This is used for codecs that return raw
+* bytes.
+*/
+function toTypedArray(buffer, metadata) {
+	const { sampleFormat, bitsPerSample } = metadata;
+	switch (sampleFormat) {
+		case SampleFormat.Uint:
+			switch (bitsPerSample) {
+				case 1: return unpackBitPacked(buffer, metadata.width * metadata.height * metadata.samplesPerPixel);
+				case 8: return new Uint8Array(buffer);
+				case 16: return new Uint16Array(buffer);
+				case 32: return new Uint32Array(buffer);
+			}
+			break;
+		case SampleFormat.Int:
+			switch (bitsPerSample) {
+				case 8: return new Int8Array(buffer);
+				case 16: return new Int16Array(buffer);
+				case 32: return new Int32Array(buffer);
+			}
+			break;
+		case SampleFormat.Float:
+			switch (bitsPerSample) {
+				case 32: return new Float32Array(buffer);
+				case 64: return new Float64Array(buffer);
+			}
+			break;
+	}
+	throw new Error(`Unsupported sample format/depth: SampleFormat=${sampleFormat}, BitsPerSample=${bitsPerSample}`);
+}
+//#endregion
+export { Photometric as a, RasterTypeKey as c, TiffTag as d, TiffTagGeo as f, Compression as i, SampleFormat as l, decode as n, PlanarConfiguration as o, Tiff as r, Predictor as s, DECODER_REGISTRY as t, SubFileType as u };
+
+//# sourceMappingURL=decode-BMFOVF9X.js.map