@gisatcz/deckgl-geolib 2.4.0-dev.4 → 2.4.0-dev.5

package/dist/cjs/index.js

@@ -447,30 +447,31 @@ function findTagsByName(xml, tagName, options) {
   return tags;
 }
 
-const fieldTypes = Object.freeze({
-    BYTE: 0x0001,
-    ASCII: 0x0002,
-    SHORT: 0x0003,
-    LONG: 0x0004,
-    RATIONAL: 0x0005,
-    SBYTE: 0x0006,
-    UNDEFINED: 0x0007,
-    SSHORT: 0x0008,
-    SLONG: 0x0009,
-    SRATIONAL: 0x000a,
-    FLOAT: 0x000b,
-    DOUBLE: 0x000c,
+/** @import {TypedArray} from './geotiff.js' */
+const fieldTypes = {
+    BYTE: /** @type {1} */ (0x0001),
+    ASCII: /** @type {2} */ (0x0002),
+    SHORT: /** @type {3} */ (0x0003),
+    LONG: /** @type {4} */ (0x0004),
+    RATIONAL: /** @type {5} */ (0x0005),
+    SBYTE: /** @type {6} */ (0x0006),
+    UNDEFINED: /** @type {7} */ (0x0007),
+    SSHORT: /** @type {8} */ (0x0008),
+    SLONG: /** @type {9} */ (0x0009),
+    SRATIONAL: /** @type {10} */ (0x000a),
+    FLOAT: /** @type {11} */ (0x000b),
+    DOUBLE: /** @type {12} */ (0x000c),
     // IFD offset, suggested by https://owl.phy.queensu.ca/~phil/exiftool/standards.html
-    IFD: 0x000d,
+    IFD: /** @type {13} */ (0x000d),
     // introduced by BigTIFF
-    LONG8: 0x0010,
-    SLONG8: 0x0011,
-    IFD8: 0x0012,
-});
+    LONG8: /** @type {16} */ (0x0010),
+    SLONG8: /** @type {17} */ (0x0011),
+    IFD8: /** @type {18} */ (0x0012),
+};
 /** @typedef {keyof fieldTypes} FieldTypeName */
 /** @typedef {fieldTypes[keyof typeof fieldTypes]} FieldType */
 /** @typedef {Record<FieldTypeName, number>} FieldTypeSizes */
-const fieldTypeSizes = Object.freeze({
+const fieldTypeSizes = /** @type {const} */ ({
     [fieldTypes.BYTE]: 1,
     [fieldTypes.ASCII]: 1,
     [fieldTypes.SBYTE]: 1,
@@ -502,219 +503,196 @@ function getFieldTypeSize(fieldType) {
     }
     return size;
 }
-const tagSource = [
-    { tag: 254, name: 'NewSubfileType', fieldTypes: fieldTypes.LONG },
-    { tag: 255, name: 'SubfileType', type: fieldTypes.SHORT },
-    { tag: 256, name: 'ImageWidth', type: fieldTypes.SHORT },
-    { tag: 257, name: 'ImageLength', type: fieldTypes.SHORT },
-    {
-        tag: 258,
-        name: 'BitsPerSample',
-        type: fieldTypes.SHORT,
-        isArray: true,
-        eager: true,
-    },
-    { tag: 259, name: 'Compression', type: fieldTypes.SHORT },
-    { tag: 262, name: 'PhotometricInterpretation', type: fieldTypes.SHORT },
-    { tag: 263, name: 'Threshholding', type: fieldTypes.SHORT },
-    { tag: 264, name: 'CellWidth', type: fieldTypes.SHORT },
-    { tag: 265, name: 'CellLength', type: fieldTypes.SHORT },
-    { tag: 266, name: 'FillOrder', type: fieldTypes.SHORT },
-    { tag: 269, name: 'DocumentName', type: fieldTypes.ASCII },
-    { tag: 270, name: 'ImageDescription', type: fieldTypes.ASCII },
-    { tag: 271, name: 'Make', type: fieldTypes.ASCII },
-    { tag: 272, name: 'Model', type: fieldTypes.ASCII },
-    { tag: 273, name: 'StripOffsets', type: fieldTypes.SHORT, isArray: true },
-    { tag: 274, name: 'Orientation', type: fieldTypes.SHORT },
-    { tag: 277, name: 'SamplesPerPixel', type: fieldTypes.SHORT },
-    { tag: 278, name: 'RowsPerStrip', type: fieldTypes.SHORT },
-    { tag: 279, name: 'StripByteCounts', type: fieldTypes.LONG, isArray: true },
-    { tag: 280, name: 'MinSampleValue', type: fieldTypes.SHORT, isArray: true },
-    { tag: 281, name: 'MaxSampleValue', type: fieldTypes.SHORT, isArray: true },
-    { tag: 282, name: 'XResolution', type: fieldTypes.RATIONAL },
-    { tag: 283, name: 'YResolution', type: fieldTypes.RATIONAL },
-    { tag: 284, name: 'PlanarConfiguration', fieldTypes: fieldTypes.SHORT },
-    { tag: 285, name: 'PageName', type: fieldTypes.ASCII },
-    { tag: 286, name: 'XPosition', type: fieldTypes.RATIONAL },
-    { tag: 287, name: 'YPosition', type: fieldTypes.RATIONAL },
-    { tag: 288, name: 'FreeOffsets', type: fieldTypes.LONG },
-    { tag: 289, name: 'FreeByteCounts', type: fieldTypes.LONG },
-    { tag: 290, name: 'GrayResponseUnit', type: fieldTypes.SHORT },
-    {
-        tag: 291,
-        name: 'GrayResponseCurve',
-        type: fieldTypes.SHORT,
-        isArray: true,
-    },
-    { tag: 292, name: 'T4Options', type: fieldTypes.LONG },
-    { tag: 293, name: 'T6Options', type: fieldTypes.LONG },
-    { tag: 296, name: 'ResolutionUnit', type: fieldTypes.SHORT },
-    { tag: 297, name: 'PageNumber', type: fieldTypes.SHORT, isArray: true },
-    { tag: 301, name: 'TransferFunction', type: fieldTypes.SHORT, isArray: true },
-    { tag: 305, name: 'Software', type: fieldTypes.ASCII },
-    { tag: 306, name: 'DateTime', type: fieldTypes.ASCII },
-    { tag: 315, name: 'Artist', type: fieldTypes.ASCII },
-    { tag: 316, name: 'HostComputer', type: fieldTypes.ASCII },
-    { tag: 317, name: 'Predictor', type: fieldTypes.SHORT },
-    { tag: 318, name: 'WhitePoint', type: fieldTypes.RATIONAL, isArray: true },
-    {
-        tag: 319,
-        name: 'PrimaryChromaticities',
-        type: fieldTypes.RATIONAL,
-        isArray: true,
-    },
-    { tag: 320, name: 'ColorMap', type: fieldTypes.SHORT, isArray: true },
-    { tag: 321, name: 'HalftoneHints', type: fieldTypes.SHORT, isArray: true },
-    { tag: 322, name: 'TileWidth', type: fieldTypes.SHORT },
-    { tag: 323, name: 'TileLength', type: fieldTypes.SHORT },
-    { tag: 324, name: 'TileOffsets', type: fieldTypes.LONG, isArray: true },
-    { tag: 325, name: 'TileByteCounts', type: fieldTypes.SHORT, isArray: true },
-    { tag: 332, name: 'InkSet', type: fieldTypes.SHORT },
-    { tag: 333, name: 'InkNames', type: fieldTypes.ASCII },
-    { tag: 334, name: 'NumberOfInks', type: fieldTypes.SHORT },
-    { tag: 336, name: 'DotRange', type: fieldTypes.BYTE, isArray: true },
-    { tag: 337, name: 'TargetPrinter', type: fieldTypes.ASCII },
-    { tag: 338, name: 'ExtraSamples', type: fieldTypes.BYTE, isArray: true },
-    {
-        tag: 339,
-        name: 'SampleFormat',
-        type: fieldTypes.SHORT,
-        isArray: true,
-        eager: true,
-    },
-    { tag: 340, name: 'SMinSampleValue', isArray: true },
-    { tag: 341, name: 'SMaxSampleValue', isArray: true },
-    { tag: 342, name: 'TransferRange', type: fieldTypes.SHORT, isArray: true },
-    { tag: 512, name: 'JPEGProc', type: fieldTypes.SHORT },
-    { tag: 513, name: 'JPEGInterchangeFormat', type: fieldTypes.LONG },
-    { tag: 514, name: 'JPEGInterchangeFormatLngth', type: fieldTypes.LONG },
-    { tag: 515, name: 'JPEGRestartInterval', type: fieldTypes.SHORT },
-    {
-        tag: 517,
-        name: 'JPEGLosslessPredictors',
-        type: fieldTypes.SHORT,
-        isArray: true,
-    },
-    {
-        tag: 518,
-        name: 'JPEGPointTransforms',
-        type: fieldTypes.SHORT,
-        isArray: true,
-    },
-    { tag: 519, name: 'JPEGQTables', type: fieldTypes.LONG, isArray: true },
-    { tag: 520, name: 'JPEGDCTables', type: fieldTypes.LONG, isArray: true },
-    { tag: 521, name: 'JPEGACTables', type: fieldTypes.LONG, isArray: true },
-    {
-        tag: 529,
-        name: 'YCbCrCoefficients',
-        type: fieldTypes.RATIONAL,
-        isArray: true,
-    },
-    { tag: 530, name: 'YCbCrSubSampling', type: fieldTypes.SHORT, isArray: true },
-    { tag: 531, name: 'YCbCrPositioning', type: fieldTypes.SHORT },
-    {
-        tag: 532,
-        name: 'ReferenceBlackWhite',
-        type: fieldTypes.LONG,
-        isArray: true,
-    },
-    { tag: 33432, name: 'Copyright', type: fieldTypes.ASCII },
-    // TIFF Extended
-    { tag: 326, name: 'BadFaxLines' },
-    { tag: 327, name: 'CleanFaxData' },
-    { tag: 343, name: 'ClipPath' },
-    { tag: 328, name: 'ConsecutiveBadFaxLines' },
-    { tag: 433, name: 'Decode' },
-    { tag: 434, name: 'DefaultImageColor' },
-    { tag: 346, name: 'Indexed' },
-    { tag: 347, name: 'JPEGTables', isArray: true, eager: true },
-    { tag: 559, name: 'StripRowCounts', isArray: true },
-    { tag: 330, name: 'SubIFDs', isArray: true },
-    { tag: 344, name: 'XClipPathUnits' },
-    { tag: 345, name: 'YClipPathUnits' },
-    // EXIF
-    { tag: 37378, name: 'ApertureValue' },
-    { tag: 40961, name: 'ColorSpace' },
-    { tag: 36868, name: 'DateTimeDigitized' },
-    { tag: 36867, name: 'DateTimeOriginal' },
-    { tag: 34665, name: 'Exif IFD', type: fieldTypes.LONG },
-    { tag: 36864, name: 'ExifVersion' },
-    { tag: 33434, name: 'ExposureTime' },
-    { tag: 41728, name: 'FileSource' },
-    { tag: 37385, name: 'Flash' },
-    { tag: 40960, name: 'FlashpixVersion' },
-    { tag: 33437, name: 'FNumber' },
-    { tag: 42016, name: 'ImageUniqueID' },
-    { tag: 37384, name: 'LightSource' },
-    { tag: 37500, name: 'MakerNote' },
-    { tag: 37377, name: 'ShutterSpeedValue' },
-    { tag: 37510, name: 'UserComment' },
-    // IPTC
-    { tag: 33723, name: 'IPTC' },
-    // Laser Scanning Microscopy
-    { tag: 34412, name: 'CZ_LSMINFO' },
-    // ICC
-    { tag: 34675, name: 'ICC Profile' },
-    // XMP
-    { tag: 700, name: 'XMP' },
-    // GDAL
-    { tag: 42112, name: 'GDAL_METADATA' },
-    { tag: 42113, name: 'GDAL_NODATA', type: fieldTypes.ASCII },
-    // Photoshop
-    { tag: 34377, name: 'Photoshop' },
-    // GeoTiff
-    {
-        tag: 33550,
-        name: 'ModelPixelScale',
-        type: fieldTypes.DOUBLE,
-        isArray: true,
-        eager: true,
-    },
-    {
-        tag: 33922,
-        name: 'ModelTiepoint',
-        type: fieldTypes.DOUBLE,
-        isArray: true,
-        eager: true,
-    },
-    {
-        tag: 34264,
-        name: 'ModelTransformation',
-        type: fieldTypes.DOUBLE,
-        isArray: true,
-        eager: true,
-    },
-    {
-        tag: 34735,
-        name: 'GeoKeyDirectory',
-        type: fieldTypes.SHORT,
-        isArray: true,
-        eager: true,
-    },
-    {
-        tag: 34736,
-        name: 'GeoDoubleParams',
-        type: fieldTypes.DOUBLE,
-        isArray: true,
-        eager: true,
-    },
-    { tag: 34737, name: 'GeoAsciiParams', type: fieldTypes.ASCII, eager: true },
-    // LERC
-    { tag: 50674, name: 'LercParameters', eager: true },
-];
+/**
+ * @typedef {Object} TagDictionaryEntry
+ * @property {number} tag
+ * @property {string} [name]
+ * @property {number} [type]
+ * @property {boolean} [isArray]
+ * @property {boolean} [eager]
+ */
+const tagDictionary = /** @type {const} */ ({
+    NewSubfileType: { tag: 254, type: fieldTypes.LONG, eager: true },
+    SubfileType: { tag: 255, type: fieldTypes.SHORT, eager: true },
+    ImageWidth: { tag: 256, type: fieldTypes.SHORT, eager: true },
+    ImageLength: { tag: 257, type: fieldTypes.SHORT, eager: true },
+    BitsPerSample: { tag: 258, type: fieldTypes.SHORT, isArray: true, eager: true },
+    Compression: { tag: 259, type: fieldTypes.SHORT, eager: true },
+    PhotometricInterpretation: { tag: 262, type: fieldTypes.SHORT, eager: true },
+    Threshholding: { tag: 263, type: fieldTypes.SHORT },
+    CellWidth: { tag: 264, type: fieldTypes.SHORT },
+    CellLength: { tag: 265, type: fieldTypes.SHORT },
+    FillOrder: { tag: 266, type: fieldTypes.SHORT },
+    DocumentName: { tag: 269, type: fieldTypes.ASCII },
+    ImageDescription: { tag: 270, type: fieldTypes.ASCII },
+    Make: { tag: 271, type: fieldTypes.ASCII },
+    Model: { tag: 272, type: fieldTypes.ASCII },
+    StripOffsets: { tag: 273, type: fieldTypes.SHORT, isArray: true },
+    Orientation: { tag: 274, type: fieldTypes.SHORT },
+    SamplesPerPixel: { tag: 277, type: fieldTypes.SHORT, eager: true },
+    RowsPerStrip: { tag: 278, type: fieldTypes.SHORT, eager: true },
+    StripByteCounts: { tag: 279, type: fieldTypes.LONG, isArray: true },
+    MinSampleValue: { tag: 280, type: fieldTypes.SHORT, isArray: true },
+    MaxSampleValue: { tag: 281, type: fieldTypes.SHORT, isArray: true },
+    XResolution: { tag: 282, type: fieldTypes.RATIONAL },
+    YResolution: { tag: 283, type: fieldTypes.RATIONAL },
+    PlanarConfiguration: { tag: 284, type: fieldTypes.SHORT, eager: true },
+    PageName: { tag: 285, type: fieldTypes.ASCII },
+    XPosition: { tag: 286, type: fieldTypes.RATIONAL },
+    YPosition: { tag: 287, type: fieldTypes.RATIONAL },
+    FreeOffsets: { tag: 288, type: fieldTypes.LONG },
+    FreeByteCounts: { tag: 289, type: fieldTypes.LONG },
+    GrayResponseUnit: { tag: 290, type: fieldTypes.SHORT },
+    GrayResponseCurve: { tag: 291, type: fieldTypes.SHORT, isArray: true },
+    T4Options: { tag: 292, type: fieldTypes.LONG },
+    T6Options: { tag: 293, type: fieldTypes.LONG },
+    ResolutionUnit: { tag: 296, type: fieldTypes.SHORT },
+    PageNumber: { tag: 297, type: fieldTypes.SHORT, isArray: true },
+    TransferFunction: { tag: 301, type: fieldTypes.SHORT, isArray: true },
+    Software: { tag: 305, type: fieldTypes.ASCII },
+    DateTime: { tag: 306, type: fieldTypes.ASCII },
+    Artist: { tag: 315, type: fieldTypes.ASCII },
+    HostComputer: { tag: 316, type: fieldTypes.ASCII },
+    Predictor: { tag: 317, type: fieldTypes.SHORT },
+    WhitePoint: { tag: 318, type: fieldTypes.RATIONAL, isArray: true },
+    PrimaryChromaticities: { tag: 319, type: fieldTypes.RATIONAL, isArray: true },
+    ColorMap: { tag: 320, type: fieldTypes.SHORT, isArray: true },
+    HalftoneHints: { tag: 321, type: fieldTypes.SHORT, isArray: true },
+    TileWidth: { tag: 322, type: fieldTypes.SHORT, eager: true },
+    TileLength: { tag: 323, type: fieldTypes.SHORT, eager: true },
+    TileOffsets: { tag: 324, type: fieldTypes.LONG, isArray: true },
+    TileByteCounts: { tag: 325, type: fieldTypes.SHORT, isArray: true },
+    InkSet: { tag: 332, type: fieldTypes.SHORT },
+    InkNames: { tag: 333, type: fieldTypes.ASCII },
+    NumberOfInks: { tag: 334, type: fieldTypes.SHORT },
+    DotRange: { tag: 336, type: fieldTypes.BYTE, isArray: true },
+    TargetPrinter: { tag: 337, type: fieldTypes.ASCII },
+    ExtraSamples: { tag: 338, type: fieldTypes.BYTE, isArray: true, eager: true },
+    SampleFormat: { tag: 339, type: fieldTypes.SHORT, isArray: true, eager: true },
+    SMinSampleValue: { tag: 340, isArray: true },
+    SMaxSampleValue: { tag: 341, isArray: true },
+    TransferRange: { tag: 342, type: fieldTypes.SHORT, isArray: true },
+    JPEGProc: { tag: 512, type: fieldTypes.SHORT },
+    JPEGInterchangeFormat: { tag: 513, type: fieldTypes.LONG },
+    JPEGInterchangeFormatLngth: { tag: 514, type: fieldTypes.LONG },
+    JPEGRestartInterval: { tag: 515, type: fieldTypes.SHORT },
+    JPEGLosslessPredictors: { tag: 517, type: fieldTypes.SHORT, isArray: true },
+    JPEGPointTransforms: { tag: 518, type: fieldTypes.SHORT, isArray: true },
+    JPEGQTables: { tag: 519, type: fieldTypes.LONG, isArray: true },
+    JPEGDCTables: { tag: 520, type: fieldTypes.LONG, isArray: true },
+    JPEGACTables: { tag: 521, type: fieldTypes.LONG, isArray: true },
+    YCbCrCoefficients: { tag: 529, type: fieldTypes.RATIONAL, isArray: true },
+    YCbCrSubSampling: { tag: 530, type: fieldTypes.SHORT, isArray: true },
+    YCbCrPositioning: { tag: 531, type: fieldTypes.SHORT },
+    ReferenceBlackWhite: { tag: 532, type: fieldTypes.LONG, isArray: true },
+    Copyright: { tag: 33432, type: fieldTypes.ASCII },
+    BadFaxLines: { tag: 326 },
+    CleanFaxData: { tag: 327 },
+    ClipPath: { tag: 343 },
+    ConsecutiveBadFaxLines: { tag: 328 },
+    Decode: { tag: 433 },
+    DefaultImageColor: { tag: 434 },
+    Indexed: { tag: 346 },
+    JPEGTables: { tag: 347, isArray: true, eager: true },
+    StripRowCounts: { tag: 559, isArray: true },
+    SubIFDs: { tag: 330, isArray: true },
+    XClipPathUnits: { tag: 344 },
+    YClipPathUnits: { tag: 345 },
+    ApertureValue: { tag: 37378 },
+    ColorSpace: { tag: 40961 },
+    DateTimeDigitized: { tag: 36868 },
+    DateTimeOriginal: { tag: 36867 },
+    ExifIFD: { tag: 34665, name: 'Exif IFD', type: fieldTypes.LONG },
+    ExifVersion: { tag: 36864 },
+    ExposureTime: { tag: 33434 },
+    FileSource: { tag: 41728 },
+    Flash: { tag: 37385 },
+    FlashpixVersion: { tag: 40960 },
+    FNumber: { tag: 33437 },
+    ImageUniqueID: { tag: 42016 },
+    LightSource: { tag: 37384 },
+    MakerNote: { tag: 37500 },
+    ShutterSpeedValue: { tag: 37377 },
+    UserComment: { tag: 37510 },
+    IPTC: { tag: 33723 },
+    CZ_LSMINFO: { tag: 34412 },
+    ICCProfile: { tag: 34675, name: 'ICC Profile' },
+    XMP: { tag: 700 },
+    GDAL_METADATA: { tag: 42112 },
+    GDAL_NODATA: { tag: 42113, type: fieldTypes.ASCII, eager: true },
+    Photoshop: { tag: 34377 },
+    ModelPixelScale: { tag: 33550, type: fieldTypes.DOUBLE, isArray: true, eager: true },
+    ModelTiepoint: { tag: 33922, type: fieldTypes.DOUBLE, isArray: true, eager: true },
+    ModelTransformation: { tag: 34264, type: fieldTypes.DOUBLE, isArray: true, eager: true },
+    GeoKeyDirectory: { tag: 34735, type: fieldTypes.SHORT, isArray: true, eager: true },
+    GeoDoubleParams: { tag: 34736, type: fieldTypes.DOUBLE, isArray: true, eager: true },
+    GeoAsciiParams: { tag: 34737, type: fieldTypes.ASCII, eager: true },
+    LercParameters: { tag: 50674, eager: true },
+});
+/** @typedef {keyof typeof tagDictionary} TagName */
+/** @typedef {typeof tagDictionary[keyof typeof tagDictionary]['tag']} Tag */
+/**
+ * @typedef {Extract<keyof typeof tagDictionary,
+ *   { [K in keyof typeof tagDictionary]: (typeof tagDictionary)[K] extends { eager: true }
+ *   ? K : never }[keyof typeof tagDictionary]>} EagerTagName
+ */
+/**
+ * @typedef {Extract<Tag, { [K in keyof typeof tagDictionary]: (typeof tagDictionary)[K] extends { eager: true }
+ *   ? (typeof tagDictionary)[K]['tag'] : never }[keyof typeof tagDictionary]>} EagerTag
+ */
+/** @typedef {Extract<typeof tagDictionary[keyof typeof tagDictionary], {type: any}>['type']} TagType */
+/**
+ * @template {number} T
+ * @typedef {T extends 2 ? string : number} GeoTiffPrimitive
+ */
+/**
+ * @template {TagName} T
+ * @typedef {typeof tagDictionary[T]} TagDef
+ */
+/**
+ * @typedef {{
+ *   1: number;
+ *   2: string;
+ *   3: number;
+ *   4: number;
+ *   5: number;
+ *   6: number;
+ *   7: ArrayBuffer;
+ *   8: number;
+ *   9: number;
+ *   10: number;
+ *   11: number;
+ *   12: number;
+ *   16: number;
+ *   17: number;
+ *   18: number;
+ * }} FieldTypeMap
+ */
+/**
+ * @template {TagName} T
+ * @typedef {TagDef<T> extends { isArray: true }
+ *   ? (TagDef<T> extends { type: typeof fieldTypes.DOUBLE } ? number[] :
+ *      TagDef<T> extends { type: typeof fieldTypes.ASCII } ? string[] :
+ *      TagDef<T> extends { type: typeof fieldTypes.BYTE | typeof fieldTypes.SBYTE | typeof fieldTypes.UNDEFINED }
+ *        ? Uint8Array | Int8Array :
+ *      (number[] | TypedArray))
+ *   : (TagDef<T> extends { type: keyof FieldTypeMap } ? FieldTypeMap[TagDef<T>['type']] : any)} TagValue
+ */
 /**
  * Maps tag names to their numeric values
+ * @type {Record<string, number>}
  */
 const tags = {};
 /**
  * Maps tag numbers to their definitions
+ * @type {Record<number, { tag: number, name: string, type: string|number|undefined, isArray: boolean, eager: boolean }>}
  */
 const tagDefinitions = {};
 /**
  * Registers a new field tag
  * @param {number} tag the numeric tiff tag
  * @param {string} name the name of the tag that will be reported in the IFD
- * @param {string|number|undefined} type the tags data type
+ * @param {keyof fieldTypes|number|undefined} type the tags data type
  * @param {Boolean} isArray whether the tag is an array
  * @param {boolean} [eager=false] whether to eagerly fetch deferred fields.
  *                                 When false (default), tags are loaded lazily on-demand.
@@ -724,8 +702,9 @@ function registerTag(tag, name, type, isArray = false, eager = false) {
     tags[name] = tag;
     tagDefinitions[tag] = { tag, name, type: typeof type === 'string' ? fieldTypes[type] : type, isArray, eager };
 }
-for (const entry of tagSource) {
-    registerTag(entry.tag, entry.name, entry.type, entry.isArray, entry.eager);
+for (const [key, value] of Object.entries(tagDictionary)) {
+    const entry = /** @type {TagDictionaryEntry} */ (value);
+    registerTag(entry.tag, entry.name || key, entry.type, entry.isArray, entry.eager);
 }
 /**
  * @param {number|string} tagIdentifier The field tag ID or name
@@ -755,7 +734,7 @@ const LercAddCompression = {
     Deflate: 1,
     Zstandard: 2,
 };
-const geoKeyNames = Object.freeze({
+const geoKeyNames = /** @type {const} */ ({
     1024: 'GTModelTypeGeoKey',
     1025: 'GTRasterTypeGeoKey',
     1026: 'GTCitationGeoKey',
@@ -804,15 +783,7 @@ const geoKeyNames = Object.freeze({
     4098: 'VerticalDatumGeoKey',
     4099: 'VerticalUnitsGeoKey',
 });
-/** @typedef {geoKeyNames[keyof typeof geoKeyNames]} GeoKeyName */
-/**
- * @type {Record<GeoKeyName, number>}
- */
-const geoKeys = /** @type {Record<GeoKeyName, number>} */ ({});
-for (const key in geoKeyNames) {
-    if (geoKeyNames.hasOwnProperty(key)) {
-        geoKeys[geoKeyNames[key]] = parseInt(key, 10);
-    }
+for (const [key, name] of Object.entries(geoKeyNames)) {
 }
 
 function fromWhiteIsZero(raster, max) {
@@ -912,39 +883,40 @@ function fromCIELab(cieLabRaster) {
     return rgbRaster;
 }
 
-const registry = new Map();
+/** @import BaseDecoder, {BaseDecoderParameters} from "./basedecoder.js" */
 /**
- * @typedef {Object} DecoderParameters
- * @property {number} tileWidth
- * @property {number} tileHeight
- * @property {number} planarConfiguration
- * @property {number} bitsPerSample
- * @property {number} predictor
+ * @typedef {Object} RegistryEntry
+ * @property {function():Promise<typeof BaseDecoder>} importFn
+ * @property {function(import("../imagefiledirectory.js").ImageFileDirectory):Promise<BaseDecoderParameters>} decoderParameterFn
+ * @property {boolean} preferWorker
  */
+/** @type {Map<number | undefined, RegistryEntry>} */
+const registry = new Map();
 /**
  * Default decoder parameter retrieval function
- * @param {import("../imagefiledirectory").ImageFileDirectory} fileDirectory
- * @returns {Promise<DecoderParameters>}
+ * @param {import("../imagefiledirectory.js").ImageFileDirectory} fileDirectory
+ * @returns {Promise<BaseDecoderParameters>}
  */
 async function defaultDecoderParameterFn(fileDirectory) {
     const isTiled = !fileDirectory.hasTag('StripOffsets');
-    return {
-        tileWidth: isTiled ? await fileDirectory.loadValue('TileWidth') : await fileDirectory.loadValue('ImageWidth'),
-        tileHeight: isTiled ? await fileDirectory.loadValue('TileLength') : (await fileDirectory.loadValue('RowsPerStrip') || await fileDirectory.loadValue('ImageLength')),
+    return /** @type {BaseDecoderParameters} */ ({
+        tileWidth: isTiled
+            ? await fileDirectory.loadValue('TileWidth')
+            : await fileDirectory.loadValue('ImageWidth'),
+        tileHeight: isTiled
+            ? await fileDirectory.loadValue('TileLength')
+            : (await fileDirectory.loadValue('RowsPerStrip')
+                || await fileDirectory.loadValue('ImageLength')),
         planarConfiguration: await fileDirectory.loadValue('PlanarConfiguration'),
         bitsPerSample: await fileDirectory.loadValue('BitsPerSample'),
         predictor: await fileDirectory.loadValue('Predictor') || 1,
-    };
+    });
 }
-/**
- * Either a number or undefined.
- * @typedef {(number|undefined)} NumberOrUndefined
- */
 /**
  * Register a decoder for a specific compression method or a range of compressions
- * @param {(NumberOrUndefined|(NumberOrUndefined[]))} cases ids of the compression methods to register for
- * @param {function():Promise} importFn the function to import the decoder
- * @param {function(import("../imagefiledirectory").ImageFileDirectory):Promise} decoderParameterFn
+ * @param {(number|undefined|(number|undefined)[])} cases ids of the compression methods to register for
+ * @param {function():Promise<typeof BaseDecoder>} importFn the function to import the decoder
+ * @param {function(import("../imagefiledirectory.js").ImageFileDirectory):Promise<BaseDecoderParameters>} decoderParameterFn
  * @param {boolean} preferWorker_ Whether to prefer running the decoder in a worker
  */
 function addDecoder(cases, importFn, decoderParameterFn = defaultDecoderParameterFn, preferWorker_ = true) {
@@ -957,27 +929,27 @@ function addDecoder(cases, importFn, decoderParameterFn = defaultDecoderParamete
 }
 /**
  * Get the required decoder parameters for a specific compression method
- * @param {NumberOrUndefined} compression
+ * @param {number|undefined} compression
  * @param {import('../imagefiledirectory.js').ImageFileDirectory} fileDirectory
  */
 async function getDecoderParameters(compression, fileDirectory) {
     if (!registry.has(compression)) {
         throw new Error(`Unknown compression method identifier: ${compression}`);
     }
-    const { decoderParameterFn } = registry.get(compression);
+    const { decoderParameterFn } = /** @type {RegistryEntry} */ (registry.get(compression));
     return decoderParameterFn(fileDirectory);
 }
 /**
  * Get a decoder for a specific compression and parameters
  * @param {number} compression the compression method identifier
- * @param {DecoderParameters} decoderParameters the parameters for the decoder
+ * @param {BaseDecoderParameters} decoderParameters the parameters for the decoder
  * @returns {Promise<import('./basedecoder.js').default>}
  */
 async function getDecoder(compression, decoderParameters) {
     if (!registry.has(compression)) {
         throw new Error(`Unknown compression method identifier: ${compression}`);
     }
-    const { importFn } = registry.get(compression);
+    const { importFn } = /** @type {RegistryEntry} */ (registry.get(compression));
     const Decoder = await importFn();
     return new Decoder(decoderParameters);
 }
@@ -1004,6 +976,9 @@ const defaultDecoderDefinitions = [
     {
         cases: 7,
         importFn: () => Promise.resolve().then(function () { return jpeg; }).then((m) => m.default),
+        /**
+         * @param {import("../imagefiledirectory.js").ImageFileDirectory} fileDirectory
+         */
         decoderParameterFn: async (fileDirectory) => {
             return {
                 ...await defaultDecoderParameterFn(fileDirectory),
@@ -1030,6 +1005,9 @@ const defaultDecoderDefinitions = [
             return m;
         })
             .then((m) => m.default),
+        /**
+         * @param {import("../imagefiledirectory.js").ImageFileDirectory} fileDirectory
+         */
         decoderParameterFn: async (fileDirectory) => {
             return {
                 ...await defaultDecoderParameterFn(fileDirectory),
@@ -1051,10 +1029,13 @@ const defaultDecoderDefinitions = [
     {
         cases: 50001,
         importFn: () => Promise.resolve().then(function () { return webimage; }).then((m) => m.default),
+        /**
+         * @param {import("../imagefiledirectory.js").ImageFileDirectory} fileDirectory
+         */
         decoderParameterFn: async (fileDirectory) => {
             return {
                 ...await defaultDecoderParameterFn(fileDirectory),
-                samplesPerPixel: await fileDirectory.loadValue('SamplesPerPixel') || 4,
+                samplesPerPixel: Number(await fileDirectory.loadValue('SamplesPerPixel')) || 4,
             };
         },
         preferWorker: false,
@@ -1069,17 +1050,23 @@ for (const decoderDefinition of defaultDecoderDefinitions) {
 /**
  * @module resample
  */
+/**
+ * @param {import("./geotiff.js").TypedArray} array
+ * @param {number} width
+ * @param {number} height
+ * @param {number} [samplesPerPixel=1]
+ */
 function copyNewSize(array, width, height, samplesPerPixel = 1) {
     return new (Object.getPrototypeOf(array).constructor)(width * height * samplesPerPixel);
 }
 /**
  * Resample the input arrays using nearest neighbor value selection.
- * @param {import("./geotiff").TypedArray[]} valueArrays The input arrays to resample
+ * @param {import("./geotiff.js").TypedArray[]} valueArrays The input arrays to resample
  * @param {number} inWidth The width of the input rasters
  * @param {number} inHeight The height of the input rasters
  * @param {number} outWidth The desired width of the output rasters
  * @param {number} outHeight The desired height of the output rasters
- * @returns {import("./geotiff").TypedArray[]} The resampled rasters
+ * @returns {import("./geotiff.js").TypedArray[]} The resampled rasters
  */
 function resampleNearest(valueArrays, inWidth, inHeight, outWidth, outHeight) {
     const relX = inWidth / outWidth;
@@ -1099,17 +1086,22 @@ function resampleNearest(valueArrays, inWidth, inHeight, outWidth, outHeight) {
 }
 // simple linear interpolation, code from:
 // https://en.wikipedia.org/wiki/Linear_interpolation#Programming_language_support
+/**
+ * @param {number} v0
+ * @param {number} v1
+ * @param {number} t
+ */
 function lerp(v0, v1, t) {
     return ((1 - t) * v0) + (t * v1);
 }
 /**
  * Resample the input arrays using bilinear interpolation.
- * @param {import("./geotiff").TypedArray[]} valueArrays The input arrays to resample
+ * @param {import("./geotiff.js").TypedArray[]} valueArrays The input arrays to resample
  * @param {number} inWidth The width of the input rasters
  * @param {number} inHeight The height of the input rasters
  * @param {number} outWidth The desired width of the output rasters
  * @param {number} outHeight The desired height of the output rasters
- * @returns {import("./geotiff").TypedArray[]} The resampled rasters
+ * @returns {import("./geotiff.js").TypedArray[]} The resampled rasters
  */
 function resampleBilinear(valueArrays, inWidth, inHeight, outWidth, outHeight) {
     const relX = inWidth / outWidth;
@@ -1138,13 +1130,13 @@ function resampleBilinear(valueArrays, inWidth, inHeight, outWidth, outHeight) {
 }
 /**
  * Resample the input arrays using the selected resampling method.
- * @param {import("./geotiff").TypedArray[]} valueArrays The input arrays to resample
+ * @param {import("./geotiff.js").TypedArray[]} valueArrays The input arrays to resample
  * @param {number} inWidth The width of the input rasters
  * @param {number} inHeight The height of the input rasters
  * @param {number} outWidth The desired width of the output rasters
  * @param {number} outHeight The desired height of the output rasters
  * @param {string} [method = 'nearest'] The desired resampling method
- * @returns {import("./geotiff").TypedArray[]} The resampled rasters
+ * @returns {import("./geotiff.js").TypedArray[]} The resampled rasters
  */
 function resample(valueArrays, inWidth, inHeight, outWidth, outHeight, method = 'nearest') {
     switch (method.toLowerCase()) {
@@ -1159,14 +1151,14 @@ function resample(valueArrays, inWidth, inHeight, outWidth, outHeight, method =
 }
 /**
  * Resample the pixel interleaved input array using nearest neighbor value selection.
- * @param {import("./geotiff").TypedArray} valueArray The input array to resample
+ * @param {import("./geotiff.js").TypedArray} valueArray The input array to resample
  * @param {number} inWidth The width of the input rasters
  * @param {number} inHeight The height of the input rasters
  * @param {number} outWidth The desired width of the output rasters
  * @param {number} outHeight The desired height of the output rasters
  * @param {number} samples The number of samples per pixel for pixel
  *                         interleaved data
- * @returns {import("./geotiff").TypedArray} The resampled raster
+ * @returns {import("./geotiff.js").TypedArray} The resampled raster
  */
 function resampleNearestInterleaved(valueArray, inWidth, inHeight, outWidth, outHeight, samples) {
     const relX = inWidth / outWidth;
@@ -1186,14 +1178,14 @@ function resampleNearestInterleaved(valueArray, inWidth, inHeight, outWidth, out
 }
 /**
  * Resample the pixel interleaved input array using bilinear interpolation.
- * @param {import("./geotiff").TypedArray} valueArray The input array to resample
+ * @param {import("./geotiff.js").TypedArray} valueArray The input array to resample
  * @param {number} inWidth The width of the input rasters
  * @param {number} inHeight The height of the input rasters
  * @param {number} outWidth The desired width of the output rasters
  * @param {number} outHeight The desired height of the output rasters
  * @param {number} samples The number of samples per pixel for pixel
  *                         interleaved data
- * @returns {import("./geotiff").TypedArray} The resampled raster
+ * @returns {import("./geotiff.js").TypedArray} The resampled raster
  */
 function resampleBilinearInterleaved(valueArray, inWidth, inHeight, outWidth, outHeight, samples) {
     const relX = inWidth / outWidth;
@@ -1222,7 +1214,7 @@ function resampleBilinearInterleaved(valueArray, inWidth, inHeight, outWidth, ou
 }
 /**
  * Resample the pixel interleaved input array using the selected resampling method.
- * @param {import("./geotiff").TypedArray} valueArray The input array to resample
+ * @param {import("./geotiff.js").TypedArray} valueArray The input array to resample
  * @param {number} inWidth The width of the input rasters
  * @param {number} inHeight The height of the input rasters
  * @param {number} outWidth The desired width of the output rasters
@@ -1230,7 +1222,7 @@ function resampleBilinearInterleaved(valueArray, inWidth, inHeight, outWidth, ou
  * @param {number} samples The number of samples per pixel for pixel
  *                                 interleaved data
  * @param {string} [method = 'nearest'] The desired resampling method
- * @returns {import("./geotiff").TypedArray} The resampled rasters
+ * @returns {import("./geotiff.js").TypedArray} The resampled rasters
  */
 function resampleInterleaved(valueArray, inWidth, inHeight, outWidth, outHeight, samples, method = 'nearest') {
     switch (method.toLowerCase()) {
@@ -1245,10 +1237,16 @@ function resampleInterleaved(valueArray, inWidth, inHeight, outWidth, outHeight,
 }
 
 /** @module geotiffimage */
-/** @import {DecoderWorker, TypedArray} from "./geotiff" */
-/** @import {ReadRasterResult} from "./geotiff" */
-/** @import {ReadRastersOptions} from "./geotiff" */
-/** @import {ReadRGBOptions} from "./geotiff" */
+/** @import {DecoderWorker, TypedArray} from "./geotiff.js" */
+/** @import {ReadRasterResult} from "./geotiff.js" */
+/** @import {ReadRastersOptions} from "./geotiff.js" */
+/** @import {ReadRGBOptions} from "./geotiff.js" */
+/**
+ * @param {Array<number>|TypedArray} array
+ * @param {number} start
+ * @param {number} end
+ * @returns {number}
+ */
 function sum(array, start, end) {
     let s = 0;
     for (let i = start; i < end; ++i) {
@@ -1256,42 +1254,64 @@ function sum(array, start, end) {
     }
     return s;
 }
-function arrayForType(format, bitsPerSample, size) {
+/**
+ * @param {1|2|3} format
+ * @param {number} bitsPerSample
+ * @param {number|ArrayBufferLike} sizeOrData
+ * @returns {TypedArray}
+ */
+function arrayForType(format, bitsPerSample, sizeOrData) {
+    let TypedArrayConstructor;
     switch (format) {
         case 1: // unsigned integer data
             if (bitsPerSample <= 8) {
-                return new Uint8Array(size);
+                TypedArrayConstructor = Uint8Array;
             }
             else if (bitsPerSample <= 16) {
-                return new Uint16Array(size);
+                TypedArrayConstructor = Uint16Array;
             }
             else if (bitsPerSample <= 32) {
-                return new Uint32Array(size);
+                TypedArrayConstructor = Uint32Array;
             }
             break;
         case 2: // twos complement signed integer data
             if (bitsPerSample === 8) {
-                return new Int8Array(size);
+                TypedArrayConstructor = Int8Array;
             }
             else if (bitsPerSample === 16) {
-                return new Int16Array(size);
+                TypedArrayConstructor = Int16Array;
             }
             else if (bitsPerSample === 32) {
-                return new Int32Array(size);
+                TypedArrayConstructor = Int32Array;
             }
             break;
         case 3: // floating point data
             switch (bitsPerSample) {
                 case 16:
                 case 32:
-                    return new Float32Array(size);
+                    TypedArrayConstructor = Float32Array;
+                    break;
                 case 64:
-                    return new Float64Array(size);
+                    TypedArrayConstructor = Float64Array;
+                    break;
             }
             break;
     }
+    if (TypedArrayConstructor) {
+        if (typeof sizeOrData === 'number') {
+            return new TypedArrayConstructor(sizeOrData);
+        }
+        else if (sizeOrData instanceof ArrayBuffer) {
+            return new TypedArrayConstructor(sizeOrData);
+        }
+    }
     throw Error('Unsupported data format/bitsPerSample');
 }
+/**
+ * @param {1|2|3} format
+ * @param {number} bitsPerSample
+ * @returns {boolean}
+ */
 function needsNormalization(format, bitsPerSample) {
     if ((format === 1 || format === 2) && bitsPerSample <= 32 && bitsPerSample % 8 === 0) {
         return false;
@@ -1301,6 +1321,16 @@ function needsNormalization(format, bitsPerSample) {
     }
     return true;
 }
+/**
+ * @param {ArrayBufferLike} inBuffer
+ * @param {1|2|3} format
+ * @param {1|2} planarConfiguration
+ * @param {number} samplesPerPixel
+ * @param {number} bitsPerSample
+ * @param {number} tileWidth
+ * @param {number} tileHeight
+ * @returns {ArrayBufferLike}
+ */
 function normalizeArray(inBuffer, format, planarConfiguration, samplesPerPixel, bitsPerSample, tileWidth, tileHeight) {
     // const inByteArray = new Uint8Array(inBuffer);
     const view = new DataView(inBuffer);
@@ -1374,7 +1404,7 @@ function normalizeArray(inBuffer, format, planarConfiguration, samplesPerPixel,
 class GeoTIFFImage {
     /**
      * @constructor
-     * @param {import("./imagefiledirectory").ImageFileDirectory} fileDirectory The parsed file directory
+     * @param {import("./imagefiledirectory.js").ImageFileDirectory} fileDirectory The parsed file directory
      * @param {Boolean} littleEndian Whether the file is encoded in little or big endian
      * @param {Boolean} cache Whether or not decoded tiles shall be cached
      * @param {import('./source/basesource.js').BaseSource} source The datasource to read from
@@ -1382,7 +1412,8 @@ class GeoTIFFImage {
     constructor(fileDirectory, littleEndian, cache, source) {
         this.fileDirectory = fileDirectory;
         this.littleEndian = littleEndian;
-        this.tiles = cache ? {} : null;
+        /** @type {Array<Promise<ArrayBufferLike>>|null} */
+        this.tiles = cache ? [] : null;
         this.isTiled = !fileDirectory.hasTag('StripOffsets');
         const planarConfiguration = fileDirectory.getValue('PlanarConfiguration') ?? 1;
         if (planarConfiguration !== 1 && planarConfiguration !== 2) {
@@ -1394,7 +1425,7 @@ class GeoTIFFImage {
     }
     /**
      * Returns the associated parsed file directory.
-     * @returns {import("./imagefiledirectory").ImageFileDirectory} the parsed file directory
+     * @returns {import("./imagefiledirectory.js").ImageFileDirectory} the parsed file directory
      */
     getFileDirectory() {
         return this.fileDirectory;
@@ -1411,46 +1442,50 @@ class GeoTIFFImage {
      * @returns {Number} the width of the image
      */
     getWidth() {
-        return this.fileDirectory.getValue('ImageWidth');
+        return this.fileDirectory.getValue('ImageWidth') || 0;
     }
     /**
      * Returns the height of the image.
      * @returns {Number} the height of the image
      */
     getHeight() {
-        return this.fileDirectory.getValue('ImageLength');
+        return this.fileDirectory.getValue('ImageLength') || 0;
     }
     /**
      * Returns the number of samples per pixel.
-     * @returns {Number} the number of samples per pixel
+     * @returns {number} the number of samples per pixel
      */
     getSamplesPerPixel() {
-        return this.fileDirectory.hasTag('SamplesPerPixel')
-            ? this.fileDirectory.getValue('SamplesPerPixel') : 1;
+        return this.fileDirectory.getValue('SamplesPerPixel') ?? 1;
     }
     /**
      * Returns the width of each tile.
-     * @returns {Number} the width of each tile
+     * @returns {number} the width of each tile
      */
     getTileWidth() {
-        return this.isTiled ? this.fileDirectory.getValue('TileWidth') : this.getWidth();
+        return this.isTiled ? (this.fileDirectory.getValue('TileWidth') || 0) : this.getWidth();
     }
     /**
      * Returns the height of each tile.
-     * @returns {Number} the height of each tile
+     * @returns {number} the height of each tile
      */
     getTileHeight() {
         if (this.isTiled) {
-            return this.fileDirectory.getValue('TileLength');
+            return this.fileDirectory.getValue('TileLength') || 0;
         }
-        if (this.fileDirectory.hasTag('RowsPerStrip')) {
-            return Math.min(this.fileDirectory.getValue('RowsPerStrip'), this.getHeight());
+        const rowsPerStrip = this.fileDirectory.hasTag('RowsPerStrip') && this.fileDirectory.getValue('RowsPerStrip');
+        if (rowsPerStrip) {
+            return Math.min(rowsPerStrip, this.getHeight());
         }
         return this.getHeight();
     }
     getBlockWidth() {
         return this.getTileWidth();
     }
+    /**
+     * @param {number} y
+     * @returns {number}
+     */
     getBlockHeight(y) {
         if (this.isTiled || (y + 1) * this.getTileHeight() <= this.getHeight()) {
             return this.getTileHeight();
@@ -1467,22 +1502,32 @@ class GeoTIFFImage {
     getBytesPerPixel() {
         let bytes = 0;
         // this is a short list, so we assume this is already loaded
-        for (let i = 0; i < this.fileDirectory.getValue('BitsPerSample').length; ++i) {
+        const bitsPerSample = this.fileDirectory.getValue('BitsPerSample') || [];
+        for (let i = 0; i < bitsPerSample.length; ++i) {
             bytes += this.getSampleByteSize(i);
         }
         return bytes;
     }
+    /**
+     * @param {number} i
+     * @returns {number}
+     */
     getSampleByteSize(i) {
-        const bitsPerSample = this.fileDirectory.getValue('BitsPerSample');
+        const bitsPerSample = this.fileDirectory.getValue('BitsPerSample') || [];
         if (i >= bitsPerSample.length) {
             throw new RangeError(`Sample index ${i} is out of range.`);
         }
         return Math.ceil(bitsPerSample[i] / 8);
     }
+    /**
+     * @param {number} sampleIndex
+     * @returns {(this: DataView, byteOffset: number, littleEndian: boolean) => number}
+     */
     getReaderForSample(sampleIndex) {
-        const format = this.fileDirectory.hasTag('SampleFormat')
-            ? this.fileDirectory.getValue('SampleFormat')[sampleIndex] : 1;
-        const bitsPerSample = this.fileDirectory.getValue('BitsPerSample')[sampleIndex];
+        const sampleFormat = this.fileDirectory.getValue('SampleFormat');
+        const format = sampleFormat
+            ? sampleFormat[sampleIndex] : 1;
+        const bitsPerSample = (this.fileDirectory.getValue('BitsPerSample') || [])[sampleIndex];
         switch (format) {
             case 1: // unsigned integer data
                 if (bitsPerSample <= 8) {
@@ -1522,26 +1567,32 @@ class GeoTIFFImage {
         throw Error('Unsupported data format/bitsPerSample');
     }
     getSampleFormat(sampleIndex = 0) {
-        return this.fileDirectory.hasTag('SampleFormat')
-            ? this.fileDirectory.getValue('SampleFormat')[sampleIndex] : 1;
+        const sampleFormat = this.fileDirectory.getValue('SampleFormat');
+        return sampleFormat ? sampleFormat[sampleIndex] : 1;
     }
     getBitsPerSample(sampleIndex = 0) {
-        return this.fileDirectory.getValue('BitsPerSample')[sampleIndex];
+        const bitsPerSample = this.fileDirectory.getValue('BitsPerSample');
+        return bitsPerSample ? bitsPerSample[sampleIndex] : 0;
     }
-    getArrayForSample(sampleIndex, size) {
-        const format = this.getSampleFormat(sampleIndex);
+    /**
+     * @param {number} sampleIndex
+     * @param {number|ArrayBufferLike} sizeOrData
+     * @returns {TypedArray}
+     */
+    getArrayForSample(sampleIndex, sizeOrData) {
+        const format = /** @type {1|2|3} */ (this.getSampleFormat(sampleIndex));
         const bitsPerSample = this.getBitsPerSample(sampleIndex);
-        return arrayForType(format, bitsPerSample, size);
+        return arrayForType(format, bitsPerSample, sizeOrData);
     }
     /**
      * Returns the decoded strip or tile.
      * @param {Number} x the strip or tile x-offset
      * @param {Number} y the tile y-offset (0 for stripped images)
      * @param {Number} sample the sample to get for separated samples
-     * @param {DecoderWorker|import("./geotiff").BaseDecoder} poolOrDecoder the decoder or decoder pool
+     * @param {DecoderWorker|import("./geotiff.js").BaseDecoder} poolOrDecoder the decoder or decoder pool
      * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
      *                               to be aborted
-     * @returns {Promise.<{x: number, y: number, sample: number, data: ArrayBuffer}>} the decoded strip or tile
+     * @returns {Promise.<{x: number, y: number, sample: number, data: ArrayBufferLike}>} the decoded strip or tile
      */
     async getTileOrStrip(x, y, sample, poolOrDecoder, signal) {
         const numTilesPerRow = Math.ceil(this.getWidth() / this.getTileWidth());
@@ -1560,12 +1611,12 @@ class GeoTIFFImage {
         let offset;
         let byteCount;
         if (this.isTiled) {
-            offset = await this.fileDirectory.loadValueIndexed('TileOffsets', index);
-            byteCount = await this.fileDirectory.loadValueIndexed('TileByteCounts', index);
+            offset = Number(await this.fileDirectory.loadValueIndexed('TileOffsets', index));
+            byteCount = Number(await this.fileDirectory.loadValueIndexed('TileByteCounts', index));
         }
         else {
-            offset = await this.fileDirectory.loadValueIndexed('StripOffsets', index);
-            byteCount = await this.fileDirectory.loadValueIndexed('StripByteCounts', index);
+            offset = Number(await this.fileDirectory.loadValueIndexed('StripOffsets', index));
+            byteCount = Number(await this.fileDirectory.loadValueIndexed('StripByteCounts', index));
         }
         if (byteCount === 0) {
             const nPixels = this.getBlockHeight(y) * this.getTileWidth();
@@ -1581,7 +1632,7 @@ class GeoTIFFImage {
             // resolve each request by potentially applying array normalization
             request = (async () => {
                 let data = await poolOrDecoder.decode(slice);
-                const sampleFormat = this.getSampleFormat();
+                const sampleFormat = /** @type {1|2|3} */ (this.getSampleFormat());
                 const bitsPerSample = this.getBitsPerSample();
                 if (needsNormalization(sampleFormat, bitsPerSample)) {
                     data = normalizeArray(data, sampleFormat, this.planarConfiguration, this.getSamplesPerPixel(), bitsPerSample, this.getTileWidth(), this.getBlockHeight(y));
@@ -1603,11 +1654,11 @@ class GeoTIFFImage {
     /**
      * Internal read function.
      * @private
-     * @param {Array} imageWindow The image window in pixel coordinates
-     * @param {Array} samples The selected samples (0-based indices)
+     * @param {Array<number>} imageWindow The image window in pixel coordinates
+     * @param {Array<number>} samples The selected samples (0-based indices)
      * @param {TypedArray|TypedArray[]} valueArrays The array(s) to write into
      * @param {boolean|undefined} interleave Whether or not to write in an interleaved manner
-     * @param {DecoderWorker|import("./geotiff").BaseDecoder} poolOrDecoder the decoder or decoder pool
+     * @param {DecoderWorker|import("./geotiff.js").BaseDecoder} poolOrDecoder the decoder or decoder pool
      * @param {number} [width] the width of window to be read into
      * @param {number} [height] the height of window to be read into
      * @param {string} [resampleMethod] the resampling method to be used when interpolating
@@ -1626,11 +1677,17 @@ class GeoTIFFImage {
         const maxYTile = Math.min(Math.ceil(imageWindow[3] / tileHeight), Math.ceil(imageHeight / tileHeight));
         const windowWidth = imageWindow[2] - imageWindow[0];
         let bytesPerPixel = this.getBytesPerPixel();
+        /** @type {Array<number>} */
         const srcSampleOffsets = [];
+        /** @type {Array<(this: DataView, byteOffset: number, littleEndian: boolean) => number>} */
         const sampleReaders = [];
         for (let i = 0; i < samples.length; ++i) {
             if (this.planarConfiguration === 1) {
-                srcSampleOffsets.push(sum(await this.fileDirectory.loadValue('BitsPerSample'), 0, samples[i]) / 8);
+                const bitsPerSample = await this.fileDirectory.loadValue('BitsPerSample');
+                if (typeof bitsPerSample !== 'object') {
+                    throw new Error('Expected BitsPerSample to be an array or typed array.');
+                }
+                srcSampleOffsets.push(sum(bitsPerSample, 0, samples[i]) / 8);
             }
             else {
                 srcSampleOffsets.push(0);
@@ -1679,7 +1736,7 @@ class GeoTIFFImage {
                                 }
                                 else {
                                     windowCoordinate = ((y + firstLine - imageWindow[1]) * windowWidth) + x + firstCol - imageWindow[0];
-                                    valueArrays[si][windowCoordinate] = value;
+                                    /** @type {TypedArray} */ (valueArrays[si])[windowCoordinate] = value;
                                 }
                             }
                         }
@@ -1715,12 +1772,12 @@ class GeoTIFFImage {
     /**
      * @overload
      * @param {ReadRastersOptions & {interleave: true}} options optional parameters
-     * @returns {Promise<import("./geotiff").TypedArrayWithDimensions>} the decoded arrays as a promise
+     * @returns {Promise<import("./geotiff.js").TypedArrayWithDimensions>} the decoded arrays as a promise
      */
     /**
      * @overload
      * @param {ReadRastersOptions & {interleave: false}} options optional parameters
-     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
+     * @returns {Promise<import("./geotiff.js").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
      */
     /**
      * @overload
@@ -1730,7 +1787,7 @@ class GeoTIFFImage {
     /**
      * @overload
      * @param {ReadRastersOptions} [options={}] optional parameters
-     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
+     * @returns {Promise<import("./geotiff.js").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
      */
     /**
      * Reads raster data from the image. This function reads all selected samples
@@ -1768,9 +1825,16 @@ class GeoTIFFImage {
         /** @type {TypedArray|TypedArray[]} */
         let valueArrays;
         if (interleave) {
-            const format = this.fileDirectory.hasTag('SampleFormat')
-                ? Math.max.apply(null, this.fileDirectory.getValue('SampleFormat')) : 1;
-            const bitsPerSample = Math.max.apply(null, this.fileDirectory.getValue('BitsPerSample'));
+            const { fileDirectory } = this;
+            const sampleFormat = fileDirectory.getValue('SampleFormat');
+            const format = sampleFormat
+                ? Math.max.apply(null, Array.from(sampleFormat)) : 1;
+            if (format !== 1 && format !== 2 && format !== 3) {
+                throw new Error('Unsupported sample format for interleaved data. Must be 1, 2, or 3.');
+            }
+            const bitsPerSample_ = fileDirectory.getValue('BitsPerSample');
+            const bitsPerSample = bitsPerSample_
+                ? Math.max.apply(null, Array.from(bitsPerSample_)) : 8;
             valueArrays = arrayForType(format, bitsPerSample, numPixels * samples.length);
             if (fillValue) {
                 if (Array.isArray(fillValue)) {
@@ -1803,12 +1867,12 @@ class GeoTIFFImage {
     /**
      * @overload
      * @param {ReadRGBOptions & {interleave: true}} options optional parameters
-     * @returns {Promise<import("./geotiff").TypedArrayWithDimensions>} the RGB array as a Promise
+     * @returns {Promise<import("./geotiff.js").TypedArrayWithDimensions>} the RGB array as a Promise
      */
     /**
      * @overload
      * @param {ReadRGBOptions & {interleave: false}} options optional parameters
-     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the RGB array as a Promise
+     * @returns {Promise<import("./geotiff.js").TypedArrayArrayWithDimensions>} the RGB array as a Promise
      */
     /**
      * @overload
@@ -1818,7 +1882,7 @@ class GeoTIFFImage {
     /**
      * @overload
      * @param {ReadRGBOptions} [options={}] optional parameters
-     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the RGB array as a Promise
+     * @returns {Promise<import("./geotiff.js").TypedArrayArrayWithDimensions>} the RGB array as a Promise
      */
     /**
      * Reads raster data from the image as RGB.
@@ -1841,9 +1905,11 @@ class GeoTIFFImage {
         const pi = this.fileDirectory.getValue('PhotometricInterpretation');
         if (pi === photometricInterpretations.RGB) {
             let s = [0, 1, 2];
-            if ((!(this.fileDirectory.getValue('ExtraSamples') === ExtraSamplesValues.Unspecified)) && enableAlpha) {
+            const extraSamples = this.fileDirectory.getValue('ExtraSamples');
+            if (extraSamples && extraSamples[0] !== ExtraSamplesValues.Unspecified && enableAlpha) {
                 s = [];
-                for (let i = 0; i < this.fileDirectory.getValue('BitsPerSample').length; i += 1) {
+                const bitsPerSample = this.fileDirectory.getValue('BitsPerSample') || [];
+                for (let i = 0; i < bitsPerSample.length; i += 1) {
                     s.push(i);
                 }
             }
@@ -1898,7 +1964,7 @@ class GeoTIFFImage {
                 data = fromBlackIsZero(raster, max);
                 break;
             case photometricInterpretations.Palette:
-                data = fromPalette(raster, await fileDirectory.loadValue('ColorMap'));
+                data = fromPalette(raster, /** @type {Uint16Array} */ (await fileDirectory.loadValue('ColorMap')));
                 break;
             case photometricInterpretations.CMYK:
                 data = fromCMYK(raster);
@@ -1925,20 +1991,23 @@ class GeoTIFFImage {
             }
             data = [red, green, blue];
         }
-        const dataWithDimensions = /** @type {import("./geotiff").ReadRasterResult} */ (data);
+        const dataWithDimensions = /** @type {import("./geotiff.js").ReadRasterResult} */ (data);
         dataWithDimensions.width = raster.width;
         dataWithDimensions.height = raster.height;
         return dataWithDimensions;
     }
     /**
      * Returns an array of tiepoints.
-     * @returns {Promise<Object[]>}
+     * @returns {Promise<Array<{i: number, j: number, k: number, x: number, y: number, z: number}>>} the tiepoints
      */
     async getTiePoints() {
         if (!this.fileDirectory.hasTag('ModelTiepoint')) {
             return [];
         }
         const modelTiePoint = await this.fileDirectory.loadValue('ModelTiepoint');
+        if (typeof modelTiePoint !== 'object') {
+            throw new Error('Expected ModelTiepoint to be an array or typed array.');
+        }
         const tiePoints = [];
         for (let i = 0; i < modelTiePoint.length; i += 6) {
             tiePoints.push({
@@ -1959,14 +2028,16 @@ class GeoTIFFImage {
      * Otherwise only metadata specific to the provided sample will be returned.
      *
      * @param {number|null} [sample=null] The sample index.
-     * @returns {Promise<Object>}
+     * @returns {Promise<Record<string, unknown>|null>} The GDAL metadata items
      */
     async getGDALMetadata(sample = null) {
+        /** @type {Record<string, unknown>} */
         const metadata = {};
         if (!this.fileDirectory.hasTag('GDAL_METADATA')) {
             return null;
         }
         const string = await this.fileDirectory.loadValue('GDAL_METADATA');
+        /** @type {Array<{inner: unknown}>} */
         let items = findTagsByName(string, 'Item');
         if (sample === null) {
             items = items.filter((item) => getAttribute(item, 'sample') === undefined);
@@ -1985,10 +2056,10 @@ class GeoTIFFImage {
      * @returns {number|null}
      */
     getGDALNoData() {
-        if (!this.fileDirectory.hasTag('GDAL_NODATA')) {
+        const string = this.fileDirectory.hasTag('GDAL_NODATA') && this.fileDirectory.getValue('GDAL_NODATA');
+        if (!string) {
             return null;
         }
-        const string = this.fileDirectory.getValue('GDAL_NODATA');
         return Number(string.substring(0, string.length - 1));
     }
     /**
@@ -2077,9 +2148,9 @@ class GeoTIFFImage {
     getBoundingBox(tilegrid = false) {
         const height = this.getHeight();
         const width = this.getWidth();
-        if (this.fileDirectory.hasTag('ModelTransformation') && !tilegrid) {
-            // eslint-disable-next-line no-unused-vars
-            const [a, b, c, d, e, f, g, h] = this.fileDirectory.getValue('ModelTransformation');
+        const modelTransformation = this.fileDirectory.getValue('ModelTransformation');
+        if (modelTransformation && !tilegrid) {
+            const [a, b, , d, e, f, , h] = modelTransformation;
             const corners = [
                 [0, 0],
                 [0, height],
@@ -2117,12 +2188,20 @@ class GeoTIFFImage {
 }
 
 class DataView64 {
+    /**
+     * @param {ArrayBufferLike} arrayBuffer
+     */
     constructor(arrayBuffer) {
         this._dataView = new DataView(arrayBuffer);
     }
     get buffer() {
         return this._dataView.buffer;
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getUint64(offset, littleEndian) {
         const left = this.getUint32(offset, littleEndian);
         const right = this.getUint32(offset + 4, littleEndian);
@@ -2142,7 +2221,12 @@ class DataView64 {
         }
         return combined;
     }
-    // adapted from https://stackoverflow.com/a/55338384/8060591
+    /**
+     * Adapted from https://stackoverflow.com/a/55338384/8060591
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getInt64(offset, littleEndian) {
         let value = 0;
         const isNegative = (this._dataView.getUint8(offset + (littleEndian ? 7 : 0)) & 0x80) > 0;
@@ -2167,36 +2251,85 @@ class DataView64 {
         }
         return value;
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     getUint8(offset) {
         return this._dataView.getUint8(offset);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     getInt8(offset) {
         return this._dataView.getInt8(offset);
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getUint16(offset, littleEndian) {
         return this._dataView.getUint16(offset, littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getInt16(offset, littleEndian) {
         return this._dataView.getInt16(offset, littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getUint32(offset, littleEndian) {
         return this._dataView.getUint32(offset, littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getInt32(offset, littleEndian) {
         return this._dataView.getInt32(offset, littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getFloat16(offset, littleEndian) {
         return getFloat16(this._dataView, offset, littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getFloat32(offset, littleEndian) {
         return this._dataView.getFloat32(offset, littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @param {boolean} littleEndian
+     * @returns {number}
+     */
     getFloat64(offset, littleEndian) {
         return this._dataView.getFloat64(offset, littleEndian);
     }
 }
 
 class DataSlice {
+    /**
+     * @param {ArrayBufferLike} arrayBuffer
+     * @param {number} sliceOffset
+     * @param {boolean} littleEndian
+     * @param {boolean} bigTiff
+     */
     constructor(arrayBuffer, sliceOffset, littleEndian, bigTiff) {
         this._dataView = new DataView(arrayBuffer);
         this._sliceOffset = sliceOffset;
@@ -2218,33 +2351,74 @@ class DataSlice {
     get buffer() {
         return this._dataView.buffer;
     }
+    /**
+     * @param {number} offset
+     * @param {number} length
+     * @returns {boolean}
+     */
     covers(offset, length) {
         return this.sliceOffset <= offset && this.sliceTop >= offset + length;
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readUint8(offset) {
         return this._dataView.getUint8(offset - this._sliceOffset);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readInt8(offset) {
         return this._dataView.getInt8(offset - this._sliceOffset);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readUint16(offset) {
         return this._dataView.getUint16(offset - this._sliceOffset, this._littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readInt16(offset) {
         return this._dataView.getInt16(offset - this._sliceOffset, this._littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readUint32(offset) {
         return this._dataView.getUint32(offset - this._sliceOffset, this._littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readInt32(offset) {
         return this._dataView.getInt32(offset - this._sliceOffset, this._littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readFloat32(offset) {
         return this._dataView.getFloat32(offset - this._sliceOffset, this._littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readFloat64(offset) {
         return this._dataView.getFloat64(offset - this._sliceOffset, this._littleEndian);
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readUint64(offset) {
         const left = this.readUint32(offset);
         const right = this.readUint32(offset + 4);
@@ -2264,7 +2438,11 @@ class DataSlice {
         }
         return combined;
     }
-    // adapted from https://stackoverflow.com/a/55338384/8060591
+    /**
+     * Adapted from https://stackoverflow.com/a/55338384/8060591
+     * @param {number} offset
+     * @returns {number}
+     */
     readInt64(offset) {
         let value = 0;
         const isNegative = (this._dataView.getUint8(offset + (this._littleEndian ? 7 : 0)) & 0x80)
@@ -2290,6 +2468,10 @@ class DataSlice {
         }
         return value;
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readOffset(offset) {
         if (this._bigTiff) {
             return this.readUint64(offset);
@@ -2299,13 +2481,17 @@ class DataSlice {
 }
 
 const CRLFCRLF = '\r\n\r\n';
-/*
+/**
  * Shim for 'Object.fromEntries'
+ * @template T
+ * @param {Array<[string, T]>} items
+ * @return {Record<string, T>}
  */
 function itemsToObject(items) {
     if (typeof Object.fromEntries !== 'undefined') {
         return Object.fromEntries(items);
     }
+    /** @type {Record<string, T>} */
     const obj = {};
     for (const [key, value] of items) {
         obj[key.toLowerCase()] = value;
@@ -2314,14 +2500,15 @@ function itemsToObject(items) {
 }
 /**
  * Parse HTTP headers from a given string.
- * @param {String} text the text to parse the headers from
- * @returns {Object} the parsed headers with lowercase keys
+ * @param {string} text the text to parse the headers from
+ * @returns {Record<string, string>} the parsed headers with lowercase keys
  */
 function parseHeaders(text) {
+    /** @type {Array<[string, string]>} */
     const items = text
         .split('\r\n')
         .map((line) => {
-        const kv = line.split(':').map((str) => str.trim());
+        const kv = /** @type {[string, string]} */ (line.split(':').map((str) => str.trim()));
         kv[0] = kv[0].toLowerCase();
         return kv;
     });
@@ -2329,8 +2516,8 @@ function parseHeaders(text) {
 }
 /**
  * Parse a 'Content-Type' header value to the content-type and parameters
- * @param {string|null} rawContentType the raw string to parse from
- * @returns {{type: string|null, params: Object}}}
+ * @param {string|undefined} rawContentType the raw string to parse from
+ * @returns {{type: string|null, params: Record<string, string>}}
  *     the parsed content type with the fields: type and params
  */
 function parseContentType(rawContentType) {
@@ -2338,12 +2525,12 @@ function parseContentType(rawContentType) {
         return { type: null, params: {} };
     }
     const [type, ...rawParams] = rawContentType.split(';').map((s) => s.trim());
-    const paramsItems = rawParams.map((param) => param.split('='));
+    const paramsItems = /** @type {Array<[string, string]>} */ (rawParams.map((param) => param.split('=')));
     return { type, params: itemsToObject(paramsItems) };
 }
 /**
  * Parse a 'Content-Range' header value to its start, end, and total parts
- * @param {string|null} rawContentRange the raw string to parse from
+ * @param {string|undefined} rawContentRange the raw string to parse from
  * @returns {{start: number, end: number, total: number}} the parsed parts
  */
 function parseContentRange(rawContentRange) {
@@ -2363,11 +2550,12 @@ function parseContentRange(rawContentRange) {
  * - offset: the offset of the byterange within its originating file
  * - length: the length of the byterange
  * @param {ArrayBuffer} responseArrayBuffer the response to be parsed and split
- * @param {String} boundary the boundary string used to split the sections
- * @returns {Object[]} the parsed byteranges
+ * @param {string} boundary the boundary string used to split the sections
+ * @returns {Array<{headers: Record<string, string>, data: ArrayBuffer, offset: number, length: number, fileSize: number}>}
+ *     the parsed byteranges
  */
 function parseByteRanges(responseArrayBuffer, boundary) {
-    let offset = null;
+    let offset = -1;
     const decoder = new TextDecoder('ascii');
     const out = [];
     const startBoundary = `--${boundary}`;
@@ -2380,7 +2568,7 @@ function parseByteRanges(responseArrayBuffer, boundary) {
             offset = i;
         }
     }
-    if (offset === null) {
+    if (offset === -1) {
         throw new Error('Could not find initial boundary');
     }
     while (offset < responseArrayBuffer.byteLength) {
@@ -2419,29 +2607,31 @@ function parseByteRanges(responseArrayBuffer, boundary) {
 }
 
 /**
- * @typedef Slice
+ * @typedef {Object} Slice
  * @property {number} offset
  * @property {number} length
  */
+/** @typedef {Slice & {data: ArrayBufferLike}} SliceWithData */
 class BaseSource {
     /**
      * @param {Array<Slice>} slices
      * @param {AbortSignal} [signal]
-     * @returns {Promise<*[]>}
+     * @returns {Promise<ArrayBufferLike[]>}
      */
     async fetch(slices, signal) {
-        return Promise.all(slices.map((slice) => this.fetchSlice(slice, signal)));
+        return Promise.all(slices.map(async (slice) => (await this.fetchSlice(slice, signal)).data));
     }
     /**
      * @param {Slice} slice
      * @param {AbortSignal} [_signal]
-     * @returns {Promise<*>}
+     * @returns {Promise<SliceWithData>}
      */
     async fetchSlice(slice, _signal) {
         throw new Error(`fetching of slice ${slice} not possible, not implemented`);
     }
     /**
      * Returns the filesize if already determined and null otherwise
+     * @returns {number|null}
      */
     get fileSize() {
         return null;
@@ -2735,18 +2925,14 @@ class QuickLRU extends Map {
 	}
 }
 
-/*
+/**
  * Promisified wrapper around 'setTimeout' to allow 'await'
+ * @param {number} [milliseconds]
+ * @returns {Promise<void>}
  */
 async function wait(milliseconds) {
     return new Promise((resolve) => setTimeout(resolve, milliseconds));
 }
-/**
- * @template T,U
- * @param {Iterable<T>} a
- * @param {Iterable<U>} b
- * @returns {Array<[T, U]>}
- */
 function zip(a, b) {
     const A = Array.isArray(a) ? a : Array.from(a);
     const B = Array.isArray(b) ? b : Array.from(b);
@@ -2754,14 +2940,15 @@ function zip(a, b) {
 }
 // Based on https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
 class AbortError extends Error {
-    constructor(params) {
+    constructor(...args) {
         // Pass remaining arguments (including vendor specific ones) to parent constructor
-        super(params);
+        super(...args);
         // Maintains proper stack trace for where our error was thrown (only available on V8)
         if (Error.captureStackTrace) {
             Error.captureStackTrace(this, AbortError);
         }
         this.name = 'AbortError';
+        this.signal = undefined;
     }
 }
 class CustomAggregateError extends Error {
@@ -2836,7 +3023,7 @@ class BlockedSource extends BaseSource {
         return this.source.fileSize;
     }
     /**
-     * @param {import("./basesource").Slice[]} slices
+     * @param {import("./basesource.js").Slice[]} slices
      * @param {AbortSignal} [signal]
      * @return {Promise<ArrayBuffer[]>}
      */
@@ -2918,24 +3105,25 @@ class BlockedSource extends BaseSource {
         if (this.blockIdsToFetch.size > 0) {
             const groups = this.groupBlocks(this.blockIdsToFetch);
             // start requesting slices of data
-            const groupRequests = this.source.fetch(groups, signal);
+            const groupRequests = groups.map(async (group) => ({ ...group, ...(await this.source.fetchSlice(group, signal)) }));
             for (let groupIndex = 0; groupIndex < groups.length; ++groupIndex) {
                 const group = groups[groupIndex];
                 for (const blockId of group.blockIds) {
                     // make an async IIFE for each block
                     this.blockRequests.set(blockId, (async () => {
                         try {
-                            const response = (await groupRequests)[groupIndex];
+                            const response = (await Promise.all(groupRequests))[groupIndex];
                             const blockOffset = blockId * this.blockSize;
                             const o = blockOffset - response.offset;
                             const t = Math.min(o + this.blockSize, response.data.byteLength);
                             const data = response.data.slice(o, t);
-                            const block = new Block(blockOffset, data.byteLength, data);
+                            const block = new Block(blockOffset, data.byteLength, 
+                            /** @type {ArrayBuffer} */ (data));
                             this.blockCache.set(blockId, block);
                             this.abortedBlockIds.delete(blockId);
                         }
                         catch (err) {
-                            if (err.name === 'AbortError') {
+                            if (err instanceof AbortError && err.name === 'AbortError') {
                                 // store the signal here, we need it to determine later if an
                                 // error was caused by this signal
                                 err.signal = signal;
@@ -2957,7 +3145,7 @@ class BlockedSource extends BaseSource {
     }
     /**
      *
-     * @param {Set} blockIds
+     * @param {Set<number>} blockIds
      * @returns {BlockGroup[]}
      */
     groupBlocks(blockIds) {
@@ -2965,6 +3153,7 @@ class BlockedSource extends BaseSource {
         if (sortedBlockIds.length === 0) {
             return [];
         }
+        /** @type {number[]} */
         let current = [];
         let lastBlockId = null;
         const groups = [];
@@ -2983,7 +3172,7 @@ class BlockedSource extends BaseSource {
         return groups;
     }
     /**
-     * @param {import("./basesource").Slice[]} slices
+     * @param {import("./basesource.js").Slice[]} slices
      * @param {Map<number, Block>} blocks
      * @returns {ArrayBuffer[]}
      */
@@ -3043,10 +3232,10 @@ class BaseResponse {
     }
     /**
      * Returns the value of the specified header
-     * @param {string} headerName the header name
-     * @returns {string|null} the header value
+     * @param {string} _headerName the header name
+     * @returns {string|undefined} the header value
      */
-    getHeader(headerName) {
+    getHeader(_headerName) {
         throw new Error('not implemented');
     }
     /**
@@ -3057,15 +3246,16 @@ class BaseResponse {
     }
 }
 class BaseClient {
+    /** @param {string} url */
     constructor(url) {
         this.url = url;
     }
     /**
      * Send a request with the options
-     * @param {RequestInit} [options={}]
+     * @param {RequestInit} [_options={}]
      * @returns {Promise<BaseResponse>}
      */
-    async request({ headers, signal } = {}) {
+    async request(_options) {
         throw new Error('request is not implemented');
     }
 }
@@ -3084,10 +3274,10 @@ class FetchResponse extends BaseResponse {
     }
     /**
      * @param {string} name
-     * @returns {string|null}
+     * @returns {string|undefined}
      */
     getHeader(name) {
-        return this.response.headers.get(name);
+        return this.response.headers.get(name) || undefined;
     }
     async getData() {
         const data = this.response.arrayBuffer
@@ -3098,6 +3288,10 @@ class FetchResponse extends BaseResponse {
     }
 }
 class FetchClient extends BaseClient {
+    /**
+     * @param {string} url
+     * @param {RequestCredentials} [credentials]
+     */
     constructor(url, credentials) {
         super(url);
         this.credentials = credentials;
@@ -3128,14 +3322,23 @@ class XHRResponse extends BaseResponse {
     get status() {
         return this.xhr.status;
     }
+    /**
+     * @param {string} name
+     * @returns {string|undefined}
+     */
     getHeader(name) {
-        return this.xhr.getResponseHeader(name);
+        return this.xhr.getResponseHeader(name) || undefined;
     }
     async getData() {
         return this.data;
     }
 }
 class XHRClient extends BaseClient {
+    /**
+     * @param {Object<string, string>} headers
+     * @param {AbortSignal} [signal]
+     * @returns {Promise<XHRResponse>}
+     */
     constructRequest(headers, signal) {
         return new Promise((resolve, reject) => {
             const xhr = new XMLHttpRequest();
@@ -3160,7 +3363,7 @@ class XHRClient extends BaseClient {
             }
         });
     }
-    async request({ headers = undefined, signal = undefined } = {}) {
+    async request({ headers = {}, signal = undefined } = {}) {
         const response = await this.constructRequest(headers, signal);
         return response;
     }
@@ -3172,6 +3375,7 @@ class HttpResponse extends BaseResponse {
     /**
      * BaseResponse facade for node HTTP/HTTPS API Response
      * @param {import('http').IncomingMessage} response
+     * @param {Promise<ArrayBuffer>} dataPromise
      */
     constructor(response, dataPromise) {
         super();
@@ -3181,8 +3385,13 @@ class HttpResponse extends BaseResponse {
     get status() {
         return /** @type {number} */ (this.response.statusCode);
     }
+    /**
+     * @param {string} name
+     * @returns {string|undefined}
+     */
     getHeader(name) {
-        return /** @type {string|null} */ (this.response.headers[name]);
+        const value = this.response.headers[name];
+        return Array.isArray(value) ? value.join(', ') : value;
     }
     async getData() {
         const data = await this.dataPromise;
@@ -3190,11 +3399,17 @@ class HttpResponse extends BaseResponse {
     }
 }
 class HttpClient extends BaseClient {
+    /** @param {string} url */
     constructor(url) {
         super(url);
         this.parsedUrl = fs.parse(this.url);
         this.httpApi = (this.parsedUrl.protocol === 'http:' ? fs : fs);
     }
+    /**
+     * @param {Object<string, string>} headers
+     * @param {AbortSignal} [signal]
+     * @returns {Promise<HttpResponse>}
+     */
     constructRequest(headers, signal) {
         return new Promise((resolve, reject) => {
             const request = this.httpApi.get({
@@ -3202,6 +3417,7 @@ class HttpClient extends BaseClient {
                 headers,
             }, (response) => {
                 const dataPromise = new Promise((resolveData) => {
+                    /** @type {Uint8Array[]} */
                     const chunks = [];
                     // collect chunks
                     response.on('data', (chunk) => {
@@ -3225,7 +3441,7 @@ class HttpClient extends BaseClient {
             }
         });
     }
-    async request({ headers = undefined, signal = undefined } = {}) {
+    async request({ headers = {}, signal = undefined } = {}) {
         const response = await this.constructRequest(headers, signal);
         return response;
     }
@@ -3234,7 +3450,7 @@ class HttpClient extends BaseClient {
 /** @import { RemoteSourceOptions, BlockedSourceOptions } from '../geotiff.js' */
 class RemoteSource extends BaseSource {
     /**
-     * @param {import("../geotiff").BaseClient} client
+     * @param {import("../geotiff.js").BaseClient} client
      * @param {RemoteSourceOptions} options
      */
     constructor(client, { headers, maxRanges = 0, allowFullFile } = {}) {
@@ -3248,24 +3464,29 @@ class RemoteSource extends BaseSource {
     /**
      * @param {import('./basesource.js').Slice[]} slices
      * @param {AbortSignal} [signal]
-     * @returns {Promise<*[]>}
+     * @returns {Promise<ArrayBufferLike[]>}
      */
     async fetch(slices, signal) {
         // if we allow multi-ranges, split the incoming request into that many sub-requests
         // and join them afterwards
         if (this.maxRanges >= slices.length) {
-            return this.fetchSlices(slices, signal);
+            return this.fetchSlices(slices, signal).then((results) => results.map((r) => r.data));
         }
         else if (this.maxRanges > 0 && slices.length > 1) ;
         // otherwise make a single request for each slice
-        return Promise.all(slices.map((slice) => this.fetchSlice(slice, signal)));
+        return Promise.all(slices.map(async (slice) => (await this.fetchSlice(slice, signal)).data));
     }
+    /**
+     * @param {Array<import('./basesource.js').Slice>} slices
+     * @param {AbortSignal} [signal]
+     * @returns {Promise<Array<import('./basesource.js').SliceWithData>>}
+     */
     async fetchSlices(slices, signal) {
         const response = await this.client.request({
             headers: {
                 ...this.headers,
                 Range: `bytes=${slices
-                    .map(({ offset, length }) => `${offset}-${offset + length}`)
+                    .map(({ offset, length }) => `${offset}-${offset + length - 1}`)
                     .join(',')}`,
             },
             signal,
@@ -3283,10 +3504,11 @@ class RemoteSource extends BaseSource {
             const data = await response.getData();
             const { start, end, total } = parseContentRange(response.getHeader('content-range'));
             this._fileSize = total || null;
+            /** @type {import('./basesource.js').SliceWithData[]} */
             const first = [{
                     data,
                     offset: start,
-                    length: end - start,
+                    length: end + 1 - start,
                 }];
             if (slices.length > 1) {
                 // we requested more than one slice, but got only the first
@@ -3311,12 +3533,17 @@ class RemoteSource extends BaseSource {
                 }];
         }
     }
+    /**
+     * @param {import('./basesource.js').Slice} slice
+     * @param {AbortSignal} [signal]
+     * @returns {Promise<import('./basesource.js').SliceWithData>}
+     */
     async fetchSlice(slice, signal) {
         const { offset, length } = slice;
         const response = await this.client.request({
             headers: {
                 ...this.headers,
-                Range: `bytes=${offset}-${offset + length}`,
+                Range: `bytes=${offset}-${offset + length - 1}`,
             },
             signal,
         });
@@ -3357,7 +3584,7 @@ class RemoteSource extends BaseSource {
  * @returns {BaseSource}
  */
 function maybeWrapInBlockedSource(source, { blockSize, cacheSize }) {
-    if (blockSize === null) {
+    if (blockSize === undefined) {
         return source;
     }
     return new BlockedSource(source, { blockSize, cacheSize });
@@ -3408,17 +3635,30 @@ function makeRemoteSource(url, { forceXHR = false, ...clientOptions } = {}) {
 }
 
 class ArrayBufferSource extends BaseSource {
+    /**
+     * @param {ArrayBuffer} arrayBuffer
+     */
     constructor(arrayBuffer) {
         super();
         this.arrayBuffer = arrayBuffer;
     }
+    /**
+     * @param {import('./basesource.js').Slice} slice
+     * @param {AbortSignal} [signal]
+     * @returns {Promise<import('./basesource.js').SliceWithData>}
+     */
     fetchSlice(slice, signal) {
         if (signal && signal.aborted) {
             throw new AbortError('Request aborted');
         }
-        return this.arrayBuffer.slice(slice.offset, slice.offset + slice.length);
+        return Promise.resolve({
+            data: this.arrayBuffer.slice(slice.offset, slice.offset + slice.length),
+            offset: slice.offset,
+            length: slice.length,
+        });
     }
 }
+/** @param {ArrayBuffer} arrayBuffer */
 function makeBufferSource(arrayBuffer) {
     return new ArrayBufferSource(arrayBuffer);
 }
@@ -3516,6 +3756,17 @@ function getDataSliceReader(dataSlice, fieldType) {
  * @param {true} isArray - Whether to always return an array (vs single value)
  * @returns {import('./geotiff.js').TypedArray|Array<number>} The decoded value(s)
  */
+/**
+ * @overload
+ * @param {import('./geotiff.js').TypedArray|Array<number>|null} outValues - Optional pre-allocated output array
+ * @param {Function} readMethod - DataView read method (e.g., getUint16)
+ * @param {DataSlice} dataSlice - Source data slice
+ * @param {number} fieldType - TIFF field type constant
+ * @param {number} count - Number of values to read
+ * @param {number} offset - Byte offset to start reading
+ * @param {boolean} [isArray] - Whether to always return an array (vs single value)
+ * @returns {import('./geotiff.js').TypedArray|Array<number>|string|number} The decoded value(s)
+ */
 /**
  * Reads field values from a DataSlice.
  * @param {import('./geotiff.js').TypedArray|Array<number>|null} outValues - Optional pre-allocated output array
@@ -3640,9 +3891,11 @@ class DeferredArray {
 class ImageFileDirectory {
     /**
      * Create an ImageFileDirectory.
-     * @param {Map} actualizedFields the file directory, mapping tag names to values
-     * @param {Map} deferredFields the deferred fields, mapping tag names to async functions
-     * @param {Map} deferredArrays the deferred arrays, mapping tag names to DeferredArray objects
+     * @param {Map<string|number, number|string|Array<number|string>>} actualizedFields the file directory,
+     * mapping tag names to values
+     * @param {Map<string|number, Function>} deferredFields the deferred fields, mapping tag names to async functions
+     * @param {Map<string|number, DeferredArray>} deferredArrays the deferred arrays, mapping tag names to
+     * DeferredArray objects
      * @param {number} nextIFDByteOffset the byte offset to the next IFD
      */
     constructor(actualizedFields, deferredFields, deferredArrays, nextIFDByteOffset) {
@@ -3653,7 +3906,7 @@ class ImageFileDirectory {
         this.nextIFDByteOffset = nextIFDByteOffset;
     }
     /**
-     * @param {number|string} tagIdentifier The field tag ID or name
+     * @param {import('./globals.js').TagName|number} tagIdentifier The field tag ID or name
      * @returns {boolean} whether the field exists (actualized or deferred)
      */
     hasTag(tagIdentifier) {
@@ -3662,8 +3915,11 @@ class ImageFileDirectory {
     }
     /**
      * Synchronously retrieves the value for a given tag. If it is deferred, an error is thrown.
-     * @param {number|string} tagIdentifier The field tag ID or name
-     * @returns the field value, or undefined if it does not exist
+     * @template {import('./globals.js').EagerTagName | import('./globals.js').EagerTag} [T=any]
+     * @param {T} tagIdentifier The field tag ID or name
+     * @returns {T extends import('./globals.js').TagName ? (import('./globals.js').TagValue<T> | undefined) : any}
+     * the field value,
+     * or undefined if it does not exist
      * @throws {Error} If the tag is deferred and requires asynchronous loading
      */
     getValue(tagIdentifier) {
@@ -3674,25 +3930,27 @@ class ImageFileDirectory {
             throw new Error(`Field '${tagName}' (${tag}) is deferred. Use loadValue() to load it asynchronously.`);
         }
         if (!this.actualizedFields.has(tag)) {
-            return undefined;
+            return /** @type {any} */ (undefined);
         }
-        return this.actualizedFields.get(tag);
+        return /** @type {any} */ (this.actualizedFields.get(tag));
     }
     /**
      * Retrieves the value for a given tag. If it is deferred, it will be loaded first.
-     * @param {number|string} tagIdentifier The field tag ID or name
-     * @returns the field value, or undefined if it does not exist
+     * @template {import('./globals.js').TagName} [T=any]
+     * @param {T|number} tagIdentifier The field tag ID or name
+     * @returns {Promise<T extends import('./globals.js').TagName ? (import('./globals.js').TagValue<T> | undefined) : any>}
+     *   the field value, or undefined if it does not exist
      */
     async loadValue(tagIdentifier) {
         const tag = resolveTag(tagIdentifier);
         if (this.actualizedFields.has(tag)) {
-            return this.actualizedFields.get(tag);
+            return /** @type {any} */ (this.actualizedFields.get(tag));
         }
         if (this.deferredFieldsBeingResolved.has(tag)) {
-            return this.deferredFieldsBeingResolved.get(tag);
+            return /** @type {any} */ (this.deferredFieldsBeingResolved.get(tag));
         }
-        if (this.deferredFields.has(tag)) {
-            const loaderFn = this.deferredFields.get(tag);
+        const loaderFn = this.deferredFields.get(tag);
+        if (loaderFn) {
             this.deferredFields.delete(tag);
             // Set promise BEFORE starting async work to prevent race conditions
             const valuePromise = (async () => {
@@ -3706,32 +3964,35 @@ class ImageFileDirectory {
                 }
             })();
             this.deferredFieldsBeingResolved.set(tag, valuePromise);
-            return valuePromise;
+            return /** @type {any} */ (valuePromise);
         }
-        if (this.deferredArrays.has(tag)) {
-            const deferredArray = this.deferredArrays.get(tag);
-            return deferredArray.loadAll();
+        const deferredArray = this.deferredArrays.get(tag);
+        if (deferredArray) {
+            return /** @type {any} */ (deferredArray.loadAll());
         }
-        return undefined;
+        return /** @type {any} */ (undefined);
     }
     /**
      * Retrieves the value at a given index for a tag that is an array. If it is deferred, it will be loaded first.
      * @param {number|string} tagIdentifier The field tag ID or name
      * @param {number} index The index within the array
-     * @returns the field value at the given index, or undefined if it does not exist
+     * @returns {Promise<number|string|bigint|undefined>} the field value at the given index, or undefined if it does not exist
      */
     async loadValueIndexed(tagIdentifier, index) {
         const tag = resolveTag(tagIdentifier);
         if (this.actualizedFields.has(tag)) {
             const value = this.actualizedFields.get(tag);
-            return value[index];
+            return /** @type {any} */ (value)[index];
         }
         else if (this.deferredArrays.has(tag)) {
-            const deferredArray = this.deferredArrays.get(tag);
+            const deferredArray = /** @type {DeferredArray} */ (this.deferredArrays.get(tag));
             return deferredArray.get(index);
         }
         else if (this.hasTag(tag)) {
-            return (await this.loadValue(tag))[index];
+            const value = await this.loadValue(tag);
+            if (value && typeof value !== 'number') {
+                return value[index];
+            }
         }
         return undefined;
     }
@@ -3751,8 +4012,8 @@ class ImageFileDirectory {
         /** @type {Partial<Record<import('./globals.js').GeoKeyName, *>>} */
         const geoKeyDirectory = {};
         for (let i = 4; i <= rawGeoKeyDirectory[3] * 4; i += 4) {
-            const key = geoKeyNames[rawGeoKeyDirectory[i]];
-            const location = rawGeoKeyDirectory[i + 1] || null;
+            const key = ( /** @type {Record<number, import('./globals.js').GeoKeyName>} */(geoKeyNames))[rawGeoKeyDirectory[i]];
+            const location = /** @type {import('./globals.js').EagerTag} */ (rawGeoKeyDirectory[i + 1]) || null;
             const count = rawGeoKeyDirectory[i + 2];
             const offset = rawGeoKeyDirectory[i + 3];
             let value = null;
@@ -3779,9 +4040,10 @@ class ImageFileDirectory {
         return geoKeyDirectory;
     }
     toObject() {
+        /** @type {Record<string, unknown>} */
         const obj = {};
         for (const [tag, value] of this.actualizedFields.entries()) {
-            const tagDefinition = tagDefinitions[tag];
+            const tagDefinition = typeof tag === 'number' ? tagDefinitions[tag] : undefined;
             const tagName = tagDefinition ? tagDefinition.name : `Tag${tag}`;
             obj[tagName] = value;
         }
@@ -3905,6 +4167,10 @@ class ImageFileDirectoryParser {
     }
 }
 
+/**
+ * @param {Uint8Array|Uint16Array|Uint32Array} row
+ * @param {number} stride
+ */
 function decodeRowAcc(row, stride) {
     let length = row.length - stride;
     let offset = 0;
@@ -3916,6 +4182,11 @@ function decodeRowAcc(row, stride) {
         length -= stride;
     } while (length > 0);
 }
+/**
+ * @param {Uint8Array} row
+ * @param {number} stride
+ * @param {number} bytesPerSample
+ */
 function decodeRowFloatingPoint(row, stride, bytesPerSample) {
     let index = 0;
     let count = row.length;
@@ -3934,6 +4205,15 @@ function decodeRowFloatingPoint(row, stride, bytesPerSample) {
         }
     }
 }
+/**
+ * @param {ArrayBufferLike} block
+ * @param {number} predictor
+ * @param {number} width
+ * @param {number} height
+ * @param {number[]} bitsPerSample
+ * @param {number} planarConfiguration
+ * @returns
+ */
 function applyPredictor(block, predictor, width, height, bitsPerSample, planarConfiguration) {
     if (!predictor || predictor === 1) {
         return block;
@@ -3978,21 +4258,41 @@ function applyPredictor(block, predictor, width, height, bitsPerSample, planarCo
     return block;
 }
 
+/**
+ * @typedef {Object} BaseDecoderParameters
+ * @property {number} tileWidth
+ * @property {number} tileHeight
+ * @property {number} predictor
+ * @property {number|number[]|import('../geotiff.js').TypedArray} bitsPerSample
+ * @property {number} planarConfiguration
+ * @property {number} [samplesPerPixel]
+ */
 class BaseDecoder {
+    /**
+     * @param {BaseDecoderParameters} parameters
+     */
     constructor(parameters) {
         this.parameters = parameters;
     }
     /**
      * @abstract
+     * @param {ArrayBufferLike} _buffer
+     * @returns {Promise<ArrayBufferLike>|ArrayBufferLike}
      */
     decodeBlock(_buffer) {
         throw new Error('decodeBlock not implemented');
     }
+    /**
+     * @param {ArrayBufferLike} buffer
+     * @returns {Promise<ArrayBufferLike>}
+     */
     async decode(buffer) {
         const decoded = await this.decodeBlock(buffer);
         const { tileWidth, tileHeight, predictor, bitsPerSample, planarConfiguration, } = this.parameters;
         if (predictor !== 1) {
-            return applyPredictor(decoded, predictor, tileWidth, tileHeight, bitsPerSample, planarConfiguration);
+            const isBitsPerSampleArray = Array.isArray(bitsPerSample) || ArrayBuffer.isView(bitsPerSample);
+            const adaptedBitsPerSample = isBitsPerSampleArray ? Array.from(bitsPerSample) : [bitsPerSample];
+            return applyPredictor(decoded, predictor, tileWidth, tileHeight, adaptedBitsPerSample, planarConfiguration);
         }
         return decoded;
     }
@@ -4018,6 +4318,43 @@ class BaseDecoder {
  * `TypedArray[] & { height: number; width: number}`
  * @typedef {TypedArray[] & Dimensions} TypedArrayArrayWithDimensions
  */
+/**
+ * @typedef {Object} GeotiffWriterMetadata
+ * @property {number | number[]} [ImageWidth]
+ * @property {number | number[]} [ImageLength]
+ * @property {number} [width]
+ * @property {number} [height]
+ * @property {number | number[]} [BitsPerSample]
+ * @property {number | number[]} [Compression]
+ * @property {number | number[]} [PlanarConfiguration]
+ * @property {number | number[]} [ExtraSamples]
+ * @property {number | number[]} [PhotometricInterpretation]
+ * @property {number | number[]} [SamplesPerPixel]
+ * @property {number | number[]} [StripByteCounts]
+ * @property {number[]} [ModelPixelScale]
+ * @property {number[]} [ModelTransformation]
+ * @property {number[]} [ModelTiepoint]
+ * @property {number[]} [GeoKeyDirectory]
+ * @property {string} [GeoAsciiParams]
+ * @property {number[]} [GeoDoubleParams]
+ * @property {number | number[]} [Orientation]
+ * @property {number | number[]} [ResolutionUnit]
+ * @property {number | number[]} [XPosition]
+ * @property {number | number[]} [YPosition]
+ * @property {number | number[]} [RowsPerStrip]
+ * @property {number[]} [SampleFormat]
+ * @property {number | number[]} [TileWidth]
+ * @property {number | number[]} [TileLength]
+ * @property {number[]} [TileOffsets]
+ * @property {number[]} [TileByteCounts]
+ * @property {string} [GDAL_NODATA]
+ * @property {number | number[]} [GeographicTypeGeoKey]
+ * @property {number | number[]} [ProjectedCSTypeGeoKey]
+ * @property {string} [GeogCitationGeoKey]
+ * @property {string} [GTCitationGeoKey]
+ * @property {number | number[]} [GTModelTypeGeoKey]
+ * @property {number | number[]} [GTRasterTypeGeoKey]
+ */
 /**
  *  The autogenerated docs are a little confusing here. The effective type is:
  *
@@ -4029,7 +4366,7 @@ class BaseDecoder {
  * Use the {@link Pool.bindParameters} method to get a decoder worker for
  * a specific compression and its parameters.
  *
- * @property {(buffer: ArrayBuffer) => Promise<ArrayBuffer>} decode
+ * @property {(buffer: ArrayBufferLike) => Promise<ArrayBufferLike>} decode
  *   A function that takes a compressed buffer and returns a promise resolving to the decoded buffer.
  */
 /**
@@ -4068,12 +4405,12 @@ class BaseDecoder {
  */
 /**
  * @typedef {Object} BlockedSourceOptions
- * @property {number|null} [blockSize=null] Block size for a BlockedSource.
+ * @property {number} [blockSize] Block size for a BlockedSource.
  * @property {number} [cacheSize=100] The number of blocks to cache.
  */
 /**
  * @typedef {Object} RemoteSourceOptions
- * @property {Object} [headers={}] Additional headers to add to each request
+ * @property {Record<string, string>} [headers={}] Additional headers to add to each request
  * @property {number} [maxRanges=0] Maximum number of ranges to request in a single HTTP request. 0 means no multi-range requests.
  * @property {boolean} [allowFullFile=false] Whether to allow full file responses when requesting ranges
  * @property {boolean} [forceXHR=false] When the Fetch API would be used, force using XMLHttpRequest instead.
@@ -4094,7 +4431,7 @@ class BaseDecoder {
  * @returns {TypedArray|Array<number>|string}
  */
 function getValues(dataSlice, fieldType, count, offset) {
-    /** @type {TypedArray|Array|null} */
+    /** @type {TypedArray|Array<number>|null} */
     let values = null;
     let readMethod = null;
     const fieldTypeLength = getFieldTypeSize(fieldType);
@@ -4157,27 +4494,23 @@ function getValues(dataSlice, fieldType, count, offset) {
         throw new RangeError(`Invalid field type: ${fieldType}`);
     }
     // normal fields
-    if (!(fieldType === fieldTypes.RATIONAL || fieldType === fieldTypes.SRATIONAL)) {
+    {
         for (let i = 0; i < count; ++i) {
             values[i] = readMethod.call(dataSlice, offset + (i * fieldTypeLength));
         }
     }
-    else { // RATIONAL or SRATIONAL
-        for (let i = 0; i < count; i += 2) {
-            values[i] = readMethod.call(dataSlice, offset + (i * fieldTypeLength));
-            values[i + 1] = readMethod.call(dataSlice, offset + ((i * fieldTypeLength) + 4));
-        }
-    }
-    if (fieldType === fieldTypes.ASCII) {
+    {
         return new TextDecoder('utf-8').decode(/** @type {Uint8Array} */ (values));
     }
-    return values;
 }
 /**
  * Error class for cases when an IFD index was requested, that does not exist
  * in the file.
  */
 class GeoTIFFImageIndexError extends Error {
+    /**
+     * @param {number} index
+     */
     constructor(index) {
         super(`No image at index ${index}`);
         this.index = index;
@@ -4262,7 +4595,7 @@ class GeoTIFFBase {
                 const image = await this.getImage(i);
                 const subfileType = image.fileDirectory.getValue('SubfileType');
                 const newSubfileType = image.fileDirectory.getValue('NewSubfileType');
-                if (i === 0 || subfileType === 2 || newSubfileType & 1) {
+                if (i === 0 || subfileType === 2 || (newSubfileType || 0) & 1) {
                     allImages.push(image);
                 }
             }
@@ -4322,9 +4655,16 @@ class GeoTIFF extends GeoTIFFBase {
         this.bigTiff = bigTiff;
         this.firstIFDOffset = firstIFDOffset;
         this.cache = options.cache || false;
+        /** @type {Array<Promise<import('./imagefiledirectory.js').ImageFileDirectory> | undefined>} */
         this.ifdRequests = [];
+        /** @type {Record<string, unknown>|null} */
         this.ghostValues = null;
     }
+    /**
+     * @param {number} offset
+     * @param {number} [size]
+     * @returns {Promise<DataSlice>}
+     */
     async getSlice(offset, size) {
         const fallbackSize = this.bigTiff ? 4048 : 1024;
         return new DataSlice((await this.source.fetch([{
@@ -4332,6 +4672,10 @@ class GeoTIFF extends GeoTIFFBase {
                 length: typeof size !== 'undefined' ? size : fallbackSize,
             }]))[0], offset, this.littleEndian, this.bigTiff);
     }
+    /**
+     * @param {number} index
+     * @return {Promise<import('./imagefiledirectory.js').ImageFileDirectory>}
+     */
     async requestIFD(index) {
         // see if we already have that IFD index requested.
         if (this.ifdRequests[index]) {
@@ -4362,7 +4706,11 @@ class GeoTIFF extends GeoTIFFBase {
         // if the previous IFD was loaded, we can finally fetch the one we are interested in.
         // we need to wrap this in an IIFE, otherwise this.ifdRequests[index] would be delayed
         this.ifdRequests[index] = (async () => {
-            const previousIfd = await this.ifdRequests[index - 1];
+            const previousPromise = this.ifdRequests[index - 1];
+            if (!previousPromise) {
+                throw new Error('Previous IFD request missing');
+            }
+            const previousIfd = await previousPromise;
             if (previousIfd.nextIFDByteOffset === 0) {
                 throw new GeoTIFFImageIndexError(index);
             }
@@ -4407,11 +4755,11 @@ class GeoTIFF extends GeoTIFFBase {
     /**
      * Get the values of the COG ghost area as a parsed map.
      * See https://gdal.org/drivers/raster/cog.html#header-ghost-area for reference
-     * @returns {Promise<Object>} the parsed ghost area or null, if no such area was found
+     * @returns {Promise<Record<string, unknown>|null>} the parsed ghost area or null, if no such area was found
      */
     async getGhostValues() {
         const offset = this.bigTiff ? 16 : 8;
-        if (this.ghostValues) {
+        if (this.ghostValues !== null) {
             return this.ghostValues;
         }
         const detectionString = 'GDAL_STRUCTURAL_METADATA_SIZE=';
@@ -4425,15 +4773,16 @@ class GeoTIFF extends GeoTIFFBase {
                 slice = await this.getSlice(offset, metadataSize);
             }
             const fullString = getValues(slice, fieldTypes.ASCII, metadataSize, offset);
-            /** @type {Object} */
-            this.ghostValues = {};
+            /** @type {Record<string, unknown>} */
+            const ghostValues = {};
             fullString
                 .split('\n')
                 .filter((line) => line.length > 0)
                 .map((line) => line.split('='))
                 .forEach(([key, value]) => {
-                this.ghostValues[key] = value;
+                ghostValues[key] = value;
             });
+            this.ghostValues = ghostValues;
         }
         return this.ghostValues;
     }
@@ -4448,7 +4797,7 @@ class GeoTIFF extends GeoTIFFBase {
     static async fromSource(source, options, signal) {
         const headerData = (await source.fetch([{ offset: 0, length: 1024 }], signal))[0];
         const dataView = new DataView64(headerData);
-        const BOM = dataView.getUint16(0, 0);
+        const BOM = dataView.getUint16(0, false);
         let littleEndian;
         if (BOM === 0x4949) {
             littleEndian = true;
@@ -5332,11 +5681,11 @@ class BitmapGenerator {
     }
     static getColorValue(dataArray, options, arrayLength, samplesPerPixel = 1) {
         // Normalize all colorScale entries for chroma.js compatibility
-        const colorScale = chroma.scale(options.colorScale?.map(c => Array.isArray(c) ? chroma(c) : c)).domain(options.colorScaleValueRange);
+        const colorScale = chroma.scale(options.colorScale?.map(c => Array.isArray(c) ? chroma(c) : c)).domain(options.colorScaleValueRange ?? [0, 255]);
         const colorsArray = new Uint8ClampedArray(arrayLength);
-        const optAlpha = Math.floor(options.alpha * 2.55);
-        const rangeMin = options.colorScaleValueRange[0];
-        const rangeMax = options.colorScaleValueRange.slice(-1)[0];
+        const optAlpha = Math.floor((options.alpha ?? 100) * 2.55);
+        const rangeMin = options.colorScaleValueRange?.[0] ?? 0;
+        const rangeMax = options.colorScaleValueRange?.[1] ?? 255;
         const is8Bit = dataArray instanceof Uint8Array || dataArray instanceof Uint8ClampedArray;
         const isFloatOrWide = !is8Bit && (dataArray instanceof Float32Array || dataArray instanceof Uint16Array || dataArray instanceof Int16Array);
         // 1. 8-BIT COMPREHENSIVE LUT
@@ -5649,6 +5998,7 @@ class TerrainGenerator {
             const cellSize = input.cellSizeMeters ?? ((input.bounds[2] - input.bounds[0]) / 256);
             const zFactor = options.zFactor ?? 1;
             if (options.useSlope && options.useHillshade) {
+                // eslint-disable-next-line no-console
                 console.warn('[TerrainGenerator] useSlope and useHillshade are mutually exclusive; useSlope takes precedence.');
             }
             // Build a separate raster for kernel computation that preserves noData samples.
@@ -5662,7 +6012,6 @@ class TerrainGenerator {
                 for (let i = 0; i < terrain.length; i++) {
                     // If the source raster marks this sample as noData, keep it as noData for the kernel.
                     // Otherwise, use the processed terrain elevation value.
-                    // eslint-disable-next-line eqeqeq
                     kernelTerrain[i] = sourceRaster[i] == noData ? noData : terrain[i];
                 }
             }
@@ -5904,8 +6253,8 @@ class CogTiles {
     cogResolutionLookup = [];
     cogOrigin = [0, 0];
     zoomRange = [0, 0];
-    tileSize;
-    bounds; // Or your Bounds type
+    tileSize = 256;
+    bounds = [0, 0, 0, 0];
     geo = new GeoImage();
     options;
     constructor(options) {
@@ -6099,7 +6448,7 @@ class CogTiles {
         if (missingLeft > 0 || missingTop > 0 || readWidth < FETCH_SIZE || readHeight < FETCH_SIZE) {
             const numChannels = this.options.numOfChannels || 1;
             // Initialize with a TypedArray of the full target size and correct data type
-            const validImageData = this.createTileBuffer(this.options.format, FETCH_SIZE, numChannels);
+            const validImageData = this.createTileBuffer(this.options.format || 'Float32', FETCH_SIZE, numChannels);
             if (this.options.noDataValue !== undefined) {
                 validImageData.fill(this.options.noDataValue);
             }
@@ -6108,7 +6457,7 @@ class CogTiles {
             // Place the valid pixel data into the tile buffer.
             for (let band = 0; band < validRasterData.length; band += 1) {
                 // We must reset the buffer for each band, otherwise data from previous band persists in padding areas
-                const tileBuffer = this.createTileBuffer(this.options.format, FETCH_SIZE);
+                const tileBuffer = this.createTileBuffer(this.options.format || 'Float32', FETCH_SIZE);
                 if (this.options.noDataValue !== undefined) {
                     tileBuffer.fill(this.options.noDataValue);
                 }
@@ -6530,7 +6879,7 @@ class CogTerrainLayer extends core.CompositeLayer {
     static defaultProps = defaultProps;
     static layerName = 'CogTerrainLayer';
     // terrainCogTiles: CogTiles;
-    terrainUrl;
+    terrainUrl = '';
     async initializeState(context) {
         super.initializeState(context);
         this.setState({
@@ -6652,16 +7001,19 @@ class CogTerrainLayer extends core.CompositeLayer {
         const { zRange } = this.state;
         const ranges = tiles
             .map((tile) => tile.content)
-            .filter((x) => x && x[0])
+            .filter((x) => !!x && !!x[0])
             .map((arr) => {
+            if (!arr || !arr[0])
+                return undefined;
             const bounds = arr[0]?.map?.header?.boundingBox;
             return bounds?.map((bound) => bound[2]);
-        });
+        })
+            .filter((x) => x !== undefined);
         if (ranges.length === 0) {
             return;
         }
-        const minZ = Math.min(...ranges.map((x) => x[0]));
-        const maxZ = Math.max(...ranges.map((x) => x[1]));
+        const minZ = Math.min(...ranges.map((x) => x?.[0] ?? 0).filter((n) => Number.isFinite(n)));
+        const maxZ = Math.max(...ranges.map((x) => x?.[1] ?? 0).filter((n) => Number.isFinite(n)));
         if (!zRange || minZ < zRange[0] || maxZ > zRange[1]) {
             this.setState({ zRange: [Number.isFinite(minZ) ? minZ : 0, Number.isFinite(maxZ) ? maxZ : 0] });
         }
@@ -6708,10 +7060,12 @@ class CogTerrainLayer extends core.CompositeLayer {
                 refinementStrategy,
             });
         }
+        return null;
     }
 }
 
 class RawDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         return buffer;
     }
@@ -6726,6 +7080,12 @@ const MIN_BITS = 9;
 const CLEAR_CODE = 256; // clear code
 const EOI_CODE = 257; // end of information
 const MAX_BYTELENGTH = 12;
+/**
+ * @param {Uint8Array} array
+ * @param {number} position
+ * @param {number} length
+ * @returns {number}
+ */
 function getByte(array, position, length) {
     const d = position % 8;
     const a = Math.floor(position / 8);
@@ -6753,12 +7113,21 @@ function getByte(array, position, length) {
     }
     return chunks;
 }
+/**
+ * @template T
+ * @param {Array<T>} dest
+ * @param {Array<T>} source
+ * @returns {Array<T>}
+ */
 function appendReversed(dest, source) {
     for (let i = source.length - 1; i >= 0; i--) {
         dest.push(source[i]);
     }
     return dest;
 }
+/**
+ * @param {ArrayBuffer} input
+ */
 function decompress(input) {
     const dictionaryIndex = new Uint16Array(4093);
     const dictionaryChar = new Uint8Array(4093);
@@ -6773,17 +7142,23 @@ function decompress(input) {
         dictionaryLength = 258;
         byteLength = MIN_BITS;
     }
+    /** @param {Uint8Array} array */
     function getNext(array) {
         const byte = getByte(array, position, byteLength);
         position += byteLength;
         return byte;
     }
+    /**
+     * @param {number} i
+     * @param {number} c
+     */
     function addToDictionary(i, c) {
         dictionaryChar[dictionaryLength] = c;
         dictionaryIndex[dictionaryLength] = i;
         dictionaryLength++;
         return dictionaryLength - 1;
     }
+    /** @param {number} n */
     function getDictionaryReversed(n) {
         const rev = [];
         for (let i = n; i !== 4096; i = dictionaryIndex[i]) {
@@ -6818,10 +7193,15 @@ function decompress(input) {
         else if (code < dictionaryLength) {
             const val = getDictionaryReversed(code);
             appendReversed(result, val);
-            addToDictionary(oldCode, val[val.length - 1]);
+            if (oldCode !== undefined) {
+                addToDictionary(oldCode, val[val.length - 1]);
+            }
             oldCode = code;
         }
         else {
+            if (oldCode === undefined) {
+                throw new Error(`Invalid LZW code: ${code} with no previous code`);
+            }
             const oldVal = getDictionaryReversed(oldCode);
             if (!oldVal) {
                 throw new Error(`Bogus entry. Not in dictionary, ${oldCode} / ${dictionaryLength}, position: ${position}`);
@@ -6844,6 +7224,7 @@ function decompress(input) {
     return new Uint8Array(result);
 }
 class LZWDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         return decompress(buffer).buffer;
     }
@@ -6902,6 +7283,33 @@ const dctSqrt2 = 5793; // sqrt(2)
 const dctSqrt1d2 = 2896; // sqrt(2) / 2
 /** @typedef {(number|HuffmanNode)[]} HuffmanNode */
 /** @typedef {{children: HuffmanNode, index: number}} Code */
+/**
+ * @typedef {Object} JpegComponent
+ * @property {number} h
+ * @property {number} v
+ * @property {number} [quantizationIdx]
+ * @property {Int32Array} [quantizationTable]
+ * @property {number} blocksPerLine
+ * @property {number} blocksPerColumn
+ * @property {Int32Array[][]} blocks
+ * @property {HuffmanNode} [huffmanTableDC]
+ * @property {HuffmanNode} [huffmanTableAC]
+ * @property {number} [pred]
+ */
+/**
+ * @typedef {Object} JpegFrame
+ * @property {boolean} extended
+ * @property {boolean} progressive
+ * @property {number} precision
+ * @property {number} scanLines
+ * @property {number} samplesPerLine
+ * @property {Object.<string, JpegComponent>} components
+ * @property {number[]} componentsOrder
+ * @property {number} maxH
+ * @property {number} maxV
+ * @property {number} mcusPerLine
+ * @property {number} mcusPerColumn
+ */
 /**
  * @param {Uint8Array<ArrayBuffer>} codeLengths
  * @param {Uint8Array<ArrayBuffer>} values
@@ -6951,8 +7359,25 @@ function buildHuffmanTable(codeLengths, values) {
     }
     return code[0].children;
 }
+/**
+ * @param {Uint8Array} data
+ * @param {number} initialOffset
+ * @param {JpegFrame} frame
+ * @param {JpegComponent[]} components
+ * @param {number} resetInterval
+ * @param {number} spectralStart
+ * @param {number} spectralEnd
+ * @param {number} successivePrev
+ * @param {number} successive
+ */
 function decodeScan(data, initialOffset, frame, components, resetInterval, spectralStart, spectralEnd, successivePrev, successive) {
     const { mcusPerLine, progressive } = frame;
+    if (components.length > 1 && (mcusPerLine === undefined || frame.mcusPerColumn === undefined)) {
+        throw new Error('Missing MCU dimensions');
+    }
+    if (components.length === 1 && (components[0].blocksPerLine === undefined || components[0].blocksPerColumn === undefined)) {
+        throw new Error('Missing block dimensions');
+    }
     const startOffset = initialOffset;
     let offset = initialOffset;
     let bitsData = 0;
@@ -6973,20 +7398,26 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
         bitsCount = 7;
         return bitsData >>> 7;
     }
+    /** @param {HuffmanNode|undefined} tree */
     function decodeHuffman(tree) {
+        if (!tree) {
+            throw new Error('Huffman table not found');
+        }
         let node = tree;
         let bit;
         while ((bit = readBit()) !== null) { // eslint-disable-line no-cond-assign
-            node = node[bit];
-            if (typeof node === 'number') {
-                return node;
+            const next = node[bit];
+            if (typeof next === 'number') {
+                return next;
             }
-            if (typeof node !== 'object') {
+            if (typeof next !== 'object') {
                 throw new Error('invalid huffman sequence');
             }
+            node = next;
         }
         return null;
     }
+    /** @param {number} initialLength */
     function receive(initialLength) {
         let length = initialLength;
         let n = 0;
@@ -7000,6 +7431,7 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
         }
         return n;
     }
+    /** @param {number} length */
     function receiveAndExtend(length) {
         const n = receive(length);
         if (n === undefined) {
@@ -7010,9 +7442,22 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
         }
         return n + (-1 << length) + 1;
     }
+    /**
+     * @param {JpegComponent} component
+     * @param {Int32Array} zz
+     */
     function decodeBaseline(component, zz) {
         const t = decodeHuffman(component.huffmanTableDC);
+        if (t === null) {
+            throw new Error('Huffman error');
+        }
         const diff = t === 0 ? 0 : receiveAndExtend(t);
+        if (diff === undefined) {
+            throw new Error('Unexpected end of stream');
+        }
+        if (component.pred === undefined) {
+            component.pred = 0;
+        }
         component.pred += diff;
         zz[0] = component.pred;
         let k = 1;
@@ -7032,25 +7477,51 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
             else {
                 k += r;
                 const z = dctZigZag[k];
-                zz[z] = receiveAndExtend(s);
+                const val = receiveAndExtend(s);
+                if (val === undefined) {
+                    throw new Error('Unexpected end of stream');
+                }
+                zz[z] = val;
                 k++;
             }
         }
     }
+    /**
+     * @param {JpegComponent} component
+     * @param {Int32Array} zz
+     */
     function decodeDCFirst(component, zz) {
         const t = decodeHuffman(component.huffmanTableDC);
+        if (t === null) {
+            throw new Error('Huffman error');
+        }
         const value = receiveAndExtend(t);
         if (value === undefined) {
             throw new Error('Unexpected end of data in DC coefficient decoding');
         }
         const diff = t === 0 ? 0 : (value << successive);
+        if (component.pred === undefined) {
+            component.pred = 0;
+        }
         component.pred += diff;
         zz[0] = component.pred;
     }
-    function decodeDCSuccessive(component, zz) {
-        zz[0] |= readBit() << successive;
+    /**
+     * @param {JpegComponent} _
+     * @param {Int32Array} zz
+     */
+    function decodeDCSuccessive(_, zz) {
+        const bit = readBit();
+        if (bit === null) {
+            throw new Error('Unexpected end of data in DC coefficient decoding');
+        }
+        zz[0] |= bit << successive;
     }
     let eobrun = 0;
+    /**
+     * @param {JpegComponent} component
+     * @param {Int32Array} zz
+     */
     function decodeACFirst(component, zz) {
         if (eobrun > 0) {
             eobrun--;
@@ -7089,7 +7560,12 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
         }
     }
     let successiveACState = 0;
+    /** @type {number} */
     let successiveACNextValue;
+    /**
+     * @param {JpegComponent} component
+     * @param {Int32Array} zz
+     */
     function decodeACSuccessive(component, zz) {
         let k = spectralStart;
         const e = spectralEnd;
@@ -7123,7 +7599,11 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
                         if (s !== 1) {
                             throw new Error('invalid ACn encoding');
                         }
-                        successiveACNextValue = receiveAndExtend(s);
+                        const nextVal = receiveAndExtend(s);
+                        if (nextVal === undefined) {
+                            throw new Error('Unexpected end of data in AC coefficient decoding');
+                        }
+                        successiveACNextValue = nextVal;
                         successiveACState = r ? 2 : 3;
                     }
                     continue; // eslint-disable-line no-continue
@@ -7131,7 +7611,11 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
                 case 1: // skipping r zero items
                 case 2:
                     if (zz[z]) {
-                        zz[z] += (readBit() << successive) * direction;
+                        const bit = readBit();
+                        if (bit === null) {
+                            throw new Error('Unexpected end of data in AC coefficient decoding');
+                        }
+                        zz[z] += (bit << successive) * direction;
                     }
                     else {
                         r--;
@@ -7142,7 +7626,11 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
                     break;
                 case 3: // set value for a zero item
                     if (zz[z]) {
-                        zz[z] += (readBit() << successive) * direction;
+                        const bit = readBit();
+                        if (bit === null) {
+                            throw new Error('Unexpected end of data in AC coefficient decoding');
+                        }
+                        zz[z] += (bit << successive) * direction;
                     }
                     else {
                         zz[z] = successiveACNextValue << successive;
@@ -7151,7 +7639,11 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
                     break;
                 case 4: // eob
                     if (zz[z]) {
-                        zz[z] += (readBit() << successive) * direction;
+                        const bit = readBit();
+                        if (bit === null) {
+                            throw new Error('Unexpected end of data in AC coefficient decoding');
+                        }
+                        zz[z] += (bit << successive) * direction;
                     }
                     break;
             }
@@ -7164,16 +7656,34 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
             }
         }
     }
+    /**
+     * @param {JpegComponent} component
+     * @param {function} decodeFunction
+     * @param {number} mcu
+     * @param {number} row
+     * @param {number} col
+     */
     function decodeMcu(component, decodeFunction, mcu, row, col) {
         const mcuRow = (mcu / mcusPerLine) | 0;
         const mcuCol = mcu % mcusPerLine;
         const blockRow = (mcuRow * component.v) + row;
         const blockCol = (mcuCol * component.h) + col;
+        if (!component.blocks) {
+            throw new Error('Missing blocks');
+        }
         decodeFunction(component, component.blocks[blockRow][blockCol]);
     }
+    /**
+     * @param {JpegComponent} component
+     * @param {function} decodeFunction
+     * @param {number} mcu
+     */
     function decodeBlock(component, decodeFunction, mcu) {
         const blockRow = (mcu / component.blocksPerLine) | 0;
         const blockCol = mcu % component.blocksPerLine;
+        if (!component.blocks) {
+            throw new Error('Missing blocks');
+        }
         decodeFunction(component, component.blocks[blockRow][blockCol]);
     }
     const componentsLength = components.length;
@@ -7250,9 +7760,15 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
     }
     return offset - startOffset;
 }
-function buildComponentData(frame, component) {
+/**
+ * @param {JpegComponent} component
+ */
+function buildComponentData(component) {
     const lines = [];
     const { blocksPerLine, blocksPerColumn } = component;
+    if (!blocksPerLine || !blocksPerColumn || !component.blocks) {
+        throw new Error('Missing component data');
+    }
     const samplesPerLine = blocksPerLine << 3;
     const R = new Int32Array(64);
     const r = new Uint8Array(64);
@@ -7261,8 +7777,16 @@ function buildComponentData(frame, component) {
     //   "Practical Fast 1-D DCT Algorithms with 11 Multiplications",
     //   IEEE Intl. Conf. on Acoustics, Speech & Signal Processing, 1989,
     //   988-991.
+    /**
+     * @param {Int32Array} zz
+     * @param {Uint8Array} dataOut
+     * @param {Int32Array} dataIn
+     */
     function quantizeAndInverse(zz, dataOut, dataIn) {
         const qt = component.quantizationTable;
+        if (!qt) {
+            throw new Error('No quantization table found');
+        }
         let v0;
         let v1;
         let v2;
@@ -7441,14 +7965,21 @@ class JpegStreamReader {
     constructor() {
         this.jfif = null;
         this.adobe = null;
+        /** @type {number} */
+        this.resetInterval = 0;
+        /** @type {Int32Array[]} */
         this.quantizationTables = [];
+        /** @type {HuffmanNode[]} */
         this.huffmanTablesAC = [];
+        /** @type {HuffmanNode[]} */
         this.huffmanTablesDC = [];
+        /** @type {JpegFrame[]} */
         this.frames = [];
     }
     resetFrames() {
         this.frames = [];
     }
+    /** @param {Uint8Array} data */
     parse(data) {
         let offset = 0;
         // const { length } = data;
@@ -7463,6 +7994,7 @@ class JpegStreamReader {
             offset += array.length;
             return array;
         }
+        /** @param {JpegFrame} frame */
         function prepareComponents(frame) {
             let maxH = 0;
             let maxV = 0;
@@ -7589,15 +8121,21 @@ class JpegStreamReader {
                 case 0xFFC1: // SOF1 (Start of Frame, Extended DCT)
                 case 0xFFC2: { // SOF2 (Start of Frame, Progressive DCT)
                     readUint16(); // skip data length
+                    /** @type {JpegFrame} */
                     const frame = {
                         extended: (fileMarker === 0xFFC1),
                         progressive: (fileMarker === 0xFFC2),
                         precision: data[offset++],
                         scanLines: readUint16(),
                         samplesPerLine: readUint16(),
+                        /** @type {Object.<string, JpegComponent>} */
                         components: {},
-                        /** @type {any[]} */
+                        /** @type {number[]} */
                         componentsOrder: [],
+                        maxH: 0,
+                        maxV: 0,
+                        mcusPerLine: 0,
+                        mcusPerColumn: 0,
                     };
                     const componentsCount = data[offset++];
                     let componentId;
@@ -7613,6 +8151,9 @@ class JpegStreamReader {
                             h,
                             v,
                             quantizationIdx: qId,
+                            blocksPerLine: 0,
+                            blocksPerColumn: 0,
+                            blocks: [],
                         };
                         offset += 3;
                     }
@@ -7697,11 +8238,17 @@ class JpegStreamReader {
         for (let i = 0; i < this.frames.length; i++) {
             const cp = this.frames[i].components;
             for (const j of Object.keys(cp)) {
-                cp[j].quantizationTable = this.quantizationTables[cp[j].quantizationIdx];
-                delete cp[j].quantizationIdx;
+                const qIdx = cp[j].quantizationIdx;
+                if (typeof qIdx === 'number') {
+                    cp[j].quantizationTable = this.quantizationTables[qIdx];
+                    delete cp[j].quantizationIdx;
+                }
             }
         }
         const frame = frames[0];
+        if (!frame.maxH || !frame.maxV) {
+            throw new Error('Invalid frame dimensions');
+        }
         const { components, componentsOrder } = frame;
         const outComponents = [];
         const width = frame.samplesPerLine;
@@ -7709,7 +8256,7 @@ class JpegStreamReader {
         for (let i = 0; i < componentsOrder.length; i++) {
             const component = components[componentsOrder[i]];
             outComponents.push({
-                lines: buildComponentData(frame, component),
+                lines: buildComponentData(component),
                 scaleX: component.h / frame.maxH,
                 scaleY: component.v / frame.maxV,
             });
@@ -7729,6 +8276,9 @@ class JpegStreamReader {
     }
 }
 class JpegDecoder extends BaseDecoder {
+    /**
+     * @param {import('./basedecoder.js').BaseDecoderParameters & { JPEGTables?: Uint8Array }} parameters
+     */
     constructor(parameters) {
         super(parameters);
         this.reader = new JpegStreamReader();
@@ -7736,6 +8286,7 @@ class JpegDecoder extends BaseDecoder {
             this.reader.parse(parameters.JPEGTables);
         }
     }
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         this.reader.resetFrames();
         this.reader.parse(new Uint8Array(buffer));
@@ -10984,6 +11535,7 @@ const { inflate} = inflate_1$1;
 var inflate_1 = inflate;
 
 class DeflateDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         return inflate_1(new Uint8Array(buffer)).buffer;
     }
@@ -10995,6 +11547,7 @@ var deflate = /*#__PURE__*/Object.freeze({
 });
 
 class PackbitsDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         const dataView = new DataView(buffer);
         const out = [];
@@ -13442,23 +13995,33 @@ let ZSTDDecoder$1 = class ZSTDDecoder {
 // wasm:begin
 const wasm$1 = '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';
 
+/**
+ * @typedef {import('./basedecoder.js').BaseDecoderParameters & { LercParameters?: any }} LercDecoderParameters
+ */
 const zstd$2 = new ZSTDDecoder$1();
 class LercDecoder extends BaseDecoder {
+    /**
+     * @param {ArrayBufferLike} buffer
+     * @returns {ArrayBufferLike}
+     */
     decodeBlock(buffer) {
-        const addCompression = this.parameters.LercParameters[LercParameters.AddCompression];
+        const params = /** @type {LercDecoderParameters} */ (this.parameters);
+        const addCompression = params.LercParameters?.[LercParameters.AddCompression];
+        /** @type {ArrayBufferLike} */
+        let decoded = buffer;
         switch (addCompression) {
             case LercAddCompression.None:
                 break;
             case LercAddCompression.Deflate:
-                buffer = inflate_1(new Uint8Array(buffer)).buffer; // eslint-disable-line no-param-reassign, prefer-destructuring
+                decoded = inflate_1(new Uint8Array(decoded)).buffer;
                 break;
             case LercAddCompression.Zstandard:
-                buffer = zstd$2.decode(new Uint8Array(buffer)).buffer; // eslint-disable-line no-param-reassign, prefer-destructuring
+                decoded = zstd$2.decode(new Uint8Array(decoded)).buffer;
                 break;
             default:
                 throw new Error(`Unsupported LERC additional compression method identifier: ${addCompression}`);
         }
-        const lercResult = Lerc.decode(buffer, { returnPixelInterleavedDims: this.parameters.planarConfiguration === 1 });
+        const lercResult = Lerc.decode(decoded, { returnPixelInterleavedDims: this.parameters.planarConfiguration === 1 });
         const lercData = lercResult.pixels[0];
         return lercData.buffer;
     }
@@ -13634,8 +14197,9 @@ const wasm = 'AGFzbQEAAAABpgEVYAF/AGADf39/AX9gA39/fwBgAX8Bf2AFf39/f38Bf2ACf38AYA
 
 const zstd = new ZSTDDecoder();
 class ZstdDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
-        return zstd.decode(new Uint8Array(buffer)).buffer;
+        return /** @type {ArrayBuffer} */ (zstd.decode(new Uint8Array(buffer)).buffer);
     }
 }
 
@@ -13652,6 +14216,9 @@ var zstd$1 = /*#__PURE__*/Object.freeze({
  * formats like WebP when supported.
  */
 class WebImageDecoder extends BaseDecoder {
+    /**
+     * @param {import('./basedecoder.js').BaseDecoderParameters} parameters
+     */
     constructor(parameters) {
         super(parameters);
         if (typeof createImageBitmap === 'undefined') {
@@ -13661,6 +14228,7 @@ class WebImageDecoder extends BaseDecoder {
             throw new Error('Cannot decode WebImage as neither `document` nor `OffscreenCanvas` is not available');
         }
     }
+    /** @param {ArrayBuffer} buffer */
     async decodeBlock(buffer) {
         const blob = new Blob([buffer]);
         const imageBitmap = await createImageBitmap(blob);