geotiff 3.0.2 → 3.0.4-beta.0

package/dist-node/geotiffimage.d.ts

@@ -13,7 +13,8 @@ declare class GeoTIFFImage {
     constructor(fileDirectory: import("./imagefiledirectory").ImageFileDirectory, littleEndian: boolean, cache: boolean, source: import("./source/basesource.js").BaseSource);
     fileDirectory: import("./imagefiledirectory").ImageFileDirectory;
     littleEndian: boolean;
-    tiles: {} | null;
+    /** @type {Array<Promise<ArrayBufferLike>>|null} */
+    tiles: Array<Promise<ArrayBufferLike>> | null;
     isTiled: boolean;
     /** @type {1 | 2} */
     planarConfiguration: 1 | 2;
@@ -54,18 +55,35 @@ declare class GeoTIFFImage {
      */
     getTileHeight(): number;
     getBlockWidth(): number;
-    getBlockHeight(y: any): number;
+    /**
+     * @param {number} y
+     * @returns {number}
+     */
+    getBlockHeight(y: number): number;
     /**
      * Calculates the number of bytes for each pixel across all samples. Only full
      * bytes are supported, an exception is thrown when this is not the case.
      * @returns {Number} the bytes per pixel
      */
     getBytesPerPixel(): number;
-    getSampleByteSize(i: any): number;
-    getReaderForSample(sampleIndex: any): (byteOffset: number, littleEndian?: boolean) => number;
-    getSampleFormat(sampleIndex?: number): any;
-    getBitsPerSample(sampleIndex?: number): any;
-    getArrayForSample(sampleIndex: any, size: any): Uint8Array<any> | Uint16Array<any> | Uint32Array<any> | Int8Array<any> | Int16Array<any> | Int32Array<any> | Float32Array<any> | Float64Array<any>;
+    /**
+     * @param {number} i
+     * @returns {number}
+     */
+    getSampleByteSize(i: number): number;
+    /**
+     * @param {number} sampleIndex
+     * @returns {(this: DataView, byteOffset: number, littleEndian: boolean) => number}
+     */
+    getReaderForSample(sampleIndex: number): (this: DataView, byteOffset: number, littleEndian: boolean) => number;
+    getSampleFormat(sampleIndex?: number): number;
+    getBitsPerSample(sampleIndex?: number): number;
+    /**
+     * @param {number} sampleIndex
+     * @param {number|ArrayBufferLike} sizeOrData
+     * @returns {TypedArray}
+     */
+    getArrayForSample(sampleIndex: number, sizeOrData: number | ArrayBufferLike): TypedArray;
     /**
      * Returns the decoded strip or tile.
      * @param {Number} x the strip or tile x-offset
@@ -74,19 +92,19 @@ declare class GeoTIFFImage {
      * @param {DecoderWorker|import("./geotiff").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
      */
     getTileOrStrip(x: number, y: number, sample: number, poolOrDecoder: DecoderWorker | import("./geotiff").BaseDecoder, signal?: AbortSignal): Promise<{
         x: number;
         y: number;
         sample: number;
-        data: ArrayBuffer;
+        data: ArrayBufferLike;
     }>;
     /**
      * 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
@@ -160,9 +178,16 @@ declare class GeoTIFFImage {
     readRGB(options?: ReadRGBOptions | undefined): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
     /**
      * 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
      */
-    getTiePoints(): Promise<any[]>;
+    getTiePoints(): Promise<Array<{
+        i: number;
+        j: number;
+        k: number;
+        x: number;
+        y: number;
+        z: number;
+    }>>;
     /**
      * Returns the parsed GDAL metadata items.
      *
@@ -170,9 +195,9 @@ declare 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
      */
-    getGDALMetadata(sample?: number | null): Promise<any>;
+    getGDALMetadata(sample?: number | null): Promise<Record<string, unknown> | null>;
     /**
      * Returns the GDAL nodata value
      * @returns {number|null}
@@ -208,6 +233,7 @@ declare class GeoTIFFImage {
      */
     getBoundingBox(tilegrid?: boolean): Array<number>;
 }
+import type { TypedArray } from "./geotiff";
 import type { DecoderWorker } from "./geotiff";
 import type { ReadRastersOptions } from "./geotiff";
 import type { ReadRasterResult } from "./geotiff";

package/dist-node/geotiffimage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geotiffimage.d.ts","sourceRoot":"","sources":["../dist-module/geotiffimage.js"],"names":[],"mappings":";AAkJA;;GAEG;AACH;IACI;;;;;;OAMG;IACH,2BALW,OAAO,sBAAsB,EAAE,kBAAkB,iDAGjD,OAAO,wBAAwB,EAAE,UAAU,EAcrD;IAXG,iEAAkC;IAClC,sBAAgC;IAChC,iBAA8B;IAC9B,iBAAoD;IAKpD,oBAAoB;IACpB,qBADW,CAAC,GAAG,CAAC,CAC8B;IAC9C,oDAAoB;IAExB;;;OAGG;IACH,oBAFa,OAAO,sBAAsB,EAAE,kBAAkB,CAI7D;IACD;;;OAGG;IACH,cAFa,OAAO,CAAC,MAAM,CAAC,OAAO,cAAc,EAAE,UAAU,EAAE,GAAC,CAAC,CAAC,GAAC,IAAI,CAItE;IACD;;;OAGG;IACH,mBAEC;IACD;;;OAGG;IACH,oBAEC;IACD;;;OAGG;IACH,6BAGC;IACD;;;OAGG;IACH,uBAEC;IACD;;;OAGG;IACH,wBAQC;IACD,wBAEC;IACD,+BAOC;IACD;;;;OAIG;IACH,2BAOC;IACD,kCAMC;IACD,6FA6CC;IACD,2CAGC;IACD,4CAEC;IACD,mMAIC;IACD;;;;;;;;;OASG;IACH,oEALW,aAAa,GAAC,OAAO,WAAW,EAAE,WAAW,WAC7C,WAAW,GAET,OAAO,CAAE;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,WAAW,CAAA;KAAC,CAAC,CA0D/E;IACD;;;;;;;;;;;;;;OAcG;IACH,oBAgGC;;;;;;IAEE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,IAAI,CAAA;KAAC,GACrC,OAAO,CAAC,OAAO,WAAW,EAAE,wBAAwB,CAAC,CACjE;;;;;;IAEE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,KAAK,CAAA;KAAC,GACtC,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IAEE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,OAAO,CAAA;KAAC,GACxC,OAAO,CAAC,gBAAgB,CAAC,CACrC;;;;;;IAEE,uDAEU,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IAsEE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,IAAI,CAAA;KAAC,GACjC,OAAO,CAAC,OAAO,WAAW,EAAE,wBAAwB,CAAC,CACjE;;;;;;IAEE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,KAAK,CAAA;KAAC,GAClC,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IAEE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,OAAO,CAAA;KAAC,GACpC,OAAO,CAAC,gBAAgB,CAAC,CACrC;;;;;;IAEE,+CAEU,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;IA+GD;;;OAGG;IACH,gBAFa,OAAO,CAAC,KAAQ,CAAC,CAmB7B;IACD;;;;;;;;OAQG;IACH,yBAHW,MAAM,GAAC,IAAI,GACT,OAAO,KAAQ,CAoB3B;IACD;;;OAGG;IACH,iBAFa,MAAM,GAAC,IAAI,CAQvB;IACD;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAoBzB;IACD;;;;;;;OAOG;IACH,+BALW,YAAY,GAAC,IAAI,GAGf,KAAK,CAAC,MAAM,CAAC,CAqCzB;IACD;;;OAGG;IACH,uBAEC;IACD;;;;;;;OAOG;IACH,0BAJW,OAAO,GAEL,KAAK,CAAC,MAAM,CAAC,CAyCzB;CACJ;mCAx3B4C,WAAW;wCAElB,WAAW;sCADb,WAAW;oCAEb,WAAW"}
+{"version":3,"file":"geotiffimage.d.ts","sourceRoot":"","sources":["../dist-module/geotiffimage.js"],"names":[],"mappings":"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"}

package/dist-node/geotiffimage.js

@@ -5,7 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 /** @module geotiffimage */
 const float16_1 = require("@petamoriken/float16");
+// @ts-expect-error
 const get_attribute_1 = __importDefault(require("xml-utils/get-attribute")); // eslint-disable-line import/extensions
+// @ts-expect-error
 const find_tags_by_name_1 = __importDefault(require("xml-utils/find-tags-by-name")); // eslint-disable-line import/extensions
 const globals_js_1 = require("./globals.js");
 const rgb_js_1 = require("./rgb.js");
@@ -15,6 +17,12 @@ const resample_js_1 = require("./resample.js");
 /** @import {ReadRasterResult} from "./geotiff" */
 /** @import {ReadRastersOptions} from "./geotiff" */
 /** @import {ReadRGBOptions} from "./geotiff" */
+/**
+ * @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) {
@@ -22,37 +30,46 @@ 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;
                 default:
                     break;
             }
@@ -60,8 +77,21 @@ function arrayForType(format, bitsPerSample, size) {
         default:
             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;
@@ -71,6 +101,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);
@@ -163,7 +203,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) {
@@ -192,29 +233,28 @@ 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
      */
     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
      */
     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.
@@ -222,16 +262,21 @@ class GeoTIFFImage {
      */
     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.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();
@@ -248,22 +293,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) {
@@ -307,16 +362,22 @@ 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.
@@ -326,7 +387,7 @@ class GeoTIFFImage {
      * @param {DecoderWorker|import("./geotiff").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());
@@ -345,12 +406,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();
@@ -366,7 +427,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));
@@ -388,8 +449,8 @@ 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
@@ -411,11 +472,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);
@@ -464,7 +531,7 @@ class GeoTIFFImage {
                                 }
                                 else {
                                     windowCoordinate = ((y + firstLine - imageWindow[1]) * windowWidth) + x + firstCol - imageWindow[0];
-                                    valueArrays[si][windowCoordinate] = value;
+                                    /** @type {TypedArray} */ (valueArrays[si])[windowCoordinate] = value;
                                 }
                             }
                         }
@@ -553,9 +620,14 @@ 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 format = fileDirectory.hasTag('SampleFormat')
+                ? Math.max.apply(null, Array.from(fileDirectory.getValue('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.hasTag('BitsPerSample')
+                ? Math.max.apply(null, Array.from(fileDirectory.getValue('BitsPerSample'))) : 8;
             valueArrays = arrayForType(format, bitsPerSample, numPixels * samples.length);
             if (fillValue) {
                 if (Array.isArray(fillValue)) {
@@ -626,9 +698,11 @@ class GeoTIFFImage {
         const pi = this.fileDirectory.getValue('PhotometricInterpretation');
         if (pi === globals_js_1.photometricInterpretations.RGB) {
             let s = [0, 1, 2];
-            if ((!(this.fileDirectory.getValue('ExtraSamples') === globals_js_1.ExtraSamplesValues.Unspecified)) && enableAlpha) {
+            const extraSamples = this.fileDirectory.getValue('ExtraSamples');
+            if (extraSamples && extraSamples[0] !== globals_js_1.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);
                 }
             }
@@ -683,7 +757,7 @@ class GeoTIFFImage {
                 data = (0, rgb_js_1.fromBlackIsZero)(raster, max);
                 break;
             case globals_js_1.photometricInterpretations.Palette:
-                data = (0, rgb_js_1.fromPalette)(raster, await fileDirectory.loadValue('ColorMap'));
+                data = (0, rgb_js_1.fromPalette)(raster, /** @type {Uint16Array} */ (await fileDirectory.loadValue('ColorMap')));
                 break;
             case globals_js_1.photometricInterpretations.CMYK:
                 data = (0, rgb_js_1.fromCMYK)(raster);
@@ -717,13 +791,16 @@ class GeoTIFFImage {
     }
     /**
      * 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({
@@ -744,14 +821,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 = (0, find_tags_by_name_1.default)(string, 'Item');
         if (sample === null) {
             items = items.filter((item) => (0, get_attribute_1.default)(item, 'sample') === undefined);
@@ -770,10 +849,10 @@ class GeoTIFFImage {
      * @returns {number|null}
      */
     getGDALNoData() {
-        if (!this.fileDirectory.hasTag('GDAL_NODATA')) {
+        const string = this.fileDirectory.getValue('GDAL_NODATA');
+        if (!string) {
             return null;
         }
-        const string = this.fileDirectory.getValue('GDAL_NODATA');
         return Number(string.substring(0, string.length - 1));
     }
     /**
@@ -862,9 +941,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],
@@ -901,4 +980,5 @@ class GeoTIFFImage {
     }
 }
 exports.default = GeoTIFFImage;
+//# sourceMappingURL=geotiffimage.js.map
 //# sourceMappingURL=geotiffimage.js.map