geotiff 3.0.0 → 3.0.2

package/dist-node/geotiff.d.ts

@@ -1,23 +1,23 @@
 /**
  * Creates a new GeoTIFF from a remote URL.
  * @param {string} url The URL to access the image from
- * @param {object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See {@link makeRemoteSource} for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
  *                               to be aborted
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
-export function fromUrl(url: string, options?: object, signal?: AbortSignal): Promise<GeoTIFF>;
+export function fromUrl(url: string, options?: RemoteSourceOptions, signal?: AbortSignal): Promise<GeoTIFF>;
 /**
  * Creates a new GeoTIFF from a custom {@link BaseClient}.
  * @param {BaseClient} client The client.
- * @param {object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See {@link makeRemoteSource} for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
  *                               to be aborted
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
-export function fromCustomClient(client: BaseClient, options?: object, signal?: AbortSignal): Promise<GeoTIFF>;
+export function fromCustomClient(client: BaseClient, options?: RemoteSourceOptions, signal?: AbortSignal): Promise<GeoTIFF>;
 /**
  * Construct a new GeoTIFF from an
  * [ArrayBuffer]{@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/ArrayBuffer}.
@@ -55,20 +55,21 @@ export function fromBlob(blob: Blob | File, signal?: AbortSignal): Promise<GeoTI
  * Construct a MultiGeoTIFF from the given URLs.
  * @param {string} mainUrl The URL for the main file.
  * @param {string[]} overviewUrls An array of URLs for the overview images.
- * @param {Object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See [makeRemoteSource]{@link module:source.makeRemoteSource}
  *                           for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
  *                               to be aborted
  * @returns {Promise<MultiGeoTIFF>} The resulting MultiGeoTIFF file.
  */
-export function fromUrls(mainUrl: string, overviewUrls?: string[], options?: any, signal?: AbortSignal): Promise<MultiGeoTIFF>;
+export function fromUrls(mainUrl: string, overviewUrls?: string[], options?: RemoteSourceOptions, signal?: AbortSignal): Promise<MultiGeoTIFF>;
 /**
  * Main creating function for GeoTIFF files.
- * @param {(Array)} array of pixel values
- * @returns {metadata} metadata
+ * @param {Array} values of pixel values
+ * @param {Object} metadata
+ * @returns {ArrayBuffer}
  */
-export function writeArrayBuffer(values: any, metadata: any): any;
+export function writeArrayBuffer(values: any[], metadata: any): ArrayBuffer;
 export { default as BaseDecoder } from "./compression/basedecoder.js";
 export default GeoTIFF;
 export type TypedArray = Uint8Array | Int8Array | Uint16Array | Int16Array | Uint32Array | Int32Array | Float32Array | Float64Array;
@@ -94,6 +95,127 @@ export type TypedArrayArrayWithDimensions = TypedArray[] & Dimensions;
  * `(TypedArray | TypedArray[]) & { height: number; width: number}`
  */
 export type ReadRasterResult = TypedArrayWithDimensions | TypedArrayArrayWithDimensions;
+/**
+ * Use the {@link Pool.bindParameters} method to get a decoder worker for
+ * a specific compression and its parameters.
+ */
+export type DecoderWorker = {
+    /**
+     *   A function that takes a compressed buffer and returns a promise resolving to the decoded buffer.
+     */
+    decode: (buffer: ArrayBuffer) => Promise<ArrayBuffer>;
+};
+export type ReadRastersOptions = {
+    /**
+     * the subset to read data from in pixels. Whole window if not specified.
+     */
+    window?: number[] | undefined;
+    /**
+     * the selection of samples to read from. Default is all samples.
+     * All samples if not specified.
+     */
+    samples?: number[] | undefined;
+    /**
+     * The optional decoder pool to use.
+     */
+    pool?: Pool | null | undefined;
+    /**
+     * 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 and `interleave` is
+     * `false`, an array of fill values can be passed.
+     */
+    fillValue?: number | number[] | undefined;
+    /**
+     * whether the data shall be read
+     * in one single array or separate arrays.
+     */
+    interleave?: boolean | undefined;
+};
+export type ReadRGBOptions = {
+    /**
+     * the subset to read data from in pixels. Whole window if not specified.
+     */
+    window?: number[] | undefined;
+    /**
+     * The optional decoder pool to use.
+     */
+    pool?: Pool | null | undefined;
+    /**
+     * The desired width of the output. When the width is no the
+     *       same as the images, resampling will be performed.
+     */
+    width?: number | undefined;
+    /**
+     * The desired height of the output. When the width is no the
+     *       same as the images, resampling will be performed.
+     */
+    height?: number | undefined;
+    /**
+     * The desired resampling method.
+     */
+    resampleMethod?: string | undefined;
+    /**
+     * Enable reading alpha channel if present.
+     */
+    enableAlpha?: boolean | undefined;
+    /**
+     * An AbortSignal that may be signalled if the request is
+     *       to be aborted
+     */
+    signal?: AbortSignal | undefined;
+    /**
+     * whether the data shall be read
+     * in one single array or separate arrays.
+     */
+    interleave?: boolean | undefined;
+};
+export type BlockedSourceOptions = {
+    /**
+     * Block size for a BlockedSource.
+     */
+    blockSize?: number | null | undefined;
+    /**
+     * The number of blocks to cache.
+     */
+    cacheSize?: number | undefined;
+};
+export type RemoteSourceOptions = {
+    /**
+     * Additional headers to add to each request
+     */
+    headers?: any;
+    /**
+     * Maximum number of ranges to request in a single HTTP request. 0 means no multi-range requests.
+     */
+    maxRanges?: number | undefined;
+    /**
+     * Whether to allow full file responses when requesting ranges
+     */
+    allowFullFile?: boolean | undefined;
+    /**
+     * When the Fetch API would be used, force using XMLHttpRequest instead.
+     */
+    forceXHR?: boolean | undefined;
+};
 export type GeoTIFFOptions = {
     /**
      * whether or not decoded tiles shall be cached.
@@ -106,51 +228,37 @@ export type GeoTIFFOptions = {
  */
 /**
  * The abstraction for a whole GeoTIFF file.
- * @augments GeoTIFFBase
  */
 export class GeoTIFF extends GeoTIFFBase {
     /**
      * Parse a (Geo)TIFF file from the given source.
      *
-     * @param {*} source The source of data to parse from.
+     * @param {BaseSource} source The source of data to parse from.
      * @param {GeoTIFFOptions} [options] Additional options.
      * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
      *                               to be aborted
      */
-    static fromSource(source: any, options?: GeoTIFFOptions, signal?: AbortSignal): Promise<GeoTIFF>;
+    static fromSource(source: BaseSource, options?: GeoTIFFOptions, signal?: AbortSignal): Promise<GeoTIFF>;
     /**
      * @constructor
-     * @param {*} source The datasource to read from.
+     * @param {BaseSource} source The datasource to read from.
      * @param {boolean} littleEndian Whether the image uses little endian.
      * @param {boolean} bigTiff Whether the image uses bigTIFF conventions.
      * @param {number} firstIFDOffset The numeric byte-offset from the start of the image
      *                                to the first IFD.
      * @param {GeoTIFFOptions} [options] further options.
      */
-    constructor(source: any, littleEndian: boolean, bigTiff: boolean, firstIFDOffset: number, options?: GeoTIFFOptions);
-    source: any;
+    constructor(source: BaseSource, littleEndian: boolean, bigTiff: boolean, firstIFDOffset: number, options?: GeoTIFFOptions);
+    source: BaseSource;
     parser: ImageFileDirectoryParser;
     littleEndian: boolean;
     bigTiff: boolean;
     firstIFDOffset: number;
     cache: boolean;
     ifdRequests: any[];
-    ghostValues: {} | null;
+    ghostValues: any;
     getSlice(offset: any, size: any): Promise<DataSlice>;
     requestIFD(index: any): Promise<any>;
-    /**
-     * Get the n-th internal subfile of an image. By default, the first is returned.
-     *
-     * @param {number} [index=0] the index of the image to return.
-     * @returns {Promise<GeoTIFFImage>} the image at the given index
-     */
-    getImage(index?: number): Promise<GeoTIFFImage>;
-    /**
-     * Returns the count of the internal subfiles.
-     *
-     * @returns {Promise<number>} the number of internal subfile images
-     */
-    getImageCount(): Promise<number>;
     /**
      * 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
@@ -162,7 +270,7 @@ export class GeoTIFF extends GeoTIFFBase {
      * N.B. After the GeoTIFF has been completely processed it needs
      * to be closed but only if it has been constructed from a file.
      */
-    close(): any;
+    close(): false | Promise<void>;
 }
 import { BaseClient } from './source/client/base.js';
 /**
@@ -183,19 +291,6 @@ export class MultiGeoTIFF extends GeoTIFFBase {
     fileDirectoriesPerFileParsing: any;
     imageCount: number | null;
     parseFileDirectoriesPerFile(): Promise<import("./imagefiledirectory.js").ImageFileDirectory[]>;
-    /**
-     * Get the n-th internal subfile of an image. By default, the first is returned.
-     *
-     * @param {number} [index=0] the index of the image to return.
-     * @returns {Promise<GeoTIFFImage>} the image at the given index
-     */
-    getImage(index?: number): Promise<GeoTIFFImage>;
-    /**
-     * Returns the count of the internal subfiles.
-     *
-     * @returns {Promise<number>} the number of internal subfile images
-     */
-    getImageCount(): Promise<number>;
     imageCounts: number[] | undefined;
 }
 import * as globals from './globals.js';
@@ -208,6 +303,22 @@ import Pool from './pool.js';
 import GeoTIFFImage from './geotiffimage.js';
 import { BaseResponse } from './source/client/base.js';
 declare class GeoTIFFBase {
+    /**
+     * @param {number} [_index=0] the index of the image to return.
+     * @returns {Promise<GeoTIFFImage>} the image at the given index
+     */
+    getImage(_index?: number): Promise<GeoTIFFImage>;
+    /**
+     * @returns {Promise<number>} the number of internal subfile images
+     */
+    getImageCount(): Promise<number>;
+    /**
+     * @typedef {Object} ReadRastersWindowOptions
+     * @property {number} [resX] desired Y resolution (world units per pixel)
+     * @property {number} [resY] desired X resolution (world units per pixel)
+     * @property {Array<number>} [bbox] the subset to read data from in
+     *     geographical coordinates. Whole image if not specified.
+     */
     /**
      * (experimental) Reads raster data from the best fitting image. This function uses
      * the image with the lowest resolution that is still a higher resolution than the
@@ -217,11 +328,26 @@ declare class GeoTIFFBase {
      * Then, the [readRasters]{@link GeoTIFFImage#readRasters} method of the selected
      * image is called and the result returned.
      * @see GeoTIFFImage.readRasters
-     * @param {import('./geotiffimage').ReadRasterOptions} [options={}] optional parameters
+     * @param {ReadRastersOptions & ReadRastersWindowOptions} options optional parameters
      * @returns {Promise<ReadRasterResult>} the decoded array(s), with `height` and `width`, as a promise
      */
-    readRasters(options?: import("./geotiffimage").ReadRasterOptions): Promise<ReadRasterResult>;
+    readRasters(options?: ReadRastersOptions & {
+        /**
+         * desired Y resolution (world units per pixel)
+         */
+        resX?: number | undefined;
+        /**
+         * desired X resolution (world units per pixel)
+         */
+        resY?: number | undefined;
+        /**
+         * the subset to read data from in
+         * geographical coordinates. Whole image if not specified.
+         */
+        bbox?: number[] | undefined;
+    }): Promise<ReadRasterResult>;
 }
+import type { BaseSource } from './source/basesource.js';
 import { ImageFileDirectoryParser } from './imagefiledirectory.js';
 import DataSlice from './dataslice.js';
 export { globals, registerTag, rgb, getDecoder, addDecoder, setLogger, Pool, GeoTIFFImage, BaseClient, BaseResponse };

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

@@ -1 +1 @@
-{"version":3,"file":"geotiff.d.ts","sourceRoot":"","sources":["../dist-module/geotiff.js"],"names":[],"mappings":"AA2eA;;;;;;;;GAQG;AACH,6BAPW,MAAM,YACN,MAAM,WAEN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;GAQG;AACH,yCAPW,UAAU,YACV,MAAM,WAEN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;GAOG;AACH,6CALW,WAAW,WACX,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;;;;GAWG;AACH,+BALW,MAAM,WACN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;;GASG;AACH,+BALW,IAAI,GAAC,IAAI,WACT,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;;;GAUG;AACH,kCATW,MAAM,iBACN,MAAM,EAAE,0BAIR,WAAW,GAET,OAAO,CAAC,YAAY,CAAC,CAMjC;AACD;;;;GAIG;AACH,kEAEC;;;yBAziBY,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY;yBAI1G;IAAE,MAAM,EAAC,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;;uCAMhC,UAAU,GAAG,UAAU;;;;;;4CAMvB,UAAU,EAAE,GAAG,UAAU;;;;;;+BAMzB,wBAAwB,GAAG,6BAA6B;;;;;;;AAuLrE;;;GAGG;AACH;;;GAGG;AACH;IAoII;;;;;;;OAOG;IACH,0BALW,GAAC,YACD,cAAc,WACd,WAAW,oBAoCrB;IA5KD;;;;;;;;OAQG;IACH,oBAPW,GAAC,gBACD,OAAO,WACP,OAAO,kBACP,MAAM,YAEN,cAAc,EAYxB;IARG,YAAoB;IACpB,iCAAgF;IAChF,sBAAgC;IAChC,iBAAsB;IACtB,uBAAoC;IACpC,eAAmC;IACnC,mBAAqB;IACrB,uBAAuB;IAE3B,qDAMC;IACD,qCAqCC;IACD;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAIjC;IACD;;;;OAIG;IACH,iBAFa,OAAO,CAAC,MAAM,CAAC,CAqB3B;IACD;;;;OAIG;IACH,kBAFa,OAAO,KAAQ,CA4B3B;IA2CD;;;;OAIG;IACH,aAKC;CACJ;2BA7ZwC,yBAAyB;AAgalE;;;GAGG;AACH;IACI;;;;OAIG;IACH,sBAHW,OAAO,iBACP,OAAO,EAAE,EAUnB;IANG,kBAAwB;IACxB,yBAAkC;IAClC,sBAAkD;IAClD,sFAAkC;IAClC,mCAAyC;IACzC,0BAAsB;IAE1B,+FAKC;IACD;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAmBjC;IACD;;;;OAIG;IACH,iBAFa,OAAO,CAAC,MAAM,CAAC,CAW3B;IAHG,kCAA8C;CAIrD;yBA5dwB,cAAc;4BAFmB,cAAc;qBAGnD,UAAU;2BACQ,wBAAwB;2BAAxB,wBAAwB;0BACrC,cAAc;iBAZvB,WAAW;yBAHH,mBAAmB;6BAQH,yBAAyB;AA8HlE;IACI;;;;;;;;;;;OAWG;IACH,sBAHW,OAAO,gBAAgB,EAAE,iBAAiB,GACxC,OAAO,CAAC,gBAAgB,CAAC,CAiFrC;CACJ;yCA1NwC,yBAAyB;sBAP5C,gBAAgB"}
+{"version":3,"file":"geotiff.d.ts","sourceRoot":"","sources":["../dist-module/geotiff.js"],"names":[],"mappings":"AA6kBA;;;;;;;;GAQG;AACH,6BAPW,MAAM,YACN,mBAAmB,WAEnB,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;GAQG;AACH,yCAPW,UAAU,YACV,mBAAmB,WAEnB,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;GAOG;AACH,6CALW,WAAW,WACX,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;;;;GAWG;AACH,+BALW,MAAM,WACN,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;;GASG;AACH,+BALW,IAAI,GAAC,IAAI,WACT,WAAW,GAET,OAAO,CAAC,OAAO,CAAC,CAI5B;AACD;;;;;;;;;;GAUG;AACH,kCATW,MAAM,iBACN,MAAM,EAAE,YACR,mBAAmB,WAGnB,WAAW,GAET,OAAO,CAAC,YAAY,CAAC,CAMjC;AACD;;;;;GAKG;AACH,gEAFa,WAAW,CAIvB;;;yBA3oBY,UAAU,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,YAAY,GAAG,YAAY;yBAI1G;IAAE,MAAM,EAAC,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE;;;;;;uCAMhC,UAAU,GAAG,UAAU;;;;;;4CAMvB,UAAU,EAAE,GAAG,UAAU;;;;;;+BAMzB,wBAAwB,GAAG,6BAA6B;;;;;;;;;YAOvD,CAAC,MAAM,EAAE,WAAW,KAAK,OAAO,CAAC,WAAW,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6Q3D;;;GAGG;AACH;;GAEG;AACH;IAqII;;;;;;;OAOG;IACH,0BALW,UAAU,YACV,cAAc,WACd,WAAW,oBAoCrB;IA7KD;;;;;;;;OAQG;IACH,oBAPW,UAAU,gBACV,OAAO,WACP,OAAO,kBACP,MAAM,YAEN,cAAc,EAYxB;IARG,mBAAoB;IACpB,iCAAgF;IAChF,sBAAgC;IAChC,iBAAsB;IACtB,uBAAoC;IACpC,eAAmC;IACnC,mBAAqB;IACrB,iBAAuB;IAE3B,qDAMC;IACD,qCAqCC;IAmCD;;;;OAIG;IACH,kBAFa,OAAO,KAAQ,CA6B3B;IA2CD;;;;OAIG;IACH,+BAKC;CACJ;2BA3fwC,yBAAyB;AA8flE;;;GAGG;AACH;IACI;;;;OAIG;IACH,sBAHW,OAAO,iBACP,OAAO,EAAE,EAUnB;IANG,kBAAwB;IACxB,yBAAkC;IAClC,sBAAkD;IAClD,sFAAkC;IAClC,mCAAyC;IACzC,0BAAsB;IAE1B,+FAKC;IAwCG,kCAA8C;CAIrD;yBA9jBwB,cAAc;4BAFmB,cAAc;qBAGnD,UAAU;2BACQ,wBAAwB;2BAAxB,wBAAwB;0BACrC,cAAc;iBAZvB,WAAW;yBAHH,mBAAmB;6BAQH,yBAAyB;AAwMlE;IACI;;;OAGG;IACH,kBAHW,MAAM,GACJ,OAAO,CAAC,YAAY,CAAC,CAIjC;IACD;;OAEG;IACH,iBAFa,OAAO,CAAC,MAAM,CAAC,CAI3B;IACD;;;;;;OAMG;IACH;;;;;;;;;;;OAWG;IACH,sBAHW,kBAAkB;;;;;;;;;;;;;;KAA2B,GAC3C,OAAO,CAAC,gBAAgB,CAAC,CAiFrC;CACJ;gCAjT+B,wBAAwB;yCAPf,yBAAyB;sBAP5C,gBAAgB"}

package/dist-node/geotiff.js

@@ -98,7 +98,77 @@ Object.defineProperty(exports, "BaseDecoder", { enumerable: true, get: function
  * `(TypedArray | TypedArray[]) & { height: number; width: number}`
  * @typedef {TypedArrayWithDimensions | TypedArrayArrayWithDimensions} ReadRasterResult
  */
+/**
+ * @typedef {Object} DecoderWorker
+ * Use the {@link Pool.bindParameters} method to get a decoder worker for
+ * a specific compression and its parameters.
+ *
+ * @property {(buffer: ArrayBuffer) => Promise<ArrayBuffer>} decode
+ *   A function that takes a compressed buffer and returns a promise resolving to the decoded buffer.
+ */
+/**
+ * @typedef {Object} ReadRastersOptions
+ * @property {Array<number>} [window] the subset to read data from in pixels. Whole window if not specified.
+ * @property {Array<number>} [samples] the selection of samples to read from. Default is all samples.
+ *     All samples if not specified.
+ * @property {Pool|null} [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 and `interleave` is
+ *     `false`, an array of fill values can be passed.
+ * @property {boolean|true|false} [interleave] whether the data shall be read
+ *     in one single array or separate arrays.
+ */
+/**
+ * @typedef {Object} ReadRGBOptions
+ * @property {Array<number>} [window] the subset to read data from in pixels. Whole window if not specified.
+ * @property {Pool|null} [pool=null] The optional decoder pool to use.
+ * @property {number} [width] The desired width of the output. When the width is no the
+ *                                 same as the images, resampling will be performed.
+ * @property {number} [height] The desired height of the output. When the width is no the
+ *                                  same as the images, resampling will be performed.
+ * @property {string} [resampleMethod='nearest'] The desired resampling method.
+ * @property {boolean} [enableAlpha=false] Enable reading alpha channel if present.
+ * @property {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
+ *                                       to be aborted
+ * @property {boolean|true|false} [interleave] whether the data shall be read
+ *     in one single array or separate arrays.
+ */
+/**
+ * @typedef {Object} BlockedSourceOptions
+ * @property {number|null} [blockSize=null] 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 {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.
+ */
+/**
+ * @overload
+ * @param {DataSlice} dataSlice
+ * @param {0x0002} fieldType
+ * @param {number} count
+ * @param {number} offset
+ * @returns {string}
+ */
+/**
+ * @param {DataSlice} dataSlice
+ * @param {import('./globals.js').FieldType} fieldType
+ * @param {number} count
+ * @param {number} offset
+ * @returns {TypedArray|Array<number>|string}
+ */
 function getValues(dataSlice, fieldType, count, offset) {
+    /** @type {TypedArray|Array|null} */
     let values = null;
     let readMethod = null;
     const fieldTypeLength = (0, globals_js_1.getFieldTypeSize)(fieldType);
@@ -156,7 +226,10 @@ function getValues(dataSlice, fieldType, count, offset) {
             readMethod = dataSlice.readFloat64;
             break;
         default:
-            throw new RangeError(`Invalid field type: ${fieldType}`);
+        // will throw below
+    }
+    if (values === null || readMethod === null) {
+        throw new RangeError(`Invalid field type: ${fieldType}`);
     }
     // normal fields
     if (!(fieldType === globals_js_1.fieldTypes.RATIONAL || fieldType === globals_js_1.fieldTypes.SRATIONAL)) {
@@ -171,7 +244,7 @@ function getValues(dataSlice, fieldType, count, offset) {
         }
     }
     if (fieldType === globals_js_1.fieldTypes.ASCII) {
-        return new TextDecoder('utf-8').decode(values);
+        return new TextDecoder('utf-8').decode(/** @type {Uint8Array} */ (values));
     }
     return values;
 }
@@ -186,6 +259,26 @@ class GeoTIFFImageIndexError extends Error {
     }
 }
 class GeoTIFFBase {
+    /**
+     * @param {number} [_index=0] the index of the image to return.
+     * @returns {Promise<GeoTIFFImage>} the image at the given index
+     */
+    async getImage(_index = 0) {
+        throw new Error('Not implemented');
+    }
+    /**
+     * @returns {Promise<number>} the number of internal subfile images
+     */
+    async getImageCount() {
+        throw new Error('Not implemented');
+    }
+    /**
+     * @typedef {Object} ReadRastersWindowOptions
+     * @property {number} [resX] desired Y resolution (world units per pixel)
+     * @property {number} [resY] desired X resolution (world units per pixel)
+     * @property {Array<number>} [bbox] the subset to read data from in
+     *     geographical coordinates. Whole image if not specified.
+     */
     /**
      * (experimental) Reads raster data from the best fitting image. This function uses
      * the image with the lowest resolution that is still a higher resolution than the
@@ -195,7 +288,7 @@ class GeoTIFFBase {
      * Then, the [readRasters]{@link GeoTIFFImage#readRasters} method of the selected
      * image is called and the result returned.
      * @see GeoTIFFImage.readRasters
-     * @param {import('./geotiffimage').ReadRasterOptions} [options={}] optional parameters
+     * @param {ReadRastersOptions & ReadRastersWindowOptions} options optional parameters
      * @returns {Promise<ReadRasterResult>} the decoded array(s), with `height` and `width`, as a promise
      */
     async readRasters(options = {}) {
@@ -285,12 +378,11 @@ class GeoTIFFBase {
  */
 /**
  * The abstraction for a whole GeoTIFF file.
- * @augments GeoTIFFBase
  */
 class GeoTIFF extends GeoTIFFBase {
     /**
      * @constructor
-     * @param {*} source The datasource to read from.
+     * @param {BaseSource} source The datasource to read from.
      * @param {boolean} littleEndian Whether the image uses little endian.
      * @param {boolean} bigTiff Whether the image uses bigTIFF conventions.
      * @param {number} firstIFDOffset The numeric byte-offset from the start of the image
@@ -360,7 +452,7 @@ class GeoTIFF extends GeoTIFFBase {
      * @returns {Promise<GeoTIFFImage>} the image at the given index
      */
     async getImage(index = 0) {
-        return new geotiffimage_js_1.default(await this.requestIFD(index), this.dataView, this.littleEndian, this.cache, this.source);
+        return new geotiffimage_js_1.default(await this.requestIFD(index), this.littleEndian, this.cache, this.source);
     }
     /**
      * Returns the count of the internal subfiles.
@@ -408,6 +500,7 @@ class GeoTIFF extends GeoTIFFBase {
                 slice = await this.getSlice(offset, metadataSize);
             }
             const fullString = getValues(slice, globals_js_1.fieldTypes.ASCII, metadataSize, offset);
+            /** @type {Object} */
             this.ghostValues = {};
             fullString
                 .split('\n')
@@ -422,7 +515,7 @@ class GeoTIFF extends GeoTIFFBase {
     /**
      * Parse a (Geo)TIFF file from the given source.
      *
-     * @param {*} source The source of data to parse from.
+     * @param {BaseSource} source The source of data to parse from.
      * @param {GeoTIFFOptions} [options] Additional options.
      * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
      *                               to be aborted
@@ -507,7 +600,11 @@ class MultiGeoTIFF extends GeoTIFFBase {
      * @returns {Promise<GeoTIFFImage>} the image at the given index
      */
     async getImage(index = 0) {
+        // Initialize this.imageCounts if not yet done
         await this.getImageCount();
+        if (!this.imageCounts) {
+            throw new Error('Image counts not available');
+        }
         await this.parseFileDirectoriesPerFile();
         let visited = 0;
         let relativeIndex = 0;
@@ -515,7 +612,7 @@ class MultiGeoTIFF extends GeoTIFFBase {
             const imageFile = this.imageFiles[i];
             for (let ii = 0; ii < this.imageCounts[i]; ii++) {
                 if (index === visited) {
-                    return new geotiffimage_js_1.default(await imageFile.requestIFD(relativeIndex), imageFile.dataView, imageFile.littleEndian, imageFile.cache, imageFile.source);
+                    return new geotiffimage_js_1.default(await imageFile.requestIFD(relativeIndex), imageFile.littleEndian, imageFile.cache, imageFile.source);
                 }
                 visited++;
                 relativeIndex++;
@@ -544,26 +641,26 @@ exports.MultiGeoTIFF = MultiGeoTIFF;
 /**
  * Creates a new GeoTIFF from a remote URL.
  * @param {string} url The URL to access the image from
- * @param {object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See {@link makeRemoteSource} for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
  *                               to be aborted
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 async function fromUrl(url, options = {}, signal) {
-    return GeoTIFF.fromSource((0, remote_js_1.makeRemoteSource)(url, options), signal);
+    return GeoTIFF.fromSource((0, remote_js_1.makeRemoteSource)(url, options), undefined, signal);
 }
 /**
  * Creates a new GeoTIFF from a custom {@link BaseClient}.
  * @param {BaseClient} client The client.
- * @param {object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See {@link makeRemoteSource} for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
  *                               to be aborted
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 async function fromCustomClient(client, options = {}, signal) {
-    return GeoTIFF.fromSource((0, remote_js_1.makeCustomSource)(client, options), signal);
+    return GeoTIFF.fromSource((0, remote_js_1.makeCustomSource)(client, options), undefined, signal);
 }
 /**
  * Construct a new GeoTIFF from an
@@ -574,7 +671,7 @@ async function fromCustomClient(client, options = {}, signal) {
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 async function fromArrayBuffer(arrayBuffer, signal) {
-    return GeoTIFF.fromSource((0, arraybuffer_js_1.makeBufferSource)(arrayBuffer), signal);
+    return GeoTIFF.fromSource((0, arraybuffer_js_1.makeBufferSource)(arrayBuffer), undefined, signal);
 }
 /**
  * Construct a GeoTIFF from a local file path. This uses the node
@@ -589,7 +686,7 @@ async function fromArrayBuffer(arrayBuffer, signal) {
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 async function fromFile(path, signal) {
-    return GeoTIFF.fromSource((0, file_js_1.makeFileSource)(path), signal);
+    return GeoTIFF.fromSource((0, file_js_1.makeFileSource)(path), undefined, signal);
 }
 /**
  * Construct a GeoTIFF from an HTML
@@ -602,13 +699,13 @@ async function fromFile(path, signal) {
  * @returns {Promise<GeoTIFF>} The resulting GeoTIFF file.
  */
 async function fromBlob(blob, signal) {
-    return GeoTIFF.fromSource((0, filereader_js_1.makeFileReaderSource)(blob), signal);
+    return GeoTIFF.fromSource((0, filereader_js_1.makeFileReaderSource)(blob), undefined, signal);
 }
 /**
  * Construct a MultiGeoTIFF from the given URLs.
  * @param {string} mainUrl The URL for the main file.
  * @param {string[]} overviewUrls An array of URLs for the overview images.
- * @param {Object} [options] Additional options to pass to the source.
+ * @param {RemoteSourceOptions} [options] Additional options to pass to the source.
  *                           See [makeRemoteSource]{@link module:source.makeRemoteSource}
  *                           for details.
  * @param {AbortSignal} [signal] An AbortSignal that may be signalled if the request is
@@ -616,14 +713,15 @@ async function fromBlob(blob, signal) {
  * @returns {Promise<MultiGeoTIFF>} The resulting MultiGeoTIFF file.
  */
 async function fromUrls(mainUrl, overviewUrls = [], options = {}, signal) {
-    const mainFile = await GeoTIFF.fromSource((0, remote_js_1.makeRemoteSource)(mainUrl, options), signal);
-    const overviewFiles = await Promise.all(overviewUrls.map((url) => GeoTIFF.fromSource((0, remote_js_1.makeRemoteSource)(url, options))));
+    const mainFile = await GeoTIFF.fromSource((0, remote_js_1.makeRemoteSource)(mainUrl, options), undefined, signal);
+    const overviewFiles = await Promise.all(overviewUrls.map((url) => GeoTIFF.fromSource((0, remote_js_1.makeRemoteSource)(url, options), undefined, signal)));
     return new MultiGeoTIFF(mainFile, overviewFiles);
 }
 /**
  * Main creating function for GeoTIFF files.
- * @param {(Array)} array of pixel values
- * @returns {metadata} metadata
+ * @param {Array} values of pixel values
+ * @param {Object} metadata
+ * @returns {ArrayBuffer}
  */
 function writeArrayBuffer(values, metadata) {
     return (0, geotiffwriter_js_1.writeGeotiff)(values, metadata);