geotiff 3.0.0 → 3.0.1

package/dist-module/compression/basedecoder.d.ts

@@ -1,6 +1,10 @@
 export default class BaseDecoder {
     constructor(parameters: any);
     parameters: any;
+    /**
+     * @abstract
+     */
+    decodeBlock(_buffer: any): void;
     decode(buffer: any): Promise<any>;
 }
 //# sourceMappingURL=basedecoder.d.ts.map

package/dist-module/compression/basedecoder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"basedecoder.d.ts","sourceRoot":"","sources":["../../src/compression/basedecoder.js"],"names":[],"mappings":"AAEA;IACE,6BAEC;IADC,gBAA4B;IAG9B,kCAaC;CACF"}
+{"version":3,"file":"basedecoder.d.ts","sourceRoot":"","sources":["../../src/compression/basedecoder.js"],"names":[],"mappings":"AAEA;IACE,6BAEC;IADC,gBAA4B;IAG9B;;OAEG;IACH,gCAEC;IAED,kCAaC;CACF"}

package/dist-module/compression/basedecoder.js

@@ -3,6 +3,12 @@ export default class BaseDecoder {
     constructor(parameters) {
         this.parameters = parameters;
     }
+    /**
+     * @abstract
+     */
+    decodeBlock(_buffer) {
+        throw new Error('decodeBlock not implemented');
+    }
     async decode(buffer) {
         const decoded = await this.decodeBlock(buffer);
         const { tileWidth, tileHeight, predictor, bitsPerSample, planarConfiguration, } = this.parameters;

package/dist-module/compression/index.d.ts

@@ -6,10 +6,10 @@
  * Register a decoder for a specific compression method or a range of compressions
  * @param {(NumberOrUndefined|(NumberOrUndefined[]))} cases ids of the compression methods to register for
  * @param {function():Promise} importFn the function to import the decoder
- * @param {function():Promise} decoderParameterFn
+ * @param {function(import("../imagefiledirectory").ImageFileDirectory):Promise} decoderParameterFn
  * @param {boolean} preferWorker_ Whether to prefer running the decoder in a worker
  */
-export function addDecoder(cases: (NumberOrUndefined | (NumberOrUndefined[])), importFn: () => Promise<any>, decoderParameterFn?: () => Promise<any>, preferWorker_?: boolean): void;
+export function addDecoder(cases: (NumberOrUndefined | (NumberOrUndefined[])), importFn: () => Promise<any>, decoderParameterFn?: (arg0: import("../imagefiledirectory").ImageFileDirectory) => Promise<any>, preferWorker_?: boolean): void;
 /**
  * Get the required decoder parameters for a specific compression method
  * @param {NumberOrUndefined} compression
@@ -25,10 +25,10 @@ export function getDecoderParameters(compression: NumberOrUndefined, fileDirecto
 export function getDecoder(compression: number, decoderParameters: DecoderParameters): Promise<import("./basedecoder.js").default>;
 /**
  * Whether to prefer running the decoder in a worker
- * @param {object} fileDirectory the file directory of the image
+ * @param {number|undefined} compression the compression method identifier
  * @returns {boolean}
  */
-export function preferWorker(compression: any): boolean;
+export function preferWorker(compression: number | undefined): boolean;
 export type DecoderParameters = {
     tileWidth: number;
     tileHeight: number;

package/dist-module/compression/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.js"],"names":[],"mappings":"AA6BA;;;GAGG;AAEH;;;;;;GAMG;AACH,kCALW,CAAC,iBAAiB,GAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC,YACzC,kBAAkB,uBAClB,kBAAkB,kBAClB,OAAO,QASjB;AAED;;;;GAIG;AACH,kDAHW,iBAAiB,iBACjB,OAAO,0BAA0B,EAAE,kBAAkB,gBAQ/D;AAED;;;;;GAKG;AACH,wCAJW,MAAM,qBACN,iBAAiB,GACf,OAAO,CAAC,OAAO,kBAAkB,EAAE,OAAO,CAAC,CASvD;AAED;;;;GAIG;AACH,gDAFa,OAAO,CAOnB;;eApFa,MAAM;gBACN,MAAM;yBACN,MAAM;mBACN,MAAM;eACN,MAAM;;;;;gCAuBP,CAAC,MAAM,GAAC,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compression/index.js"],"names":[],"mappings":"AA6BA;;;GAGG;AAEH;;;;;;GAMG;AACH,kCALW,CAAC,iBAAiB,GAAC,CAAC,iBAAiB,EAAE,CAAC,CAAC,YACzC,kBAAkB,uBAClB,CAAS,IAAkD,EAAlD,OAAO,uBAAuB,EAAE,kBAAkB,iBAAS,kBACpE,OAAO,QASjB;AAED;;;;GAIG;AACH,kDAHW,iBAAiB,iBACjB,OAAO,0BAA0B,EAAE,kBAAkB,gBAQ/D;AAED;;;;;GAKG;AACH,wCAJW,MAAM,qBACN,iBAAiB,GACf,OAAO,CAAC,OAAO,kBAAkB,EAAE,OAAO,CAAC,CASvD;AAED;;;;GAIG;AACH,0CAHW,MAAM,GAAC,SAAS,GACd,OAAO,CAOnB;;eApFa,MAAM;gBACN,MAAM;yBACN,MAAM;mBACN,MAAM;eACN,MAAM;;;;;gCAuBP,CAAC,MAAM,GAAC,SAAS,CAAC"}

package/dist-module/compression/index.js

@@ -9,8 +9,8 @@ const registry = new Map();
  */
 /**
  * Default decoder parameter retrieval function
- * @param {import('../imagefiledirectory.js').ImageFileDirectory} fileDirectory
- * @returns {DecoderParameters}
+ * @param {import("../imagefiledirectory").ImageFileDirectory} fileDirectory
+ * @returns {Promise<DecoderParameters>}
  */
 async function defaultDecoderParameterFn(fileDirectory) {
     const isTiled = !fileDirectory.hasTag('StripOffsets');
@@ -30,7 +30,7 @@ async function defaultDecoderParameterFn(fileDirectory) {
  * Register a decoder for a specific compression method or a range of compressions
  * @param {(NumberOrUndefined|(NumberOrUndefined[]))} cases ids of the compression methods to register for
  * @param {function():Promise} importFn the function to import the decoder
- * @param {function():Promise} decoderParameterFn
+ * @param {function(import("../imagefiledirectory").ImageFileDirectory):Promise} decoderParameterFn
  * @param {boolean} preferWorker_ Whether to prefer running the decoder in a worker
  */
 export function addDecoder(cases, importFn, decoderParameterFn = defaultDecoderParameterFn, preferWorker_ = true) {
@@ -69,7 +69,7 @@ export async function getDecoder(compression, decoderParameters) {
 }
 /**
  * Whether to prefer running the decoder in a worker
- * @param {object} fileDirectory the file directory of the image
+ * @param {number|undefined} compression the compression method identifier
  * @returns {boolean}
  */
 export function preferWorker(compression) {

package/dist-module/compression/jpeg.d.ts

@@ -2,6 +2,11 @@ export default class JpegDecoder extends BaseDecoder {
     reader: JpegStreamReader;
     decodeBlock(buffer: any): ArrayBuffer;
 }
+export type HuffmanNode = (number | HuffmanNode)[];
+export type Code = {
+    children: HuffmanNode;
+    index: number;
+};
 import BaseDecoder from './basedecoder.js';
 declare class JpegStreamReader {
     jfif: {
@@ -25,8 +30,8 @@ declare class JpegStreamReader {
     quantizationTables: any[];
     huffmanTablesAC: any[];
     huffmanTablesDC: any[];
+    frames: any[];
     resetFrames(): void;
-    frames: any[] | undefined;
     parse(data: any): void;
     resetInterval: number | undefined;
     getResult(): Uint8Array<ArrayBuffer>;

package/dist-module/compression/jpeg.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"jpeg.d.ts","sourceRoot":"","sources":["../../src/compression/jpeg.js"],"names":[],"mappings":"AAk3BA;IAGI,yBAAoC;IAMtC,sCAIC;CACF;wBAh4BuB,kBAAkB;AAwjB1C;IAEI;;;;;;;;;;;aAAgB;IAChB;;;;;aAAiB;IAEjB,0BAA4B;IAC5B,uBAAyB;IACzB,uBAAyB;IAI3B,oBAEC;IADC,0BAAgB;IAGlB,uBA0PC;IA5CO,kCAAiC;IA8CzC,qCA4CC;CACF"}
+{"version":3,"file":"jpeg.d.ts","sourceRoot":"","sources":["../../src/compression/jpeg.js"],"names":[],"mappings":"AAg6BA;IAGI,yBAAoC;IAMtC,sCAIC;CACF;0BA13Ba,CAAC,MAAM,GAAC,WAAW,CAAC,EAAE;mBACtB;IAAC,QAAQ,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC;wBArD5B,kBAAkB;AAqmB1C;IAEI;;;;;;;;;;;aAAgB;IAChB;;;;;aAAiB;IAEjB,0BAA4B;IAC5B,uBAAyB;IACzB,uBAAyB;IACzB,cAAgB;IAGlB,oBAEC;IAED,uBA2PC;IA5CO,kCAAiC;IA8CzC,qCA4CC;CACF"}

package/dist-module/compression/jpeg.js

@@ -45,22 +45,38 @@ const dctCos6 = 1567; // cos(6*pi/16)
 const dctSin6 = 3784; // sin(6*pi/16)
 const dctSqrt2 = 5793; // sqrt(2)
 const dctSqrt1d2 = 2896; // sqrt(2) / 2
+/** @typedef {(number|HuffmanNode)[]} HuffmanNode */
+/** @typedef {{children: HuffmanNode, index: number}} Code */
+/**
+ * @param {Uint8Array<ArrayBuffer>} codeLengths
+ * @param {Uint8Array<ArrayBuffer>} values
+ * @returns {HuffmanNode}
+ */
 function buildHuffmanTable(codeLengths, values) {
     let k = 0;
+    /** @type {Array<Code>} */
     const code = [];
     let length = 16;
     while (length > 0 && !codeLengths[length - 1]) {
         --length;
     }
     code.push({ children: [], index: 0 });
+    /** @type {Code|undefined} */
     let p = code[0];
+    /** @type {Code|undefined} */
     let q;
     for (let i = 0; i < length; i++) {
         for (let j = 0; j < codeLengths[i]; j++) {
             p = code.pop();
+            if (!p) {
+                throw new Error('buildHuffmanTable: codeLength mismatch');
+            }
             p.children[p.index] = values[k];
             while (p.index > 0) {
                 p = code.pop();
+                if (!p) {
+                    throw new Error('buildHuffmanTable: codeLength mismatch');
+                }
             }
             p.index++;
             code.push(p);
@@ -131,6 +147,9 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
     }
     function receiveAndExtend(length) {
         const n = receive(length);
+        if (n === undefined) {
+            return undefined;
+        }
         if (n >= 1 << (length - 1)) {
             return n;
         }
@@ -144,6 +163,9 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
         let k = 1;
         while (k < 64) {
             const rs = decodeHuffman(component.huffmanTableAC);
+            if (rs === null) {
+                throw new Error('Unexpected end of data in AC coefficient decoding');
+            }
             const s = rs & 15;
             const r = rs >> 4;
             if (s === 0) {
@@ -162,7 +184,11 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
     }
     function decodeDCFirst(component, zz) {
         const t = decodeHuffman(component.huffmanTableDC);
-        const diff = t === 0 ? 0 : (receiveAndExtend(t) << successive);
+        const value = receiveAndExtend(t);
+        if (value === undefined) {
+            throw new Error('Unexpected end of data in DC coefficient decoding');
+        }
+        const diff = t === 0 ? 0 : (value << successive);
         component.pred += diff;
         zz[0] = component.pred;
     }
@@ -179,11 +205,18 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
         const e = spectralEnd;
         while (k <= e) {
             const rs = decodeHuffman(component.huffmanTableAC);
+            if (rs === null) {
+                throw new Error('Unexpected end of data in AC coefficient decoding');
+            }
             const s = rs & 15;
             const r = rs >> 4;
             if (s === 0) {
                 if (r < 15) {
-                    eobrun = receive(r) + (1 << r) - 1;
+                    const value = receive(r);
+                    if (value === undefined) {
+                        throw new Error('Unexpected end of data in AC coefficient decoding');
+                    }
+                    eobrun = value + (1 << r) - 1;
                     break;
                 }
                 k += 16;
@@ -191,7 +224,11 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
             else {
                 k += r;
                 const z = dctZigZag[k];
-                zz[z] = receiveAndExtend(s) * (1 << successive);
+                const value = receiveAndExtend(s);
+                if (value === undefined) {
+                    throw new Error('Unexpected end of data in AC coefficient decoding');
+                }
+                zz[z] = value * (1 << successive);
                 k++;
             }
         }
@@ -208,11 +245,18 @@ function decodeScan(data, initialOffset, frame, components, resetInterval, spect
             switch (successiveACState) {
                 case 0: { // initial state
                     const rs = decodeHuffman(component.huffmanTableAC);
+                    if (rs === null) {
+                        throw new Error('Unexpected end of data in AC coefficient decoding');
+                    }
                     const s = rs & 15;
                     r = rs >> 4;
                     if (s === 0) {
                         if (r < 15) {
-                            eobrun = receive(r) + (1 << r);
+                            const value = receive(r);
+                            if (value === undefined) {
+                                throw new Error('Unexpected end of data in AC coefficient decoding');
+                            }
+                            eobrun = value + (1 << r);
                             successiveACState = 4;
                         }
                         else {
@@ -547,7 +591,7 @@ class JpegStreamReader {
         this.quantizationTables = [];
         this.huffmanTablesAC = [];
         this.huffmanTablesDC = [];
-        this.resetFrames();
+        this.frames = [];
     }
     resetFrames() {
         this.frames = [];
@@ -699,6 +743,7 @@ class JpegStreamReader {
                         scanLines: readUint16(),
                         samplesPerLine: readUint16(),
                         components: {},
+                        /** @type {any[]} */
                         componentsOrder: [],
                     };
                     const componentsCount = data[offset++];

package/dist-module/compression/lzw.js

@@ -122,6 +122,6 @@ function decompress(input) {
 }
 export default class LZWDecoder extends BaseDecoder {
     decodeBlock(buffer) {
-        return decompress(buffer, false).buffer;
+        return decompress(buffer).buffer;
     }
 }

package/dist-module/compression/webimage.d.ts

@@ -5,7 +5,7 @@
  * formats like WebP when supported.
  */
 export default class WebImageDecoder extends BaseDecoder {
-    decodeBlock(buffer: any): Promise<any>;
+    decodeBlock(buffer: any): Promise<ArrayBuffer>;
 }
 import BaseDecoder from './basedecoder.js';
 //# sourceMappingURL=webimage.d.ts.map

package/dist-module/compression/webimage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webimage.d.ts","sourceRoot":"","sources":["../../src/compression/webimage.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAUE,uCAoCC;CACF;wBAvDuB,kBAAkB"}
+{"version":3,"file":"webimage.d.ts","sourceRoot":"","sources":["../../src/compression/webimage.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH;IAUE,+CAoCC;CACF;wBAvDuB,kBAAkB"}

package/dist-module/compression/webimage.js

@@ -29,7 +29,7 @@ export default class WebImageDecoder extends BaseDecoder {
         }
         // Draw the image onto the canvas to extract the pixel data.
         // Note: createImageBitmap always returns RGBA data.
-        const ctx = canvas.getContext('2d');
+        const ctx = /** @type {CanvasRenderingContext2D} */ (canvas.getContext('2d'));
         ctx.drawImage(imageBitmap, 0, 0);
         const imageData = ctx.getImageData(0, 0, imageBitmap.width, imageBitmap.height).data;
         // Return the correct channels to the caller

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

@@ -1 +1 @@
-{"version":3,"file":"dataslice.d.ts","sourceRoot":"","sources":["../src/dataslice.js"],"names":[],"mappings":"AAAA;IACE,iFAKC;IAJC,yBAA0C;IAC1C,kBAA+B;IAC/B,mBAAiC;IACjC,cAAuB;IAGzB,uBAEC;IAED,oBAEC;IAED,wBAEC;IAED,mBAEC;IAED,kBAEC;IAED,0CAEC;IAED,+BAIC;IAED,8BAIC;IAED,gCAIC;IAED,+BAIC;IAED,gCAIC;IAED,+BAIC;IAED,iCAIC;IAED,iCAIC;IAED,gCAuBC;IAGD,+BAyBC;IAED,gCAKC;CACF"}
+{"version":3,"file":"dataslice.d.ts","sourceRoot":"","sources":["../src/dataslice.js"],"names":[],"mappings":"AAAA;IACE,iFAKC;IAJC,yBAA0C;IAC1C,kBAA+B;IAC/B,mBAAiC;IACjC,cAAuB;IAGzB,uBAEC;IAED,oBAEC;IAED,wBAEC;IAED,mBAEC;IAED,kBAEC;IAED,0CAEC;IAED,+BAEC;IAED,8BAEC;IAED,gCAIC;IAED,+BAIC;IAED,gCAIC;IAED,+BAIC;IAED,iCAIC;IAED,iCAIC;IAED,gCAuBC;IAGD,+BAyBC;IAED,gCAKC;CACF"}

package/dist-module/dataslice.js

@@ -24,10 +24,10 @@ export default class DataSlice {
         return this.sliceOffset <= offset && this.sliceTop >= offset + length;
     }
     readUint8(offset) {
-        return this._dataView.getUint8(offset - this._sliceOffset, this._littleEndian);
+        return this._dataView.getUint8(offset - this._sliceOffset);
     }
     readInt8(offset) {
-        return this._dataView.getInt8(offset - this._sliceOffset, this._littleEndian);
+        return this._dataView.getInt8(offset - this._sliceOffset);
     }
     readUint16(offset) {
         return this._dataView.getUint16(offset - this._sliceOffset, this._littleEndian);

package/dist-module/dataview64.d.ts

@@ -4,8 +4,8 @@ export default class DataView64 {
     get buffer(): any;
     getUint64(offset: any, littleEndian: any): number;
     getInt64(offset: any, littleEndian: any): number;
-    getUint8(offset: any, littleEndian: any): number;
-    getInt8(offset: any, littleEndian: any): number;
+    getUint8(offset: any): number;
+    getInt8(offset: any): number;
     getUint16(offset: any, littleEndian: any): number;
     getInt16(offset: any, littleEndian: any): number;
     getUint32(offset: any, littleEndian: any): number;

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

@@ -1 +1 @@
-{"version":3,"file":"dataview64.d.ts","sourceRoot":"","sources":["../src/dataview64.js"],"names":[],"mappings":"AAEA;IACE,8BAEC;IADC,yBAA0C;IAG5C,kBAEC;IAED,kDAuBC;IAGD,iDAsBC;IAED,iDAEC;IAED,gDAEC;IAED,kDAEC;IAED,iDAEC;IAED,kDAEC;IAED,iDAEC;IAED,mDAEC;IAED,mDAEC;IAED,mDAEC;CACF"}
+{"version":3,"file":"dataview64.d.ts","sourceRoot":"","sources":["../src/dataview64.js"],"names":[],"mappings":"AAEA;IACE,8BAEC;IADC,yBAA0C;IAG5C,kBAEC;IAED,kDAuBC;IAGD,iDAsBC;IAED,8BAEC;IAED,6BAEC;IAED,kDAEC;IAED,iDAEC;IAED,kDAEC;IAED,iDAEC;IAED,mDAEC;IAED,mDAEC;IAED,mDAEC;CACF"}

package/dist-module/dataview64.js

@@ -50,11 +50,11 @@ export default class DataView64 {
         }
         return value;
     }
-    getUint8(offset, littleEndian) {
-        return this._dataView.getUint8(offset, littleEndian);
+    getUint8(offset) {
+        return this._dataView.getUint8(offset);
     }
-    getInt8(offset, littleEndian) {
-        return this._dataView.getInt8(offset, littleEndian);
+    getInt8(offset) {
+        return this._dataView.getInt8(offset);
     }
     getUint16(offset, littleEndian) {
         return this._dataView.getUint16(offset, littleEndian);

package/dist-module/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?: Object, 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: Object): 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,117 @@ export type TypedArrayArrayWithDimensions = TypedArray[] & Dimensions;
  * `(TypedArray | TypedArray[]) & { height: number; width: number}`
  */
 export type ReadRasterResult = TypedArrayWithDimensions | TypedArrayArrayWithDimensions;
+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?: Object | undefined;
+    /**
+     * 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 +218,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: Object;
     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 +260,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 +281,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 +293,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 +318,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 };