geotiff 3.0.0 → 3.0.2

package/dist-module/geotiffimage.d.ts

@@ -1,87 +1,33 @@
 export default GeoTIFFImage;
-export type ReadRasterOptions = {
-    /**
-     * window] the subset to read data from in pixels.
-     */
-    window?: number[] | undefined;
-    /**
-     * image] the subset to read data from in
-     *      geographical coordinates.
-     */
-    bbox?: number[] | undefined;
-    /**
-     * samples] the selection of samples to read from. Default is all samples.
-     */
-    samples?: number[] | undefined;
-    /**
-     * whether the data shall be read
-     *       in one single array or separate
-     *       arrays.
-     */
-    interleave?: boolean | undefined;
-    /**
-     * The optional decoder pool to use.
-     */
-    pool?: Pool;
-    /**
-     * The desired width of the output. When the width is not the
-     *       same as the images, resampling will be performed.
-     */
-    width?: number | undefined;
-    /**
-     * The desired height of the output. When the width is not the
-     *       same as the images, resampling will be performed.
-     */
-    height?: number | undefined;
-    /**
-     * The desired resampling method.
-     */
-    resampleMethod?: string | undefined;
-    /**
-     * An AbortSignal that may be signalled if the request is
-     *       to be aborted
-     */
-    signal?: AbortSignal | undefined;
-    /**
-     * The value to use for parts of the image
-     *       outside of the images extent. When multiple
-     *       samples are requested, an array of fill values
-     *       can be passed.
-     */
-    fillValue?: number | number[] | undefined;
-};
-export type TypedArray = import("./geotiff.js").TypedArray;
-export type ReadRasterResult = import("./geotiff.js").ReadRasterResult;
 /**
  * GeoTIFF sub-file image.
  */
 declare class GeoTIFFImage {
     /**
      * @constructor
-     * @param {import("./imagefiledirectory.js").ImageFileDirectory} fileDirectory The parsed file directory
-     * @param {DataView} dataView The DataView for the underlying file.
+     * @param {import("./imagefiledirectory").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').BaseSource} source The datasource to read from
+     * @param {import('./source/basesource.js').BaseSource} source The datasource to read from
      */
-    constructor(fileDirectory: import("./imagefiledirectory.js").ImageFileDirectory, dataView: DataView, littleEndian: boolean, cache: boolean, source: import("./source/basesource").BaseSource);
-    fileDirectory: import("./imagefiledirectory.js").ImageFileDirectory;
-    dataView: DataView<ArrayBufferLike>;
+    constructor(fileDirectory: import("./imagefiledirectory").ImageFileDirectory, littleEndian: boolean, cache: boolean, source: import("./source/basesource.js").BaseSource);
+    fileDirectory: import("./imagefiledirectory").ImageFileDirectory;
     littleEndian: boolean;
     tiles: {} | null;
     isTiled: boolean;
-    planarConfiguration: any;
-    source: import("./source/basesource").BaseSource;
+    /** @type {1 | 2} */
+    planarConfiguration: 1 | 2;
+    source: import("./source/basesource.js").BaseSource;
     /**
      * Returns the associated parsed file directory.
-     * @returns {import("./imagefiledirectory.js").ImageFileDirectory} the parsed file directory
+     * @returns {import("./imagefiledirectory").ImageFileDirectory} the parsed file directory
      */
-    getFileDirectory(): import("./imagefiledirectory.js").ImageFileDirectory;
+    getFileDirectory(): import("./imagefiledirectory").ImageFileDirectory;
     /**
      * Returns the associated parsed geo keys.
-     * @returns {Record<import('./globals.js').GeoKeyName, *>|null} the parsed geo keys
+     * @returns {Partial<Record<import('./globals.js').GeoKeyName, *>>|null} the parsed geo keys
      */
-    getGeoKeys(): Record<import("./globals.js").GeoKeyName, any> | null;
+    getGeoKeys(): Partial<Record<import("./globals.js").GeoKeyName, any>> | null;
     /**
      * Returns the width of the image.
      * @returns {Number} the width of the image
@@ -125,12 +71,12 @@ declare class GeoTIFFImage {
      * @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 {import("./geotiff").Pool|import("./geotiff").BaseDecoder} poolOrDecoder the decoder or decoder pool
+     * @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
      */
-    getTileOrStrip(x: number, y: number, sample: number, poolOrDecoder: import("./geotiff").Pool | import("./geotiff").BaseDecoder, signal?: AbortSignal): Promise<{
+    getTileOrStrip(x: number, y: number, sample: number, poolOrDecoder: DecoderWorker | import("./geotiff").BaseDecoder, signal?: AbortSignal): Promise<{
         x: number;
         y: number;
         sample: number;
@@ -142,59 +88,76 @@ declare class GeoTIFFImage {
      * @param {Array} imageWindow The image window in pixel coordinates
      * @param {Array} samples The selected samples (0-based indices)
      * @param {TypedArray|TypedArray[]} valueArrays The array(s) to write into
-     * @param {Boolean} interleave Whether or not to write in an interleaved manner
-     * @param {import("./geotiff").Pool|AbstractDecoder} 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 {number} resampleMethod the resampling method to be used when interpolating
+     * @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 {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
      * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
      *                               to be aborted
      * @returns {Promise<ReadRasterResult>}
      */
     private _readRaster;
     /**
-     * Reads raster data from the image. This function reads all selected samples
-     * into separate arrays of the correct type for that sample or into a single
-     * combined array when `interleave` is set. When provided, only a subset
-     * of the raster is read for each sample.
-     *
-     * @param {ReadRasterOptions} [options={}] optional parameters
+     * @overload
+     * @param {ReadRastersOptions & {interleave: true}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayWithDimensions>} the decoded arrays as a promise
+     */
+    readRasters(options: ReadRastersOptions & {
+        interleave: true;
+    }): Promise<import("./geotiff").TypedArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRastersOptions & {interleave: false}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
+     */
+    readRasters(options: ReadRastersOptions & {
+        interleave: false;
+    }): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRastersOptions & {interleave: boolean}} options optional parameters
      * @returns {Promise<ReadRasterResult>} the decoded arrays as a promise
      */
-    readRasters({ window: wnd, samples, interleave, pool, width, height, resampleMethod, fillValue, signal, }?: ReadRasterOptions): Promise<ReadRasterResult>;
+    readRasters(options: ReadRastersOptions & {
+        interleave: boolean;
+    }): Promise<ReadRasterResult>;
     /**
-     * Reads raster data from the image as RGB.
-     * Colorspaces other than RGB will be transformed to RGB, color maps expanded.
-     * When no other method is applicable, the first sample is used to produce a
-     * grayscale image.
-     * When provided, only a subset of the raster is read for each sample.
-     *
-     * @param {Object} [options] optional parameters
-     * @param {Array<number>} [options.window] the subset to read data from in pixels.
-     * @param {boolean} [options.interleave=true] whether the data shall be read
-     *                                             in one single array or separate
-     *                                             arrays.
-     * @param {import("./geotiff").Pool} [options.pool=null] The optional decoder pool to use.
-     * @param {number} [options.width] The desired width of the output. When the width is no the
-     *                                 same as the images, resampling will be performed.
-     * @param {number} [options.height] The desired height of the output. When the width is no the
-     *                                  same as the images, resampling will be performed.
-     * @param {string} [options.resampleMethod='nearest'] The desired resampling method.
-     * @param {boolean} [options.enableAlpha=false] Enable reading alpha channel if present.
-     * @param {AbortSignal} [options.signal] An AbortSignal that may be signalled if the request is
-     *                                       to be aborted
+     * @overload
+     * @param {ReadRastersOptions} [options={}] optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
+     */
+    readRasters(options?: ReadRastersOptions | undefined): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRGBOptions & {interleave: true}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayWithDimensions>} the RGB array as a Promise
+     */
+    readRGB(options: ReadRGBOptions & {
+        interleave: true;
+    }): Promise<import("./geotiff").TypedArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRGBOptions & {interleave: false}} options optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the RGB array as a Promise
+     */
+    readRGB(options: ReadRGBOptions & {
+        interleave: false;
+    }): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
+    /**
+     * @overload
+     * @param {ReadRGBOptions & {interleave: boolean}} options optional parameters
      * @returns {Promise<ReadRasterResult>} the RGB array as a Promise
      */
-    readRGB({ window, interleave, pool, width, height, resampleMethod, enableAlpha, signal }?: {
-        window?: number[] | undefined;
-        interleave?: boolean | undefined;
-        pool?: import("./pool.js").default | undefined;
-        width?: number | undefined;
-        height?: number | undefined;
-        resampleMethod?: string | undefined;
-        enableAlpha?: boolean | undefined;
-        signal?: AbortSignal | undefined;
+    readRGB(options: ReadRGBOptions & {
+        interleave: boolean;
     }): Promise<ReadRasterResult>;
+    /**
+     * @overload
+     * @param {ReadRGBOptions} [options={}] optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the RGB array as a Promise
+     */
+    readRGB(options?: ReadRGBOptions | undefined): Promise<import("./geotiff").TypedArrayArrayWithDimensions>;
     /**
      * Returns an array of tiepoints.
      * @returns {Promise<Object[]>}
@@ -206,10 +169,10 @@ declare class GeoTIFFImage {
      * If sample is passed to null, dataset-level metadata will be returned.
      * Otherwise only metadata specific to the provided sample will be returned.
      *
-     * @param {number} [sample=null] The sample index.
+     * @param {number|null} [sample=null] The sample index.
      * @returns {Promise<Object>}
      */
-    getGDALMetadata(sample?: number): Promise<Object>;
+    getGDALMetadata(sample?: number | null): Promise<Object>;
     /**
      * Returns the GDAL nodata value
      * @returns {number|null}
@@ -224,12 +187,12 @@ declare class GeoTIFFImage {
     /**
      * Returns the image resolution as a XYZ-vector. When the image has no affine
      * transformation, then an exception is thrown.
-     * @param {GeoTIFFImage} [referenceImage=null] A reference image to calculate the resolution from
+     * @param {GeoTIFFImage|null} [referenceImage=null] A reference image to calculate the resolution from
      *                                             in cases when the current image does not have the
      *                                             required tags on its own.
      * @returns {Array<number>} The resolution as a vector
      */
-    getResolution(referenceImage?: GeoTIFFImage): Array<number>;
+    getResolution(referenceImage?: GeoTIFFImage | null): Array<number>;
     /**
      * Returns whether or not the pixels of the image depict an area (or point).
      * @returns {Boolean} Whether the pixels are a point
@@ -245,4 +208,8 @@ declare class GeoTIFFImage {
      */
     getBoundingBox(tilegrid?: boolean): Array<number>;
 }
+import type { DecoderWorker } from "./geotiff";
+import type { ReadRastersOptions } from "./geotiff";
+import type { ReadRasterResult } from "./geotiff";
+import type { ReadRGBOptions } from "./geotiff";
 //# sourceMappingURL=geotiffimage.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"geotiffimage.d.ts","sourceRoot":"","sources":["../src/geotiffimage.js"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;WAmBc,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBAcJ,OAAO,cAAc,EAAE,UAAU;+BACjC,OAAO,cAAc,EAAE,gBAAgB;AA0IrD;;GAEG;AACH;IACE;;;;;;;OAOG;IACH,2BANW,OAAO,yBAAyB,EAAE,kBAAkB,YACpD,QAAQ,iDAGR,OAAO,qBAAqB,EAAE,UAAU,EAelD;IAZC,oEAAkC;IAClC,oCAAwB;IACxB,sBAAgC;IAChC,iBAA8B;IAC9B,iBAAoD;IAEpD,yBAAiG;IAKjG,iDAAoB;IAGtB;;;OAGG;IACH,oBAFa,OAAO,yBAAyB,EAAE,kBAAkB,CAIhE;IAED;;;OAGG;IACH,cAFa,MAAM,CAAC,OAAO,cAAc,EAAE,UAAU,EAAE,GAAC,CAAC,GAAC,IAAI,CAI7D;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,6BAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAQC;IAED,wBAEC;IAED,+BAMC;IAED;;;;OAIG;IACH,2BAQC;IAED,kCAMC;IAED,6FAyCC;IAED,2CAGC;IAED,4CAEC;IAED,mMAIC;IAED;;;;;;;;;OASG;IACH,oEALW,OAAO,WAAW,EAAE,IAAI,GAAC,OAAO,WAAW,EAAE,WAAW,WACxD,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,CAkE/E;IAED;;;;;;;;;;;;;;OAcG;IACH,oBAsHC;IAED;;;;;;;;OAQG;IACH,4GAHW,iBAAiB,GACf,OAAO,CAAC,gBAAgB,CAAC,CA6DrC;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,2FAfG;QAAgC,MAAM;QACZ,UAAU;QAGO,IAAI;QACtB,KAAK;QAEL,MAAM;QAEN,cAAc;QACb,WAAW;QACP,MAAM;KAEpC,GAAU,OAAO,CAAC,gBAAgB,CAAC,CA0GrC;IAED;;;OAGG;IACH,gBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB7B;IAED;;;;;;;;OAQG;IACH,yBAHW,MAAM,GACJ,OAAO,CAAC,MAAM,CAAC,CAsB3B;IAED;;;OAGG;IACH,iBAFa,MAAM,GAAC,IAAI,CAQvB;IAED;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAoBzB;IAED;;;;;;;OAOG;IACH,+BALW,YAAY,GAGV,KAAK,CAAC,MAAM,CAAC,CAuCzB;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,0BAJW,OAAO,GAEL,KAAK,CAAC,MAAM,CAAC,CAgDzB;CACF"}
+{"version":3,"file":"geotiffimage.d.ts","sourceRoot":"","sources":["../src/geotiffimage.js"],"names":[],"mappings":";AAuJA;;GAEG;AACH;IACE;;;;;;OAMG;IACH,2BALW,OAAO,sBAAsB,EAAE,kBAAkB,iDAGjD,OAAO,wBAAwB,EAAE,UAAU,EAerD;IAZC,iEAAkC;IAClC,sBAAgC;IAChC,iBAA8B;IAC9B,iBAAoD;IAKpD,oBAAoB;IACpB,qBADW,CAAC,GAAG,CAAC,CAC8B;IAE9C,oDAAoB;IAGtB;;;OAGG;IACH,oBAFa,OAAO,sBAAsB,EAAE,kBAAkB,CAI7D;IAED;;;OAGG;IACH,cAFa,OAAO,CAAC,MAAM,CAAC,OAAO,cAAc,EAAE,UAAU,EAAE,GAAC,CAAC,CAAC,GAAC,IAAI,CAItE;IAED;;;OAGG;IACH,mBAEC;IAED;;;OAGG;IACH,oBAEC;IAED;;;OAGG;IACH,6BAGC;IAED;;;OAGG;IACH,uBAEC;IAED;;;OAGG;IACH,wBAQC;IAED,wBAEC;IAED,+BAMC;IAED;;;;OAIG;IACH,2BAQC;IAED,kCAMC;IAED,6FAyCC;IAED,2CAGC;IAED,4CAEC;IAED,mMAIC;IAED;;;;;;;;;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,CAqE/E;IAED;;;;;;;;;;;;;;OAcG;IACH,oBA6HC;;;;;;IAGE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,IAAI,CAAA;KAAC,GACrC,OAAO,CAAC,OAAO,WAAW,EAAE,wBAAwB,CAAC,CACjE;;;;;;IAGE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,KAAK,CAAA;KAAC,GACtC,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IAGE,qBACQ,kBAAkB,GAAG;QAAC,UAAU,EAAE,OAAO,CAAA;KAAC,GACxC,OAAO,CAAC,gBAAgB,CAAC,CACrC;;;;;;IAGE,uDAEU,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IA+EE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,IAAI,CAAA;KAAC,GACjC,OAAO,CAAC,OAAO,WAAW,EAAE,wBAAwB,CAAC,CACjE;;;;;;IAGE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,KAAK,CAAA;KAAC,GAClC,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;;;;;;IAGE,iBACQ,cAAc,GAAG;QAAC,UAAU,EAAE,OAAO,CAAA;KAAC,GACpC,OAAO,CAAC,gBAAgB,CAAC,CACrC;;;;;;IAGE,+CAEU,OAAO,CAAC,OAAO,WAAW,EAAE,6BAA6B,CAAC,CACtE;IA2HD;;;OAGG;IACH,gBAFa,OAAO,CAAC,MAAM,EAAE,CAAC,CAoB7B;IAED;;;;;;;;OAQG;IACH,yBAHW,MAAM,GAAC,IAAI,GACT,OAAO,CAAC,MAAM,CAAC,CAsB3B;IAED;;;OAGG;IACH,iBAFa,MAAM,GAAC,IAAI,CAQvB;IAED;;;;OAIG;IACH,aAFa,KAAK,CAAC,MAAM,CAAC,CAoBzB;IAED;;;;;;;OAOG;IACH,+BALW,YAAY,GAAC,IAAI,GAGf,KAAK,CAAC,MAAM,CAAC,CAuCzB;IAED;;;OAGG;IACH,uBAEC;IAED;;;;;;;OAOG;IACH,0BAJW,OAAO,GAEL,KAAK,CAAC,MAAM,CAAC,CAgDzB;CACF;mCA/9B4C,WAAW;wCAElB,WAAW;sCADb,WAAW;oCAEb,WAAW"}

package/dist-module/geotiffimage.js

@@ -6,30 +6,10 @@ import { photometricInterpretations, ExtraSamplesValues } from './globals.js';
 import { fromWhiteIsZero, fromBlackIsZero, fromPalette, fromCMYK, fromYCbCr, fromCIELab } from './rgb.js';
 import { getDecoder, getDecoderParameters } from './compression/index.js';
 import { resample, resampleInterleaved } from './resample.js';
-/**
- * @typedef {Object} ReadRasterOptions
- * @property {Array<number>} [window=whole window] the subset to read data from in pixels.
- * @property {Array<number>} [bbox=whole image] the subset to read data from in
- *                                           geographical coordinates.
- * @property {Array<number>} [samples=all samples] the selection of samples to read from. Default is all samples.
- * @property {boolean} [interleave=false] whether the data shall be read
- *                                             in one single array or separate
- *                                             arrays.
- * @property {Pool} [pool=null] The optional decoder pool to use.
- * @property {number} [width] The desired width of the output. When the width is not the
- *                                 same as the images, resampling will be performed.
- * @property {number} [height] The desired height of the output. When the width is not the
- *                                  same as the images, resampling will be performed.
- * @property {string} [resampleMethod='nearest'] The desired resampling method.
- * @property {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
- *                                       to be aborted
- * @property {number|number[]} [fillValue] The value to use for parts of the image
- *                                              outside of the images extent. When multiple
- *                                              samples are requested, an array of fill values
- *                                              can be passed.
- */
-/** @typedef {import("./geotiff.js").TypedArray} TypedArray */
-/** @typedef {import("./geotiff.js").ReadRasterResult} ReadRasterResult */
+/** @import {DecoderWorker, TypedArray} from "./geotiff" */
+/** @import {ReadRasterResult} from "./geotiff" */
+/** @import {ReadRastersOptions} from "./geotiff" */
+/** @import {ReadRGBOptions} from "./geotiff" */
 function sum(array, start, end) {
     let s = 0;
     for (let i = start; i < end; ++i) {
@@ -170,35 +150,34 @@ function normalizeArray(inBuffer, format, planarConfiguration, samplesPerPixel,
 class GeoTIFFImage {
     /**
      * @constructor
-     * @param {import("./imagefiledirectory.js").ImageFileDirectory} fileDirectory The parsed file directory
-     * @param {DataView} dataView The DataView for the underlying file.
+     * @param {import("./imagefiledirectory").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').BaseSource} source The datasource to read from
+     * @param {import('./source/basesource.js').BaseSource} source The datasource to read from
      */
-    constructor(fileDirectory, dataView, littleEndian, cache, source) {
+    constructor(fileDirectory, littleEndian, cache, source) {
         this.fileDirectory = fileDirectory;
-        this.dataView = dataView;
         this.littleEndian = littleEndian;
         this.tiles = cache ? {} : null;
         this.isTiled = !fileDirectory.hasTag('StripOffsets');
-        const planarConfiguration = fileDirectory.getValue('PlanarConfiguration');
-        this.planarConfiguration = (typeof planarConfiguration === 'undefined') ? 1 : planarConfiguration;
-        if (this.planarConfiguration !== 1 && this.planarConfiguration !== 2) {
+        const planarConfiguration = fileDirectory.getValue('PlanarConfiguration') ?? 1;
+        if (planarConfiguration !== 1 && planarConfiguration !== 2) {
             throw new Error('Invalid planar configuration.');
         }
+        /** @type {1 | 2} */
+        this.planarConfiguration = planarConfiguration;
         this.source = source;
     }
     /**
      * Returns the associated parsed file directory.
-     * @returns {import("./imagefiledirectory.js").ImageFileDirectory} the parsed file directory
+     * @returns {import("./imagefiledirectory").ImageFileDirectory} the parsed file directory
      */
     getFileDirectory() {
         return this.fileDirectory;
     }
     /**
      * Returns the associated parsed geo keys.
-     * @returns {Record<import('./globals.js').GeoKeyName, *>|null} the parsed geo keys
+     * @returns {Partial<Record<import('./globals.js').GeoKeyName, *>>|null} the parsed geo keys
      */
     getGeoKeys() {
         return this.fileDirectory.parseGeoKeyDirectory();
@@ -339,7 +318,7 @@ class GeoTIFFImage {
      * @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 {import("./geotiff").Pool|import("./geotiff").BaseDecoder} poolOrDecoder the decoder or decoder pool
+     * @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
@@ -355,6 +334,9 @@ class GeoTIFFImage {
         else if (this.planarConfiguration === 2) {
             index = (sample * numTilesPerRow * numTilesPerCol) + (y * numTilesPerRow) + x;
         }
+        if (index === undefined) {
+            throw new Error('Could not determine tile or strip index.');
+        }
         let offset;
         let byteCount;
         if (this.isTiled) {
@@ -404,11 +386,11 @@ class GeoTIFFImage {
      * @param {Array} imageWindow The image window in pixel coordinates
      * @param {Array} samples The selected samples (0-based indices)
      * @param {TypedArray|TypedArray[]} valueArrays The array(s) to write into
-     * @param {Boolean} interleave Whether or not to write in an interleaved manner
-     * @param {import("./geotiff").Pool|AbstractDecoder} 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 {number} resampleMethod the resampling method to be used when interpolating
+     * @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 {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
      * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
      *                               to be aborted
      * @returns {Promise<ReadRasterResult>}
@@ -450,6 +432,9 @@ class GeoTIFFImage {
                         bytesPerPixel = this.getSampleByteSize(sample);
                         getPromise = this.getTileOrStrip(xTile, yTile, sample, poolOrDecoder, signal);
                     }
+                    if (!getPromise) {
+                        throw new Error('Could not get tile or strip data.');
+                    }
                     const promise = getPromise.then((tile) => {
                         const buffer = tile.data;
                         const dataView = new DataView(buffer);
@@ -488,29 +473,57 @@ class GeoTIFFImage {
             || (height && (imageWindow[3] - imageWindow[1]) !== height)) {
             let resampled;
             if (interleave) {
-                resampled = resampleInterleaved(valueArrays, imageWindow[2] - imageWindow[0], imageWindow[3] - imageWindow[1], width, height, samples.length, resampleMethod);
+                resampled = resampleInterleaved(
+                /** @type {TypedArray} */ (valueArrays), imageWindow[2] - imageWindow[0], imageWindow[3] - imageWindow[1], 
+                /** @type {number} */ (width), /** @type {number} */ (height), samples.length, resampleMethod);
             }
             else {
-                resampled = resample(valueArrays, imageWindow[2] - imageWindow[0], imageWindow[3] - imageWindow[1], width, height, resampleMethod);
+                resampled = resample(
+                /** @type {TypedArray[]} */ (valueArrays), imageWindow[2] - imageWindow[0], imageWindow[3] - imageWindow[1], 
+                /** @type {number} */ (width), /** @type {number} */ (height), resampleMethod);
             }
-            resampled.width = width;
-            resampled.height = height;
-            return resampled;
+            const resampledWithDimensions = /** @type {ReadRasterResult} */ (resampled);
+            resampledWithDimensions.width = width ?? imageWindow[2] - imageWindow[0];
+            resampledWithDimensions.height = height ?? imageWindow[3] - imageWindow[1];
+            return resampledWithDimensions;
         }
-        valueArrays.width = width || imageWindow[2] - imageWindow[0];
-        valueArrays.height = height || imageWindow[3] - imageWindow[1];
-        return valueArrays;
+        const valueArraysWithDimensions = /** @type {ReadRasterResult} */ (valueArrays);
+        valueArraysWithDimensions.width = width || imageWindow[2] - imageWindow[0];
+        valueArraysWithDimensions.height = height || imageWindow[3] - imageWindow[1];
+        return valueArraysWithDimensions;
     }
+    /**
+     * @overload
+     * @param {ReadRastersOptions & {interleave: true}} options optional parameters
+     * @returns {Promise<import("./geotiff").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
+     */
+    /**
+     * @overload
+     * @param {ReadRastersOptions & {interleave: boolean}} options optional parameters
+     * @returns {Promise<ReadRasterResult>} the decoded arrays as a promise
+     */
+    /**
+     * @overload
+     * @param {ReadRastersOptions} [options={}] optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the decoded arrays as a promise
+     */
     /**
      * Reads raster data from the image. This function reads all selected samples
      * into separate arrays of the correct type for that sample or into a single
      * combined array when `interleave` is set. When provided, only a subset
      * of the raster is read for each sample.
      *
-     * @param {ReadRasterOptions} [options={}] optional parameters
+     * @param {ReadRastersOptions} [options={}] optional parameters
      * @returns {Promise<ReadRasterResult>} the decoded arrays as a promise
      */
-    async readRasters({ window: wnd, samples = [], interleave, pool = null, width, height, resampleMethod, fillValue, signal, } = {}) {
+    async readRasters(options = {}) {
+        const { window: wnd, samples = [], pool = null, width, height, resampleMethod, fillValue, signal, } = options;
+        const interleave = 'interleave' in options && options.interleave;
         const imageWindow = wnd || [0, 0, this.getWidth(), this.getHeight()];
         // check parameters
         if (imageWindow[0] > imageWindow[2] || imageWindow[1] > imageWindow[3]) {
@@ -532,6 +545,7 @@ class GeoTIFFImage {
                 }
             }
         }
+        /** @type {TypedArray|TypedArray[]} */
         let valueArrays;
         if (interleave) {
             const format = this.fileDirectory.hasTag('SampleFormat')
@@ -539,6 +553,9 @@ class GeoTIFFImage {
             const bitsPerSample = Math.max.apply(null, this.fileDirectory.getValue('BitsPerSample'));
             valueArrays = arrayForType(format, bitsPerSample, numPixels * samples.length);
             if (fillValue) {
+                if (Array.isArray(fillValue)) {
+                    throw new Error('When reading interleaved data, fillValue must be a single number.');
+                }
                 valueArrays.fill(fillValue);
             }
         }
@@ -563,6 +580,26 @@ class GeoTIFFImage {
         const result = await this._readRaster(imageWindow, samples, valueArrays, interleave, poolOrDecoder, width, height, resampleMethod, signal);
         return result;
     }
+    /**
+     * @overload
+     * @param {ReadRGBOptions & {interleave: true}} options optional parameters
+     * @returns {Promise<import("./geotiff").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
+     */
+    /**
+     * @overload
+     * @param {ReadRGBOptions & {interleave: boolean}} options optional parameters
+     * @returns {Promise<ReadRasterResult>} the RGB array as a Promise
+     */
+    /**
+     * @overload
+     * @param {ReadRGBOptions} [options={}] optional parameters
+     * @returns {Promise<import("./geotiff").TypedArrayArrayWithDimensions>} the RGB array as a Promise
+     */
     /**
      * Reads raster data from the image as RGB.
      * Colorspaces other than RGB will be transformed to RGB, color maps expanded.
@@ -570,23 +607,12 @@ class GeoTIFFImage {
      * grayscale image.
      * When provided, only a subset of the raster is read for each sample.
      *
-     * @param {Object} [options] optional parameters
-     * @param {Array<number>} [options.window] the subset to read data from in pixels.
-     * @param {boolean} [options.interleave=true] whether the data shall be read
-     *                                             in one single array or separate
-     *                                             arrays.
-     * @param {import("./geotiff").Pool} [options.pool=null] The optional decoder pool to use.
-     * @param {number} [options.width] The desired width of the output. When the width is no the
-     *                                 same as the images, resampling will be performed.
-     * @param {number} [options.height] The desired height of the output. When the width is no the
-     *                                  same as the images, resampling will be performed.
-     * @param {string} [options.resampleMethod='nearest'] The desired resampling method.
-     * @param {boolean} [options.enableAlpha=false] Enable reading alpha channel if present.
-     * @param {AbortSignal} [options.signal] An AbortSignal that may be signalled if the request is
-     *                                       to be aborted
+     * @param {ReadRGBOptions} [options] optional parameters
      * @returns {Promise<ReadRasterResult>} the RGB array as a Promise
      */
-    async readRGB({ window, interleave = true, pool = null, width, height, resampleMethod, enableAlpha = false, signal } = {}) {
+    async readRGB(options = {}) {
+        const { window, pool = null, width, height, resampleMethod, enableAlpha = false, signal } = options;
+        const interleave = ('interleave' in options && options.interleave) ?? false;
         const imageWindow = window || [0, 0, this.getWidth(), this.getHeight()];
         // check parameters
         if (imageWindow[0] > imageWindow[2] || imageWindow[1] > imageWindow[3]) {
@@ -631,6 +657,7 @@ class GeoTIFFImage {
         }
         const subOptions = {
             window: imageWindow,
+            /** @type {true} */
             interleave: true,
             samples,
             pool,
@@ -678,9 +705,10 @@ class GeoTIFFImage {
             }
             data = [red, green, blue];
         }
-        data.width = raster.width;
-        data.height = raster.height;
-        return data;
+        const dataWithDimensions = /** @type {import("./geotiff").ReadRasterResult} */ (data);
+        dataWithDimensions.width = raster.width;
+        dataWithDimensions.height = raster.height;
+        return dataWithDimensions;
     }
     /**
      * Returns an array of tiepoints.
@@ -710,7 +738,7 @@ class GeoTIFFImage {
      * If sample is passed to null, dataset-level metadata will be returned.
      * Otherwise only metadata specific to the provided sample will be returned.
      *
-     * @param {number} [sample=null] The sample index.
+     * @param {number|null} [sample=null] The sample index.
      * @returns {Promise<Object>}
      */
     async getGDALMetadata(sample = null) {
@@ -770,7 +798,7 @@ class GeoTIFFImage {
     /**
      * Returns the image resolution as a XYZ-vector. When the image has no affine
      * transformation, then an exception is thrown.
-     * @param {GeoTIFFImage} [referenceImage=null] A reference image to calculate the resolution from
+     * @param {GeoTIFFImage|null} [referenceImage=null] A reference image to calculate the resolution from
      *                                             in cases when the current image does not have the
      *                                             required tags on its own.
      * @returns {Array<number>} The resolution as a vector
@@ -816,7 +844,7 @@ class GeoTIFFImage {
      * @returns {Boolean} Whether the pixels are a point
      */
     pixelIsArea() {
-        return this.geoKeys.GTRasterTypeGeoKey === 1;
+        return this.getGeoKeys()?.GTRasterTypeGeoKey === 1;
     }
     /**
      * Returns the image bounding box as an array of 4 values: min-x, min-y,

package/dist-module/geotiffwriter.js

@@ -315,7 +315,7 @@ export function writeGeotiff(data, metadata) {
     if (!metadata.BitsPerSample) {
         let bitsPerSample = 8;
         if (ArrayBuffer.isView(flattenedValues)) {
-            bitsPerSample = 8 * flattenedValues.BYTES_PER_ELEMENT;
+            bitsPerSample = 8 * Object.getPrototypeOf(flattenedValues).BYTES_PER_ELEMENT;
         }
         metadata.BitsPerSample = times(numBands, () => bitsPerSample);
     }
@@ -340,7 +340,7 @@ export function writeGeotiff(data, metadata) {
         // default for Float64
         let elementSize = 8;
         if (ArrayBuffer.isView(flattenedValues)) {
-            elementSize = flattenedValues.BYTES_PER_ELEMENT;
+            elementSize = Object.getPrototypeOf(flattenedValues).BYTES_PER_ELEMENT;
         }
         metadata.StripByteCounts = [numBands * elementSize * height * width];
     }