@gisatcz/deckgl-geolib 2.4.0 → 2.5.0-dev.1

package/dist/esm/index.js

@@ -445,30 +445,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,
@@ -500,219 +501,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.
@@ -722,8 +700,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
@@ -753,7 +732,7 @@ const LercAddCompression = {
     Deflate: 1,
     Zstandard: 2,
 };
-const geoKeyNames = Object.freeze({
+const geoKeyNames = /** @type {const} */ ({
     1024: 'GTModelTypeGeoKey',
     1025: 'GTRasterTypeGeoKey',
     1026: 'GTCitationGeoKey',
@@ -802,15 +781,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) {
@@ -910,39 +881,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) {
@@ -955,27 +927,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);
 }
@@ -1002,6 +974,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),
@@ -1028,6 +1003,9 @@ const defaultDecoderDefinitions = [
             return m;
         })
             .then((m) => m.default),
+        /**
+         * @param {import("../imagefiledirectory.js").ImageFileDirectory} fileDirectory
+         */
         decoderParameterFn: async (fileDirectory) => {
             return {
                 ...await defaultDecoderParameterFn(fileDirectory),
@@ -1049,10 +1027,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,
@@ -1067,17 +1048,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;
@@ -1097,17 +1084,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;
@@ -1136,13 +1128,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()) {
@@ -1157,14 +1149,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;
@@ -1184,14 +1176,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;
@@ -1220,7 +1212,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
@@ -1228,7 +1220,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()) {
@@ -1243,10 +1235,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) {
@@ -1254,42 +1252,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;
@@ -1299,6 +1319,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);
@@ -1372,7 +1402,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
@@ -1380,7 +1410,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) {
@@ -1392,7 +1423,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;
@@ -1409,46 +1440,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();
@@ -1465,22 +1500,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) {
@@ -1520,26 +1565,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());
@@ -1558,12 +1609,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();
@@ -1579,7 +1630,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));
@@ -1601,11 +1652,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
@@ -1624,11 +1675,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);
@@ -1677,7 +1734,7 @@ class GeoTIFFImage {
                                 }
                                 else {
                                     windowCoordinate = ((y + firstLine - imageWindow[1]) * windowWidth) + x + firstCol - imageWindow[0];
-                                    valueArrays[si][windowCoordinate] = value;
+                                    /** @type {TypedArray} */ (valueArrays[si])[windowCoordinate] = value;
                                 }
                             }
                         }
@@ -1713,12 +1770,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
@@ -1728,7 +1785,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
@@ -1766,9 +1823,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)) {
@@ -1801,12 +1865,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
@@ -1816,7 +1880,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.
@@ -1839,9 +1903,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);
                 }
             }
@@ -1896,7 +1962,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);
@@ -1923,20 +1989,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({
@@ -1957,14 +2026,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);
@@ -1983,10 +2054,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));
     }
     /**
@@ -2075,9 +2146,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],
@@ -2115,12 +2186,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);
@@ -2140,7 +2219,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;
@@ -2165,36 +2249,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;
@@ -2216,33 +2349,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);
@@ -2262,7 +2436,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)
@@ -2288,6 +2466,10 @@ class DataSlice {
         }
         return value;
     }
+    /**
+     * @param {number} offset
+     * @returns {number}
+     */
     readOffset(offset) {
         if (this._bigTiff) {
             return this.readUint64(offset);
@@ -2297,13 +2479,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;
@@ -2312,14 +2498,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;
     });
@@ -2327,8 +2514,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) {
@@ -2336,12 +2523,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) {
@@ -2361,11 +2548,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}`;
@@ -2378,7 +2566,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) {
@@ -2417,29 +2605,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;
@@ -2733,18 +2923,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);
@@ -2752,14 +2938,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 {
@@ -2834,7 +3021,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[]>}
      */
@@ -2916,24 +3103,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;
@@ -2955,7 +3143,7 @@ class BlockedSource extends BaseSource {
     }
     /**
      *
-     * @param {Set} blockIds
+     * @param {Set<number>} blockIds
      * @returns {BlockGroup[]}
      */
     groupBlocks(blockIds) {
@@ -2963,6 +3151,7 @@ class BlockedSource extends BaseSource {
         if (sortedBlockIds.length === 0) {
             return [];
         }
+        /** @type {number[]} */
         let current = [];
         let lastBlockId = null;
         const groups = [];
@@ -2981,7 +3170,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[]}
      */
@@ -3041,10 +3230,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');
     }
     /**
@@ -3055,15 +3244,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');
     }
 }
@@ -3082,10 +3272,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
@@ -3096,6 +3286,10 @@ class FetchResponse extends BaseResponse {
     }
 }
 class FetchClient extends BaseClient {
+    /**
+     * @param {string} url
+     * @param {RequestCredentials} [credentials]
+     */
     constructor(url, credentials) {
         super(url);
         this.credentials = credentials;
@@ -3126,14 +3320,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();
@@ -3158,7 +3361,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;
     }
@@ -3170,6 +3373,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();
@@ -3179,8 +3383,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;
@@ -3188,11 +3397,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({
@@ -3200,6 +3415,7 @@ class HttpClient extends BaseClient {
                 headers,
             }, (response) => {
                 const dataPromise = new Promise((resolveData) => {
+                    /** @type {Uint8Array[]} */
                     const chunks = [];
                     // collect chunks
                     response.on('data', (chunk) => {
@@ -3223,7 +3439,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;
     }
@@ -3232,7 +3448,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 } = {}) {
@@ -3246,24 +3462,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,
@@ -3281,10 +3502,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
@@ -3309,12 +3531,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,
         });
@@ -3355,7 +3582,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 });
@@ -3406,17 +3633,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);
 }
@@ -3514,6 +3754,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
@@ -3638,9 +3889,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) {
@@ -3651,7 +3904,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) {
@@ -3660,8 +3913,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) {
@@ -3672,25 +3928,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 () => {
@@ -3704,32 +3962,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;
     }
@@ -3749,8 +4010,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;
@@ -3777,9 +4038,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;
         }
@@ -3903,6 +4165,10 @@ class ImageFileDirectoryParser {
     }
 }
 
+/**
+ * @param {Uint8Array|Uint16Array|Uint32Array} row
+ * @param {number} stride
+ */
 function decodeRowAcc(row, stride) {
     let length = row.length - stride;
     let offset = 0;
@@ -3914,6 +4180,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;
@@ -3932,6 +4203,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;
@@ -3976,21 +4256,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;
     }
@@ -4016,6 +4316,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:
  *
@@ -4027,7 +4364,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.
  */
 /**
@@ -4066,12 +4403,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.
@@ -4092,7 +4429,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);
@@ -4155,27 +4492,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;
@@ -4260,7 +4593,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);
                 }
             }
@@ -4320,9 +4653,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([{
@@ -4330,6 +4670,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]) {
@@ -4360,7 +4704,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);
             }
@@ -4405,11 +4753,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=';
@@ -4423,15 +4771,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;
     }
@@ -4446,7 +4795,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;
@@ -4517,6 +4866,7 @@ async function fromArrayBuffer(arrayBuffer, signal) {
 const DefaultGeoImageOptions = {
     // --- Shared / Data ---
     type: 'image',
+    blockSize: 65536,
     format: undefined,
     useChannel: null,
     useChannelIndex: null,
@@ -4543,9 +4893,23 @@ const DefaultGeoImageOptions = {
     color: [255, 0, 255, 255],
     colorScale: chroma.brewer.YlOrRd,
     colorScaleValueRange: [0, 255],
+    //     colorScale: [
+    //     [75, 120, 90],    // Brightened forest green
+    //     [100, 145, 100],  // Soft meadow green
+    //     [130, 170, 110],  // Bright moss
+    //     [185, 210, 145],  // Sunny sage
+    //     [235, 235, 185],  // Pale primrose (transitional)
+    //     [225, 195, 160],  // Sand / light terracotta (matches slope)
+    //     [195, 160, 130],  // Warm clay brown
+    //     [170, 155, 150],  // Warm slate grey
+    //     [245, 245, 240],  // Bright mist
+    //     [255, 255, 255],  // Pure peak white
+    // ],
+    // colorScaleValueRange: [0, 6500],
     colorsBasedOnValues: undefined,
     colorClasses: undefined,
     alpha: 100,
+    maxGlazeAlpha: 128,
     nullColor: [0, 0, 0, 0],
     unidentifiedColor: [0, 0, 0, 0],
     clippedColor: [0, 0, 0, 0],
@@ -4555,6 +4919,11 @@ const DefaultGeoImageOptions = {
     hillshadeAzimuth: 315,
     hillshadeAltitude: 45,
     zFactor: 1,
+    useSwissRelief: false,
+    swissSlopeWeight: 0.5,
+    useReliefGlaze: false,
+    // --- Lighting control ---
+    disableLighting: false,
 };
 
 class Martini {
@@ -5241,6 +5610,11 @@ function scale(num, inMin, inMax, outMin, outMax) {
 }
 
 class BitmapGenerator {
+    /**
+     * Cache for Swiss relief color LUTs to avoid regenerating on every tile.
+     * Key: colorScale config + range, Value: pre-computed RGBA LUT
+     */
+    static _swissColorLUTCache = new Map();
     /**
      * Main entry point: Generates an ImageBitmap from raw raster data.
      */
@@ -5267,7 +5641,31 @@ class BitmapGenerator {
         // If planar support is added, this logic must be updated to handle both layouts correctly.
         const numAvailableChannels = optionsLocal.numOfChannels ??
             (rasters.length === 1 ? rasters[0].length / (width * height) : rasters.length);
-        if (optionsLocal.useChannelIndex == null) {
+        if (optionsLocal.useReliefGlaze) {
+            if (rasters.length >= 1) {
+                // Relief glaze: pure black/white overlay with variable alpha
+                imageData.data.set(this.getReliefGlazeRGBA(rasters, optionsLocal, size));
+            }
+            else {
+                // Missing relief mask: fill with transparent
+                const transparentData = new Uint8ClampedArray(size);
+                transparentData.fill(0);
+                imageData.data.set(transparentData);
+            }
+        }
+        else if (optionsLocal.useSwissRelief) {
+            if (rasters.length === 2) {
+                // Normal Swiss relief rendering: hypsometric color × relief mask
+                imageData.data.set(this.getColorValue(rasters, optionsLocal, size));
+            }
+            else { // Missing mask: fill with null color (fully transparent or a fallback)
+                const defaultColorData = this.getDefaultColor(size, optionsLocal.nullColor);
+                defaultColorData.forEach((value, index) => {
+                    imageData.data[index] = value;
+                });
+            }
+        }
+        else if (optionsLocal.useChannelIndex == null) {
             if (isInterleaved) {
                 const ratio = rasters[0].length / (width * height);
                 if (ratio === 1) {
@@ -5335,9 +5733,68 @@ class BitmapGenerator {
         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
+        const isMultiRaster = Array.isArray(dataArray);
+        const primaryBuffer = isMultiRaster ? dataArray[0] : dataArray;
+        const isSwiss = options.useSwissRelief && isMultiRaster && dataArray.length >= 2;
+        const is8Bit = primaryBuffer instanceof Uint8Array || primaryBuffer instanceof Uint8ClampedArray;
+        const isFloatOrWide = !is8Bit && (primaryBuffer instanceof Float32Array || primaryBuffer instanceof Uint16Array || primaryBuffer instanceof Int16Array);
+        // 1. SWISS MODE BRANCH
+        if (isSwiss) {
+            const reliefMask = dataArray[1];
+            const rangeSpan = (rangeMax - rangeMin) || 1;
+            // Only use LUT optimization for useHeatMap mode; other modes use calculateSingleColor per-pixel
+            let lut = null;
+            if (options.useHeatMap) {
+                const LUT_SIZE = 1024;
+                // Cache LUT: generate key from colorScale config + range + alpha
+                const cacheKey = `${rangeMin}_${rangeMax}_${optAlpha}_${JSON.stringify(options.colorScale)}`;
+                lut = this._swissColorLUTCache.get(cacheKey) || null;
+                if (!lut) {
+                    // LUT not cached, generate it
+                    lut = new Uint8ClampedArray(LUT_SIZE * 4);
+                    for (let i = 0; i < LUT_SIZE; i++) {
+                        const domainVal = rangeMin + (i / (LUT_SIZE - 1)) * rangeSpan;
+                        const rgb = colorScale(domainVal).rgb();
+                        lut[i * 4] = rgb[0];
+                        lut[i * 4 + 1] = rgb[1];
+                        lut[i * 4 + 2] = rgb[2];
+                        lut[i * 4 + 3] = optAlpha;
+                    }
+                    this._swissColorLUTCache.set(cacheKey, lut);
+                }
+            }
+            for (let i = 0, sampleIndex = (options.useChannelIndex ?? 0); i < arrayLength; i += 4, sampleIndex += samplesPerPixel) {
+                const elevationVal = primaryBuffer[sampleIndex];
+                // NaN-aware noData check for Swiss relief
+                const isNoData = options.noDataValue !== undefined && (Number.isNaN(options.noDataValue)
+                    ? Number.isNaN(elevationVal)
+                    : elevationVal === options.noDataValue);
+                if (Number.isNaN(elevationVal) || isNoData) {
+                    colorsArray.set(options.nullColor, i);
+                    continue;
+                }
+                let baseColor;
+                if (lut) {
+                    // LUT-optimized path for useHeatMap
+                    const t = (elevationVal - rangeMin) / rangeSpan;
+                    const lutIdx = Math.min(1023, Math.max(0, Math.floor(t * 1023))) * 4;
+                    baseColor = [lut[lutIdx], lut[lutIdx + 1], lut[lutIdx + 2], lut[lutIdx + 3]];
+                }
+                else {
+                    // Per-pixel calculation for useSingleColor, useColorClasses, useColorsBasedOnValues
+                    baseColor = this.calculateSingleColor(elevationVal, colorScale, options, optAlpha);
+                }
+                // Apply relief mask as multiplier (Ambient Fill approach)
+                const maskVal = reliefMask[sampleIndex];
+                const multiplier = 0.4 + 0.6 * (maskVal / 255);
+                colorsArray[i] = Math.floor(baseColor[0] * multiplier);
+                colorsArray[i + 1] = Math.floor(baseColor[1] * multiplier);
+                colorsArray[i + 2] = Math.floor(baseColor[2] * multiplier);
+                colorsArray[i + 3] = baseColor[3];
+            }
+            return colorsArray;
+        }
+        // 2. 8-BIT COMPREHENSIVE LUT
         // Single-band 8-bit (grayscale or indexed): use LUT for fast mapping
         if (is8Bit && !options.useDataForOpacity) {
             const lut = new Uint8ClampedArray(256 * 4);
@@ -5351,7 +5808,7 @@ class BitmapGenerator {
                 }
             }
             for (let i = 0, sampleIndex = (options.useChannelIndex ?? 0); i < arrayLength; i += 4, sampleIndex += samplesPerPixel) {
-                const lutIdx = dataArray[sampleIndex] * 4;
+                const lutIdx = primaryBuffer[sampleIndex] * 4;
                 colorsArray[i] = lut[lutIdx];
                 colorsArray[i + 1] = lut[lutIdx + 1];
                 colorsArray[i + 2] = lut[lutIdx + 2];
@@ -5359,7 +5816,7 @@ class BitmapGenerator {
             }
             return colorsArray;
         }
-        // 2. FLOAT / 16-BIT LUT (HEATMAP ONLY)
+        // 3. FLOAT / 16-BIT LUT (HEATMAP ONLY)
         if (isFloatOrWide && options.useHeatMap && !options.useDataForOpacity) {
             const LUT_SIZE = 1024;
             const lut = new Uint8ClampedArray(LUT_SIZE * 4);
@@ -5379,7 +5836,7 @@ class BitmapGenerator {
                 }
             }
             for (let i = 0, sampleIndex = (options.useChannelIndex ?? 0); i < arrayLength; i += 4, sampleIndex += samplesPerPixel) {
-                const val = dataArray[sampleIndex];
+                const val = primaryBuffer[sampleIndex];
                 if (this.isInvalid(val, options)) {
                     colorsArray.set(this.getInvalidColor(val, options), i);
                 }
@@ -5394,10 +5851,10 @@ class BitmapGenerator {
             }
             return colorsArray;
         }
-        // 3. FALLBACK LOOP (Categorical Float, Opacity, or Single Color)
+        // 4. FALLBACK LOOP (Categorical Float, Opacity, or Single Color)
         let sampleIndex = options.useChannelIndex ?? 0;
         for (let i = 0; i < arrayLength; i += 4) {
-            const val = dataArray[sampleIndex];
+            const val = primaryBuffer[sampleIndex];
             let color;
             if ((options.clipLow != null && val <= options.clipLow) || (options.clipHigh != null && val >= options.clipHigh)) {
                 color = options.clippedColor;
@@ -5413,6 +5870,50 @@ class BitmapGenerator {
         }
         return colorsArray;
     }
+    /**
+     * Generate relief glaze RGBA output.
+     * Maps relief mask (0-255) to pure black/white glaze with variable alpha.
+     * - reliefValue < 128: Pure black (0,0,0) darkens shadows
+     * - reliefValue > 128: Pure white (255,255,255) brightens highlights
+     * - reliefValue == 128: Transparent (no effect)
+     *
+     * High-performance implementation using pre-computed alpha LUT to avoid 65k Math.pow calls.
+     *
+     * @param rasters Array of [relief mask raster] (single raster expected)
+     * @param options GeoImageOptions (alpha used for opacity scaling)
+     * @param arrayLength Total RGBA array length
+     * @returns Uint8ClampedArray of RGBA values
+     */
+    static getReliefGlazeRGBA(rasters, options, arrayLength) {
+        const reliefMask = rasters[0];
+        const opacityFactor = (options.maxGlazeAlpha ?? 128) / 255;
+        // Pre-compute alpha lookup table (256 entries, one per relief value 0-255)
+        const alphaLookup = new Uint8Array(256);
+        for (let v = 0; v < 256; v++) {
+            if (v === 0) {
+                alphaLookup[v] = 0; // noData: fully transparent
+            }
+            else {
+                const alphaDist = Math.abs(v - 128) / 128;
+                const bias = v < 128 ? 0.6 : 0.8;
+                alphaLookup[v] = Math.floor(Math.pow(alphaDist, bias) * 255 * opacityFactor);
+            }
+        }
+        const glazeArray = new Uint8ClampedArray(arrayLength);
+        let maskIndex = 0;
+        for (let i = 0; i < arrayLength; i += 4) {
+            const reliefValue = reliefMask[maskIndex];
+            // Pure black for shadows, pure white for highlights (no muddy grays)
+            const glaze = reliefValue < 128 ? 0 : 255;
+            const alpha = alphaLookup[reliefValue];
+            glazeArray[i] = glaze; // R
+            glazeArray[i + 1] = glaze; // G
+            glazeArray[i + 2] = glaze; // B
+            glazeArray[i + 3] = alpha; // A
+            maskIndex++;
+        }
+        return glazeArray;
+    }
     static calculateSingleColor(val, colorScale, options, alpha) {
         if (this.isInvalid(val, options)) {
             return options.nullColor;
@@ -5493,6 +5994,21 @@ class BitmapGenerator {
  * Output: Float32Array of 256×256 computed values.
  */
 class KernelGenerator {
+    /**
+     * Compute terrain gradients (dzdx, dzdy) using Horn's method.
+     * @param z1-z9 - 3×3 neighborhood elevation values (z5 is center)
+     * @param cellSizeFactor - Pre-computed 1 / (8 * cellSize)
+     * @param geographicConvention - If true, use north-minus-south for dzdy (hillshade). If false, use south-minus-north (slope).
+     */
+    static computeGradients(z1, z2, z3, z4, /* z5 not needed */ z6, z7, z8, z9, cellSizeFactor, geographicConvention = true) {
+        const dzdx = ((z3 + 2 * z6 + z9) - (z1 + 2 * z4 + z7)) * cellSizeFactor;
+        // Geographic convention (hillshade): north minus south (top rows minus bottom rows)
+        // Slope convention: south minus north (reversed)
+        const dzdy = geographicConvention
+            ? ((z1 + 2 * z2 + z3) - (z7 + 2 * z8 + z9)) * cellSizeFactor
+            : ((z7 + 2 * z8 + z9) - (z1 + 2 * z2 + z3)) * cellSizeFactor;
+        return { dzdx, dzdy };
+    }
     /**
      * Calculates slope (0–90 degrees) for each pixel using Horn's method.
      *
@@ -5505,12 +6021,18 @@ class KernelGenerator {
         const OUT = 256;
         const IN = 258;
         const out = new Float32Array(OUT * OUT);
+        // Hoist division out of loop: multiplication is ~2-3x faster than division
+        const cellSizeFactor = 1 / (8 * cellSize);
+        // Cache constant for radians to degrees conversion
+        const RAD_TO_DEG = 180 / Math.PI;
+        const isNaNNoData = noDataValue !== undefined && Number.isNaN(noDataValue);
         for (let r = 0; r < OUT; r++) {
             for (let c = 0; c < OUT; c++) {
                 // 3×3 neighborhood in the 258×258 input, centered at (r+1, c+1)
                 const base = r * IN + c;
                 const z5 = src[base + IN + 1]; // center pixel
-                if (noDataValue !== undefined && z5 === noDataValue) {
+                const isNoData = noDataValue !== undefined && (isNaNNoData ? Number.isNaN(z5) : z5 === noDataValue);
+                if (isNoData) {
                     out[r * OUT + c] = NaN;
                     continue;
                 }
@@ -5522,10 +6044,9 @@ class KernelGenerator {
                 const z7 = src[base + 2 * IN]; // sw
                 const z8 = src[base + 2 * IN + 1]; // s
                 const z9 = src[base + 2 * IN + 2]; // se
-                const dzdx = ((z3 + 2 * z6 + z9) - (z1 + 2 * z4 + z7)) / (8 * cellSize);
-                const dzdy = ((z7 + 2 * z8 + z9) - (z1 + 2 * z2 + z3)) / (8 * cellSize);
+                const { dzdx, dzdy } = this.computeGradients(z1, z2, z3, z4, z6, z7, z8, z9, cellSizeFactor, false);
                 const slopeRad = Math.atan(zFactor * Math.sqrt(dzdx * dzdx + dzdy * dzdy));
-                out[r * OUT + c] = slopeRad * (180 / Math.PI);
+                out[r * OUT + c] = slopeRad * RAD_TO_DEG;
             }
         }
         return out;
@@ -5550,11 +6071,15 @@ class KernelGenerator {
         if (azimuthMath >= 360)
             azimuthMath -= 360;
         const azimuthRad = azimuthMath * (Math.PI / 180);
+        // Hoist division out of loop: multiplication is ~2-3x faster than division
+        const cellSizeFactor = 1 / (8 * cellSize);
+        const isNaNNoData = noDataValue !== undefined && Number.isNaN(noDataValue);
         for (let r = 0; r < OUT; r++) {
             for (let c = 0; c < OUT; c++) {
                 const base = r * IN + c;
                 const z5 = src[base + IN + 1]; // center pixel
-                if (noDataValue !== undefined && z5 === noDataValue) {
+                const isNoData = noDataValue !== undefined && (isNaNNoData ? Number.isNaN(z5) : z5 === noDataValue);
+                if (isNoData) {
                     out[r * OUT + c] = NaN;
                     continue;
                 }
@@ -5566,9 +6091,7 @@ class KernelGenerator {
                 const z7 = src[base + 2 * IN]; // sw
                 const z8 = src[base + 2 * IN + 1]; // s
                 const z9 = src[base + 2 * IN + 2]; // se
-                const dzdx = ((z3 + 2 * z6 + z9) - (z1 + 2 * z4 + z7)) / (8 * cellSize);
-                // dzdy: north minus south (geographic convention — top rows minus bottom rows in raster)
-                const dzdy = ((z1 + 2 * z2 + z3) - (z7 + 2 * z8 + z9)) / (8 * cellSize);
+                const { dzdx, dzdy } = this.computeGradients(z1, z2, z3, z4, z6, z7, z8, z9, cellSizeFactor, true);
                 const slopeRad = Math.atan(zFactor * Math.sqrt(dzdx * dzdx + dzdy * dzdy));
                 const aspectRad = Math.atan2(dzdy, -dzdx);
                 const hillshade = 255 * (Math.cos(zenithRad) * Math.cos(slopeRad) +
@@ -5578,6 +6101,139 @@ class KernelGenerator {
         }
         return out;
     }
+    /**
+     * Calculates a weighted multi-directional hillshade (0–255).
+     * Combines three light sources to reveal structure in shadows.
+     */
+    static calculateMultiHillshade(src, cellSize, zFactor = 1, noDataValue) {
+        const OUT = 256;
+        const IN = 258;
+        const out = new Float32Array(OUT * OUT);
+        // Hoist division out of loop: multiplication is ~2-3x faster than division
+        const cellSizeFactor = 1 / (8 * cellSize);
+        const isNaNNoData = noDataValue !== undefined && Number.isNaN(noDataValue);
+        // Setup 3 light sources: NW (Main), W (Fill), N (Fill)
+        const lights = [
+            { az: 315, alt: 45, weight: 0.60 }, // Primary NW
+            { az: 225, alt: 35, weight: 0.25 }, // Secondary West/SW
+            { az: 0, alt: 35, weight: 0.15 } // Secondary North
+        ].map(l => {
+            const zenithRad = (90 - l.alt) * (Math.PI / 180);
+            let azMath = 360 - l.az + 90;
+            if (azMath >= 360)
+                azMath -= 360;
+            return {
+                zCos: Math.cos(zenithRad),
+                zSin: Math.sin(zenithRad),
+                aRad: azMath * (Math.PI / 180),
+                w: l.weight
+            };
+        });
+        for (let r = 0; r < OUT; r++) {
+            for (let c = 0; c < OUT; c++) {
+                const base = r * IN + c;
+                const z5 = src[base + IN + 1];
+                const isNoData = noDataValue !== undefined && (isNaNNoData ? Number.isNaN(z5) : z5 === noDataValue);
+                if (isNoData) {
+                    out[r * OUT + c] = NaN;
+                    continue;
+                }
+                // Neighbors
+                const z1 = src[base], z2 = src[base + 1], z3 = src[base + 2];
+                const z4 = src[base + IN], z6 = src[base + IN + 2];
+                const z7 = src[base + 2 * IN], z8 = src[base + 2 * IN + 1], z9 = src[base + 2 * IN + 2];
+                const { dzdx, dzdy } = this.computeGradients(z1, z2, z3, z4, z6, z7, z8, z9, cellSizeFactor, true);
+                const slopeRad = Math.atan(zFactor * Math.sqrt(dzdx * dzdx + dzdy * dzdy));
+                const aspectRad = Math.atan2(dzdy, -dzdx);
+                const cosSlope = Math.cos(slopeRad);
+                const sinSlope = Math.sin(slopeRad);
+                // Accumulate light from all three directions
+                let multiHillshade = 0;
+                for (const L of lights) {
+                    const intensity = L.zCos * cosSlope + L.zSin * sinSlope * Math.cos(L.aRad - aspectRad);
+                    multiHillshade += Math.max(0, intensity) * L.w;
+                }
+                out[r * OUT + c] = Math.min(255, multiHillshade * 255);
+            }
+        }
+        return out;
+    }
+}
+
+/**
+ * Composes Swiss relief by combining slope and hillshade kernels via LUT.
+ * Outputs a single 0-255 relief mask suitable for baking into hypsometry (terrain)
+ * or creating transparent glaze overlays (bitmap).
+ */
+class ReliefCompositor {
+    /**
+     * Precompute and cache a 256x256 LUT for Swiss relief compositing.
+     * LUT[hillshade][slope] = (hillshade * (1.0 - (slope * weight)))
+     * All values normalized to [0,1].
+     * Only computed on first use of Swiss relief mode.
+     */
+    static _swissReliefLUT = null;
+    static _lastWeight = null;
+    static getSwissReliefLUT(weight = 0.5) {
+        // Check if LUT exists AND if the weight matches the previous calculation
+        if (this._swissReliefLUT && this._lastWeight === weight) {
+            return this._swissReliefLUT;
+        }
+        const ambient = 0.010; // 1% minimum brightness to prevent pitch black northwest slopes
+        const lut = new Float32Array(256 * 256); // 65536 values
+        for (let h = 0; h < 256; h++) {
+            const hillshade = h / 255;
+            for (let s = 0; s < 256; s++) {
+                const slope = s / 255;
+                // 1. Calculate the 'Swiss Contrast'
+                const contrast = 1.0 - (slope * weight);
+                // Swiss Formula: (Hillshade) * (1.0 - (Slope * Weight))
+                // This results in 0.0 to 1.0 multiplier
+                lut[(h << 8) | s] = Math.max(ambient, hillshade * contrast);
+            }
+        }
+        this._swissReliefLUT = lut;
+        this._lastWeight = weight;
+        return lut;
+    }
+    /**
+     * Compute Swiss relief compositing: slope + hillshade → 0-255 relief mask.
+     *
+     * @param elevation - Padded elevation raster (258×258 for kernel input)
+     * @param options - GeoImageOptions (must include zFactor, noDataValue, swissSlopeWeight)
+     * @param cellSize - Grid cell size in meters
+     * @param width - Output width (typically 256)
+     * @param height - Output height (typically 256)
+     * @returns Uint8ClampedArray of 0-255 relief values
+     */
+    static composeSwissRelief(elevation, options, cellSize, width, height) {
+        const weight = options.swissSlopeWeight ?? 0.5;
+        // 1. Compute slope and hillshade kernels
+        const rawSlope = KernelGenerator.calculateSlope(elevation, cellSize, options.zFactor ?? 1, options.noDataValue);
+        const rawHillshade = KernelGenerator.calculateMultiHillshade(elevation, cellSize, options.zFactor ?? 1, options.noDataValue);
+        // 2. Fetch pre-computed LUT
+        const lut = this.getSwissReliefLUT(weight);
+        // 3. Compose relief mask: quantize slope/hillshade, apply LUT
+        // reliefMask = 0 is reserved as noData sentinel → fully transparent in glaze output
+        const reliefMask = new Uint8ClampedArray(width * height);
+        // Hoist division out of loop: multiplication is faster than division
+        const SLOPE_SCALE = 255 / 90; // ~2.833...
+        for (let i = 0; i < width * height; i++) {
+            // noData pixels: slope is NaN (set by KernelGenerator when z5 === noDataValue)
+            if (isNaN(rawSlope[i])) {
+                reliefMask[i] = 0; // sentinel: transparent in glaze
+                continue;
+            }
+            // Quantize Slope: Normalize 0-90° to 0-255 integer (avoid division in loop)
+            const sIdx = Math.max(0, Math.min(255, (rawSlope[i] * SLOPE_SCALE) | 0));
+            // Quantize Hillshade: Ensure 0-255 integer
+            const hIdx = Math.max(0, Math.min(255, rawHillshade[i])) | 0;
+            // LUT Lookup: Result is 0.0 - 1.0 (float)
+            // Clamp to 1 to ensure output stays in 1-255 (0 is reserved for noData)
+            reliefMask[i] = Math.max(1, (lut[(hIdx << 8) | sIdx] * 255) | 0);
+        }
+        return reliefMask;
+    }
 }
 
 class TerrainGenerator {
@@ -5641,7 +6297,20 @@ class TerrainGenerator {
             height: gridHeight,
         };
         // 3. Kernel path: compute slope or hillshade, store as rawDerived, generate texture
-        if (isKernel && (options.useSlope || options.useHillshade)) {
+        if (isKernel && options.useSwissRelief) {
+            const cellSize = input.cellSizeMeters ?? ((input.bounds[2] - input.bounds[0]) / 256);
+            // Build a separate raster for kernel computation that preserves noData samples.
+            const kernelTerrain = this.preserveNoDataForKernel(terrain, input.rasters[0], options.noDataValue);
+            // Compose Swiss relief using ReliefCompositor
+            const swissReliefResult = ReliefCompositor.composeSwissRelief(kernelTerrain, options, cellSize, 256, 256);
+            tileResult.rawDerived = swissReliefResult;
+            if (this.hasVisualizationOptions(options)) {
+                const cropped = this.cropRaster(meshTerrain, gridWidth, gridHeight, 256, 256);
+                const bitmapResult = await BitmapGenerator.generate({ width: 256, height: 256, rasters: [cropped, swissReliefResult] }, { ...options, type: 'image' });
+                tileResult.texture = bitmapResult.map;
+            }
+        }
+        else if (isKernel && (options.useSlope || options.useHillshade)) {
             // Use pre-computed geographic cellSize (meters/pixel) from tile indices.
             // Falls back to bounds-derived estimate if not provided.
             const cellSize = input.cellSizeMeters ?? ((input.bounds[2] - input.bounds[0]) / 256);
@@ -5651,23 +6320,7 @@ class TerrainGenerator {
                 console.warn('[TerrainGenerator] useSlope and useHillshade are mutually exclusive; useSlope takes precedence.');
             }
             // Build a separate raster for kernel computation that preserves noData samples.
-            const kernelTerrain = new Float32Array(terrain.length);
-            const sourceRaster = input.rasters[0];
-            const noData = options.noDataValue;
-            if (noData !== undefined &&
-                noData !== null &&
-                sourceRaster &&
-                sourceRaster.length === terrain.length) {
-                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.
-                    kernelTerrain[i] = sourceRaster[i] == noData ? noData : terrain[i];
-                }
-            }
-            else {
-                // Fallback: no usable noData metadata or mismatched lengths; mirror existing behavior.
-                kernelTerrain.set(terrain);
-            }
+            const kernelTerrain = this.preserveNoDataForKernel(terrain, input.rasters[0], options.noDataValue);
             let kernelOutput;
             if (options.useSlope) {
                 kernelOutput = KernelGenerator.calculateSlope(kernelTerrain, cellSize, zFactor, options.noDataValue);
@@ -5689,7 +6342,6 @@ class TerrainGenerator {
         }
         return tileResult;
     }
-    /** Extracts rows 1–257, cols 1–257 from a 258×258 terrain array → 257×257 for mesh generation. */
     static extractMeshRaster(terrain258) {
         const MESH = 257;
         const IN = 258;
@@ -5702,11 +6354,38 @@ class TerrainGenerator {
         return out;
     }
     static hasVisualizationOptions(options) {
-        return !!(options.useHeatMap ||
-            options.useSingleColor ||
+        return !!(options.useSingleColor ||
+            options.useHeatMap ||
+            options.useSwissRelief ||
             options.useColorsBasedOnValues ||
             options.useColorClasses);
     }
+    /**
+     * Preserve noData values in a separate raster for kernel computation.
+     * If the source raster marks a sample as noData, keep it as noData.
+     * Otherwise, use the processed terrain elevation value.
+     */
+    static preserveNoDataForKernel(terrain, sourceRaster, noDataValue) {
+        const kernelTerrain = new Float32Array(terrain.length);
+        if (noDataValue !== undefined &&
+            noDataValue !== null &&
+            sourceRaster &&
+            sourceRaster.length === terrain.length) {
+            const preserveNaNNoData = Number.isNaN(noDataValue);
+            for (let i = 0; i < terrain.length; i++) {
+                const sourceValue = sourceRaster[i];
+                const isNoData = preserveNaNNoData
+                    ? Number.isNaN(sourceValue)
+                    : sourceValue === noDataValue;
+                kernelTerrain[i] = isNoData ? noDataValue : terrain[i];
+            }
+        }
+        else {
+            // Fallback: no usable noData metadata or mismatched lengths; mirror existing behavior.
+            kernelTerrain.set(terrain);
+        }
+        return kernelTerrain;
+    }
     static cropRaster(src, srcWidth, _srcHeight, dstWidth, dstHeight) {
         const out = new Float32Array(dstWidth * dstHeight);
         for (let y = 0; y < dstHeight; y++) {
@@ -5906,36 +6585,57 @@ class CogTiles {
     bounds = [0, 0, 0, 0];
     geo = new GeoImage();
     options;
+    // Cache GeoTIFFImage Promises by index to prevent redundant HTTP requests from geotiff 3.0.4+ eager loading
+    // Stores Promises (not resolved values) so concurrent requests share the same getImage() call
+    imageCache = new Map();
+    // Store initialization promise to prevent concurrent duplicate initializations
+    initializePromise;
     constructor(options) {
         this.options = { ...CogTilesGeoImageOptionsDefaults, ...options };
     }
     async initializeCog(url) {
+        // Return existing initialization promise if already in progress (prevents concurrent duplicates)
+        if (this.initializePromise)
+            return this.initializePromise;
         if (this.cog)
-            return; // Prevent re-initialization on the same instance
-        try {
-            this.cog = await fromUrl(url);
-            const image = await this.cog.getImage();
-            const fileDirectory = image.fileDirectory;
-            this.cogOrigin = image.getOrigin();
-            this.options.noDataValue ??= await this.getNoDataValue(image);
-            this.options.format ??= await this.getDataTypeFromTags(fileDirectory);
-            this.options.numOfChannels = fileDirectory.getValue('SamplesPerPixel');
-            this.options.planarConfig = fileDirectory.getValue('PlanarConfiguration');
-            [this.cogZoomLookup, this.cogResolutionLookup] = await this.buildCogZoomResolutionLookup(this.cog);
-            this.tileSize = image.getTileWidth();
-            // 1. Validation: Ensure the image is tiled
-            if (!this.tileSize || !image.getTileHeight()) {
-                throw new Error('GeoTIFF Error: The provided image is not tiled. '
-                    + 'Please use "rio cogeo create --web-optimized" to fix this.');
-            }
-            this.zoomRange = this.calculateZoomRange(this.tileSize, image.getResolution()[0], await this.cog.getImageCount());
-            this.bounds = this.calculateBoundsAsLatLon(image.getBoundingBox());
-        }
-        catch (error) {
-            /* eslint-disable no-console */
-            console.error(`[CogTiles] Failed to initialize COG from ${url}:`, error);
-            throw error;
-        }
+            return;
+        this.initializePromise = (async () => {
+            try {
+                // fromUrl's type declaration only exposes RemoteSourceOptions, but the implementation
+                // also accepts BlockedSourceOptions (forwarded to makeFetchSource internally).
+                // Explicitly enabling BlockedSource restores the block-level LRU cache that was
+                // accidentally active in geotiff 3.0.3 (due to a null vs undefined bug there).
+                // blockSize defaults to 65536 (64KB) and can be tuned via GeoImageOptions.
+                const blockSize = this.options.blockSize ?? 65536;
+                this.cog = await fromUrl(url, { blockSize });
+                const imagePromise = this.cog.getImage();
+                this.imageCache.set(0, imagePromise); // Cache base image (index 0) to avoid re-fetching during getTileFromImage
+                const image = await imagePromise;
+                const fileDirectory = image.fileDirectory;
+                this.cogOrigin = image.getOrigin();
+                this.options.noDataValue ??= await this.getNoDataValue(image);
+                this.options.format ??= await this.getDataTypeFromTags(fileDirectory);
+                this.options.numOfChannels = fileDirectory.getValue('SamplesPerPixel');
+                this.options.planarConfig = fileDirectory.getValue('PlanarConfiguration');
+                [this.cogZoomLookup, this.cogResolutionLookup] = await this.buildCogZoomResolutionLookup(this.cog);
+                this.tileSize = image.getTileWidth();
+                // 1. Validation: Ensure the image is tiled
+                if (!this.tileSize || !image.getTileHeight()) {
+                    throw new Error('GeoTIFF Error: The provided image is not tiled. '
+                        + 'Please use "rio cogeo create --web-optimized" to fix this.');
+                }
+                this.zoomRange = this.calculateZoomRange(this.tileSize, image.getResolution()[0], await this.cog.getImageCount());
+                this.bounds = this.calculateBoundsAsLatLon(image.getBoundingBox());
+            }
+            catch (error) {
+                // Reset initialization promise on error so retry can be attempted
+                this.initializePromise = undefined;
+                /* eslint-disable no-console */
+                console.error(`[CogTiles] Failed to initialize COG from ${url}:`, error);
+                throw error;
+            }
+        })();
+        return this.initializePromise;
     }
     getZoomRange() {
         return this.zoomRange;
@@ -6040,7 +6740,13 @@ class CogTiles {
     }
     async getTileFromImage(tileX, tileY, zoom, fetchSize) {
         const imageIndex = this.getImageIndexForZoomLevel(zoom);
-        const targetImage = await this.cog.getImage(imageIndex);
+        // Cache Promises to share in-flight requests across concurrent tiles at the same overview
+        let imagePromise = this.imageCache.get(imageIndex);
+        if (!imagePromise) {
+            imagePromise = this.cog.getImage(imageIndex);
+            this.imageCache.set(imageIndex, imagePromise);
+        }
+        const targetImage = await imagePromise;
         // --- STEP 1: CALCULATE BOUNDS IN METERS ---
         // 2. Get COG Metadata (image = COG)
         const imageResolution = this.cogResolutionLookup[imageIndex];
@@ -6157,19 +6863,37 @@ class CogTiles {
     async getTile(x, y, z, bounds, meshMaxError) {
         let requiredSize = this.tileSize; // Default 256 for image/bitmap
         if (this.options.type === 'terrain') {
-            const isKernel = this.options.useSlope || this.options.useHillshade;
+            const isKernel = this.options.useSlope || this.options.useHillshade || this.options.useSwissRelief;
             requiredSize = this.tileSize + (isKernel ? 2 : 1); // 258 for kernel (3×3 border), 257 for normal stitching
         }
+        else if (this.options.type === 'image' && this.options.useReliefGlaze) {
+            // Bitmap layer with relief glaze mode needs kernel padding for slope/hillshade computation
+            requiredSize = this.tileSize + 2; // 258 for kernel
+        }
         const tileData = await this.getTileFromImage(x, y, z, requiredSize);
         // Compute true ground cell size in meters from tile indices.
         // Tile y in slippy-map convention → center latitude → Web Mercator distortion correction.
         const latRad = Math.atan(Math.sinh(Math.PI * (1 - 2 * (y + 0.5) / Math.pow(2, z))));
         const tileWidthMeters = (EARTH_CIRCUMFERENCE / Math.pow(2, z)) * Math.cos(latRad);
         const cellSizeMeters = tileWidthMeters / this.tileSize;
+        let rasters = [tileData[0]];
+        let tileWidth = requiredSize;
+        let tileHeight = requiredSize;
+        // Relief glaze computation for bitmap layers
+        // Note: For multi-band support (band selection via useChannelIndex), see issue #98
+        if (this.options.type === 'image' && this.options.useReliefGlaze) {
+            const elevation = tileData[0];
+            // Pass full 258×258 padded elevation directly — KernelGenerator expects IN=258 and outputs 256×256
+            const reliefMask = ReliefCompositor.composeSwissRelief(elevation, this.options, cellSizeMeters, this.tileSize, this.tileSize);
+            // For glaze-only mode, pass ONLY the 256×256 relief mask
+            rasters = [reliefMask];
+            tileWidth = this.tileSize;
+            tileHeight = this.tileSize;
+        }
         return this.geo.getMap({
-            rasters: [tileData[0]],
-            width: requiredSize,
-            height: requiredSize,
+            rasters,
+            width: tileWidth,
+            height: tileHeight,
             bounds,
             cellSizeMeters,
         }, this.options, meshMaxError);
@@ -6382,13 +7106,20 @@ class CogBitmapLayer extends CompositeLayer {
         }
     }
     async getTiledBitmapData(tile) {
-        // TODO - pass signal to getTile
-        // abort request if signal is aborted
-        const tileData = await this.state.bitmapCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z);
-        if (tileData && !this.props.pickable) {
-            tileData.raw = null;
+        try {
+            // TODO - pass signal to getTile
+            // abort request if signal is aborted
+            const tileData = await this.state.bitmapCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z);
+            if (tileData && !this.props.pickable) {
+                tileData.raw = null;
+            }
+            return tileData;
+        }
+        catch (error) {
+            // Log the error and rethrow so TileLayer can surface the failure via onTileError
+            log.warn(`Failed to load bitmap tile at ${tile.index.z}/${tile.index.x}/${tile.index.y}:`, error)();
+            throw error;
         }
-        return tileData;
     }
     renderSubLayers(props) {
         const SubLayerClass = this.getSubLayerClass('image', BitmapLayer);
@@ -6531,11 +7262,21 @@ class CogTerrainLayer extends CompositeLayer {
     terrainUrl = '';
     async initializeState(context) {
         super.initializeState(context);
+        const terrainCogTiles = this.props.cogTiles || new CogTiles(this.props.terrainOptions);
         this.setState({
-            terrainCogTiles: this.props.cogTiles || new CogTiles(this.props.terrainOptions),
+            terrainCogTiles,
             initialized: false,
         });
-        await this.init(this.terrainUrl);
+        // Only initialize if not already done (e.g., provided cogTiles instance may be pre-initialized)
+        if (!terrainCogTiles.cog) {
+            await this.init();
+        }
+        else {
+            // CogTiles already initialized; just extract zoom range and mark ready
+            const zoomRange = terrainCogTiles.getZoomRange();
+            const [minZoom, maxZoom] = zoomRange;
+            this.setState({ initialized: true, minZoom, maxZoom });
+        }
     }
     async init() {
         await this.state.terrainCogTiles.initializeCog(this.props.elevationData);
@@ -6621,15 +7362,28 @@ class CogTerrainLayer extends CompositeLayer {
     }
     renderSubLayers(props) {
         const SubLayerClass = this.getSubLayerClass('mesh', SimpleMeshLayer);
-        const { color, wireframe, material } = this.props;
+        const { color, wireframe, terrainOptions } = this.props;
         const { data } = props;
         if (!data) {
             return null;
         }
-        // const [mesh, texture] = data;
         const [meshResult] = data;
         const tileTexture = (!this.props.disableTexture && meshResult?.texture) ? meshResult.texture : null;
+        const isSwiss = terrainOptions?.useSwissRelief;
+        const disableLighting = terrainOptions?.disableLighting;
+        const shouldDisableLighting = isSwiss || disableLighting;
+        const lightingProps = shouldDisableLighting ? {
+            material: {
+                ambient: 1.0,
+                diffuse: 0.0,
+                shininess: 0.0,
+                specularColor: [0, 0, 0]
+            }
+        } : {
+            material: this.props.material
+        };
         return new SubLayerClass({ ...props, tileSize: props.tileSize }, {
+            ...lightingProps,
             data: DUMMY_DATA,
             mesh: meshResult?.map,
             texture: tileTexture,
@@ -6639,7 +7393,6 @@ class CogTerrainLayer extends CompositeLayer {
             // getPosition: (d) => [0, 0, 0],
             getColor: tileTexture ? [255, 255, 255] : color,
             wireframe,
-            material,
         });
     }
     // Update zRange of viewport
@@ -6686,13 +7439,14 @@ class CogTerrainLayer extends CompositeLayer {
                 updateTriggers: {
                     getTileData: {
                         elevationData: urlTemplateToUpdateTrigger(elevationData),
-                        // texture: urlTemplateToUpdateTrigger(texture),
                         meshMaxError,
                         elevationDecoder,
-                        // When cogTiles instance is swapped (e.g. mode switch), refetch tiles.
-                        // deck.gl keeps old tile content visible until new tiles are ready.
                         terrainCogTiles: this.state.terrainCogTiles,
                     },
+                    renderSubLayers: {
+                        disableTexture: this.props.disableTexture,
+                        terrainOptions: this.props.terrainOptions,
+                    },
                 },
                 onViewportLoad: this.onViewportLoad.bind(this),
                 zRange: this.state.zRange || null,
@@ -6714,6 +7468,7 @@ class CogTerrainLayer extends CompositeLayer {
 }
 
 class RawDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         return buffer;
     }
@@ -6728,6 +7483,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);
@@ -6755,12 +7516,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);
@@ -6775,17 +7545,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]) {
@@ -6820,10 +7596,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}`);
@@ -6846,6 +7627,7 @@ function decompress(input) {
     return new Uint8Array(result);
 }
 class LZWDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         return decompress(buffer).buffer;
     }
@@ -6904,6 +7686,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
@@ -6953,8 +7762,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;
@@ -6975,20 +7801,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;
@@ -7002,6 +7834,7 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
         }
         return n;
     }
+    /** @param {number} length */
     function receiveAndExtend(length) {
         const n = receive(length);
         if (n === undefined) {
@@ -7012,9 +7845,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;
@@ -7034,25 +7880,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--;
@@ -7091,7 +7963,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;
@@ -7125,7 +8002,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
@@ -7133,7 +8014,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--;
@@ -7144,7 +8029,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;
@@ -7153,7 +8042,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;
             }
@@ -7166,16 +8059,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;
@@ -7252,9 +8163,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);
@@ -7263,8 +8180,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;
@@ -7443,14 +8368,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;
@@ -7465,6 +8397,7 @@ class JpegStreamReader {
             offset += array.length;
             return array;
         }
+        /** @param {JpegFrame} frame */
         function prepareComponents(frame) {
             let maxH = 0;
             let maxV = 0;
@@ -7591,15 +8524,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;
@@ -7615,6 +8554,9 @@ class JpegStreamReader {
                             h,
                             v,
                             quantizationIdx: qId,
+                            blocksPerLine: 0,
+                            blocksPerColumn: 0,
+                            blocks: [],
                         };
                         offset += 3;
                     }
@@ -7699,11 +8641,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;
@@ -7711,7 +8659,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,
             });
@@ -7731,6 +8679,9 @@ class JpegStreamReader {
     }
 }
 class JpegDecoder extends BaseDecoder {
+    /**
+     * @param {import('./basedecoder.js').BaseDecoderParameters & { JPEGTables?: Uint8Array }} parameters
+     */
     constructor(parameters) {
         super(parameters);
         this.reader = new JpegStreamReader();
@@ -7738,6 +8689,7 @@ class JpegDecoder extends BaseDecoder {
             this.reader.parse(parameters.JPEGTables);
         }
     }
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         this.reader.resetFrames();
         this.reader.parse(new Uint8Array(buffer));
@@ -10986,6 +11938,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;
     }
@@ -10997,6 +11950,7 @@ var deflate = /*#__PURE__*/Object.freeze({
 });
 
 class PackbitsDecoder extends BaseDecoder {
+    /** @param {ArrayBuffer} buffer */
     decodeBlock(buffer) {
         const dataView = new DataView(buffer);
         const out = [];
@@ -13444,23 +14398,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;
     }
@@ -13636,8 +14600,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);
     }
 }
 
@@ -13654,6 +14619,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') {
@@ -13663,6 +14631,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);