geotiff 3.0.0 → 3.0.1

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 {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();
@@ -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 {import("./geotiff").Pool|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];
     }

package/dist-module/globals.d.ts

@@ -1,63 +1,67 @@
+/** @typedef {fieldTypeSizes[keyof typeof fieldTypeSizes]} FieldTypeSize */
 /**
  * Get the byte size for a given field type.
- * @param {number} fieldType The TIFF field type constant
+ * @param {FieldType} fieldType The TIFF field type constant
  * @returns {number} The size in bytes
  * @throws {RangeError} If the field type is invalid
  */
-export function getFieldTypeSize(fieldType: number): number;
+export function getFieldTypeSize(fieldType: FieldType): number;
 /**
  * Registers a new field tag
  * @param {number} tag the numeric tiff tag
  * @param {string} name the name of the tag that will be reported in the IFD
- * @param {string|number} type the tags data type
+ * @param {string|number|undefined} type the tags data type
  * @param {Boolean} isArray whether the tag is an array
  * @param {boolean} [eager=false] whether to eagerly fetch deferred fields.
  *                                 When false (default), tags are loaded lazily on-demand.
  *                                 When true, all tags are loaded immediately during parsing.
  */
-export function registerTag(tag: number, name: string, type?: string | number, isArray?: boolean, eager?: boolean): void;
+export function registerTag(tag: number, name: string, type: string | number | undefined, isArray?: boolean, eager?: boolean): void;
 /**
  * @param {number|string} tagIdentifier The field tag ID or name
  * @returns {number} the resolved tag ID
  */
 export function resolveTag(tagIdentifier: number | string): number;
 export function getTag(tagIdentifier: any): any;
-export namespace fieldTypes {
-    let BYTE: number;
-    let ASCII: number;
-    let SHORT: number;
-    let LONG: number;
-    let RATIONAL: number;
-    let SBYTE: number;
-    let UNDEFINED: number;
-    let SSHORT: number;
-    let SLONG: number;
-    let SRATIONAL: number;
-    let FLOAT: number;
-    let DOUBLE: number;
-    let IFD: number;
-    let LONG8: number;
-    let SLONG8: number;
-    let IFD8: number;
-}
-export const fieldTypeSizes: {
-    [fieldTypes.BYTE]: number;
-    [fieldTypes.ASCII]: number;
-    [fieldTypes.SBYTE]: number;
-    [fieldTypes.UNDEFINED]: number;
-    [fieldTypes.SHORT]: number;
-    [fieldTypes.SSHORT]: number;
-    [fieldTypes.LONG]: number;
-    [fieldTypes.SLONG]: number;
-    [fieldTypes.FLOAT]: number;
-    [fieldTypes.IFD]: number;
-    [fieldTypes.RATIONAL]: number;
-    [fieldTypes.SRATIONAL]: number;
-    [fieldTypes.DOUBLE]: number;
-    [fieldTypes.LONG8]: number;
-    [fieldTypes.SLONG8]: number;
-    [fieldTypes.IFD8]: number;
-};
+export const fieldTypes: Readonly<{
+    BYTE: 1;
+    ASCII: 2;
+    SHORT: 3;
+    LONG: 4;
+    RATIONAL: 5;
+    SBYTE: 6;
+    UNDEFINED: 7;
+    SSHORT: 8;
+    SLONG: 9;
+    SRATIONAL: 10;
+    FLOAT: 11;
+    DOUBLE: 12;
+    IFD: 13;
+    LONG8: 16;
+    SLONG8: 17;
+    IFD8: 18;
+}>;
+/** @typedef {keyof fieldTypes} FieldTypeName */
+/** @typedef {fieldTypes[keyof typeof fieldTypes]} FieldType */
+/** @typedef {Record<FieldTypeName, number>} FieldTypeSizes */
+export const fieldTypeSizes: Readonly<{
+    1: 1;
+    2: 1;
+    6: 1;
+    7: 1;
+    3: 2;
+    8: 2;
+    4: 4;
+    9: 4;
+    11: 4;
+    13: 4;
+    5: 8;
+    10: 8;
+    12: 8;
+    16: 8;
+    17: 8;
+    18: 8;
+}>;
 /**
  * Maps tag names to their numeric values
  */
@@ -199,5 +203,9 @@ export const geoKeyNames: Readonly<{
  * @type {Record<GeoKeyName, number>}
  */
 export const geoKeys: Record<GeoKeyName, number>;
+export type FieldTypeSize = 1 | 2 | 4 | 8;
+export type FieldTypeName = "BYTE" | "ASCII" | "SHORT" | "LONG" | "RATIONAL" | "SBYTE" | "UNDEFINED" | "SSHORT" | "SLONG" | "SRATIONAL" | "FLOAT" | "DOUBLE" | "IFD" | "LONG8" | "SLONG8" | "IFD8";
+export type FieldType = 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 16 | 17 | 18;
+export type FieldTypeSizes = Record<FieldTypeName, number>;
 export type GeoKeyName = "GTModelTypeGeoKey" | "GTRasterTypeGeoKey" | "GTCitationGeoKey" | "GeographicTypeGeoKey" | "GeogCitationGeoKey" | "GeogGeodeticDatumGeoKey" | "GeogPrimeMeridianGeoKey" | "GeogLinearUnitsGeoKey" | "GeogLinearUnitSizeGeoKey" | "GeogAngularUnitsGeoKey" | "GeogAngularUnitSizeGeoKey" | "GeogEllipsoidGeoKey" | "GeogSemiMajorAxisGeoKey" | "GeogSemiMinorAxisGeoKey" | "GeogInvFlatteningGeoKey" | "GeogAzimuthUnitsGeoKey" | "GeogPrimeMeridianLongGeoKey" | "GeogTOWGS84GeoKey" | "ProjectedCSTypeGeoKey" | "PCSCitationGeoKey" | "ProjectionGeoKey" | "ProjCoordTransGeoKey" | "ProjLinearUnitsGeoKey" | "ProjLinearUnitSizeGeoKey" | "ProjStdParallel1GeoKey" | "ProjStdParallel2GeoKey" | "ProjNatOriginLongGeoKey" | "ProjNatOriginLatGeoKey" | "ProjFalseEastingGeoKey" | "ProjFalseNorthingGeoKey" | "ProjFalseOriginLongGeoKey" | "ProjFalseOriginLatGeoKey" | "ProjFalseOriginEastingGeoKey" | "ProjFalseOriginNorthingGeoKey" | "ProjCenterLongGeoKey" | "ProjCenterLatGeoKey" | "ProjCenterEastingGeoKey" | "ProjCenterNorthingGeoKey" | "ProjScaleAtNatOriginGeoKey" | "ProjScaleAtCenterGeoKey" | "ProjAzimuthAngleGeoKey" | "ProjStraightVertPoleLongGeoKey" | "ProjRectifiedGridAngleGeoKey" | "VerticalCSTypeGeoKey" | "VerticalCitationGeoKey" | "VerticalDatumGeoKey" | "VerticalUnitsGeoKey";
 //# sourceMappingURL=globals.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../src/globals.js"],"names":[],"mappings":"AAwCA;;;;;GAKG;AACH,4CAJW,MAAM,GACJ,MAAM,CASlB;AA+ND;;;;;;;;;GASG;AACH,iCARW,MAAM,QACN,MAAM,SACN,MAAM,GAAC,MAAM,6BAEb,OAAO,QAajB;AAMD;;;GAGG;AACH,0CAHW,MAAM,GAAC,MAAM,GACX,MAAM,CAOlB;AAED,gDAEC;;;;;;;;;;;;;;;;;;;AApSD;IACE,CAAC,UAAU,CAAC,IAAI,CAAC,SAAG;IACpB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAG;IACrB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAG;IACrB,CAAC,UAAU,CAAC,SAAS,CAAC,SAAG;IACzB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAG;IACrB,CAAC,UAAU,CAAC,MAAM,CAAC,SAAG;IACtB,CAAC,UAAU,CAAC,IAAI,CAAC,SAAG;IACpB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAG;IACrB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAG;IACrB,CAAC,UAAU,CAAC,GAAG,CAAC,SAAG;IACnB,CAAC,UAAU,CAAC,QAAQ,CAAC,SAAG;IACxB,CAAC,UAAU,CAAC,SAAS,CAAC,SAAG;IACzB,CAAC,UAAU,CAAC,MAAM,CAAC,SAAG;IACtB,CAAC,UAAU,CAAC,KAAK,CAAC,SAAG;IACrB,CAAC,UAAU,CAAC,MAAM,CAAC,SAAG;IACtB,CAAC,UAAU,CAAC,IAAI,CAAC,SAAG;EACpB;AAmOF;;GAEG;AACH,sBAAuB;AAEvB;;GAEG;AACH,gCAAiC;AA0CjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDE;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,kEAAkE;AAElE;;GAEG;AACH,sBAFU,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAEV"}
+{"version":3,"file":"globals.d.ts","sourceRoot":"","sources":["../src/globals.js"],"names":[],"mappings":"AA6CA,2EAA2E;AAE3E;;;;;GAKG;AACH,4CAJW,SAAS,GACP,MAAM,CASlB;AA+ND;;;;;;;;;GASG;AACH,iCARW,MAAM,QACN,MAAM,QACN,MAAM,GAAC,MAAM,GAAC,SAAS,6BAEvB,OAAO,QAajB;AAMD;;;GAGG;AACH,0CAHW,MAAM,GAAC,MAAM,GACX,MAAM,CAOlB;AAED,gDAEC;AAhUD;;;;;;;;;;;;;;;;;GAmBG;AAEH,gDAAgD;AAEhD,+DAA+D;AAE/D,8DAA8D;AAC9D;;;;;;;;;;;;;;;;;GAiBG;AAqOH;;GAEG;AACH,sBAAuB;AAEvB;;GAEG;AACH,gCAAiC;AA0CjC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDE;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AAEH,kEAAkE;AAElE;;GAEG;AACH,sBAFU,MAAM,CAAC,UAAU,EAAE,MAAM,CAAC,CAEkC;;;;6BArbxD,MAAM,CAAC,aAAa,EAAE,MAAM,CAAC"}

package/dist-module/globals.js

@@ -1,4 +1,4 @@
-export const fieldTypes = {
+export const fieldTypes = Object.freeze({
     BYTE: 0x0001,
     ASCII: 0x0002,
     SHORT: 0x0003,
@@ -17,8 +17,11 @@ export const fieldTypes = {
     LONG8: 0x0010,
     SLONG8: 0x0011,
     IFD8: 0x0012,
-};
-export const fieldTypeSizes = {
+});
+/** @typedef {keyof fieldTypes} FieldTypeName */
+/** @typedef {fieldTypes[keyof typeof fieldTypes]} FieldType */
+/** @typedef {Record<FieldTypeName, number>} FieldTypeSizes */
+export const fieldTypeSizes = Object.freeze({
     [fieldTypes.BYTE]: 1,
     [fieldTypes.ASCII]: 1,
     [fieldTypes.SBYTE]: 1,
@@ -35,10 +38,11 @@ export const fieldTypeSizes = {
     [fieldTypes.LONG8]: 8,
     [fieldTypes.SLONG8]: 8,
     [fieldTypes.IFD8]: 8,
-};
+});
+/** @typedef {fieldTypeSizes[keyof typeof fieldTypeSizes]} FieldTypeSize */
 /**
  * Get the byte size for a given field type.
- * @param {number} fieldType The TIFF field type constant
+ * @param {FieldType} fieldType The TIFF field type constant
  * @returns {number} The size in bytes
  * @throws {RangeError} If the field type is invalid
  */
@@ -129,8 +133,8 @@ const tagSource = [
         isArray: true,
         eager: true,
     },
-    { tag: 340, name: 'SMinSampleValue', type: fieldTypes.Any, isArray: true },
-    { tag: 341, name: 'SMaxSampleValue', type: fieldTypes.Any, isArray: true },
+    { tag: 340, name: 'SMinSampleValue', isArray: true },
+    { tag: 341, name: 'SMaxSampleValue', isArray: true },
     { tag: 342, name: 'TransferRange', type: fieldTypes.SHORT, isArray: true },
     { tag: 512, name: 'JPEGProc', type: fieldTypes.SHORT },
     { tag: 513, name: 'JPEGInterchangeFormat', type: fieldTypes.LONG },
@@ -261,13 +265,13 @@ export const tagDefinitions = {};
  * Registers a new field tag
  * @param {number} tag the numeric tiff tag
  * @param {string} name the name of the tag that will be reported in the IFD
- * @param {string|number} type the tags data type
+ * @param {string|number|undefined} type the tags data type
  * @param {Boolean} isArray whether the tag is an array
  * @param {boolean} [eager=false] whether to eagerly fetch deferred fields.
  *                                 When false (default), tags are loaded lazily on-demand.
  *                                 When true, all tags are loaded immediately during parsing.
  */
-export function registerTag(tag, name, type = undefined, isArray = false, eager = false) {
+export function registerTag(tag, name, type, isArray = false, eager = false) {
     tags[name] = tag;
     tagDefinitions[tag] = { tag, name, type: typeof type === 'string' ? fieldTypes[type] : type, isArray, eager };
 }
@@ -419,7 +423,7 @@ export const geoKeyNames = Object.freeze({
 /**
  * @type {Record<GeoKeyName, number>}
  */
-export const geoKeys = {};
+export const geoKeys = /** @type {Record<GeoKeyName, number>} */ ({});
 for (const key in geoKeyNames) {
     if (geoKeyNames.hasOwnProperty(key)) {
         geoKeys[geoKeyNames[key]] = parseInt(key, 10);

package/dist-module/imagefiledirectory.d.ts

@@ -41,11 +41,11 @@ export class ImageFileDirectory {
      * Parses the GeoTIFF GeoKeyDirectory tag into a structured object.
      * The GeoKeyDirectory is a special TIFF tag that contains geographic metadata
      * in a key-value format as defined by the GeoTIFF specification.
-     * @returns {Record<import('./globals.js').GeoKeyName, *>|null} Parsed geo key directory
+     * @returns {Partial<Record<import('./globals.js').GeoKeyName, *>>|null} Parsed geo key directory
      *     mapping key names to values, or null if not present
      * @throws {Error} If a referenced geo key value cannot be retrieved
      */
-    parseGeoKeyDirectory(): Record<import("./globals.js").GeoKeyName, any> | null;
+    parseGeoKeyDirectory(): Partial<Record<import("./globals.js").GeoKeyName, any>> | null;
     toObject(): {};
 }
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"imagefiledirectory.d.ts","sourceRoot":"","sources":["../src/imagefiledirectory.js"],"names":[],"mappings":"AA6PA;IACE;;;;;;OAMG;IACH,8HAFW,MAAM,EAQhB;IALC,gCAAwC;IACxC,8BAAoC;IACpC,2CAA4C;IAC5C,8BAAoC;IACpC,0BAA0C;IAG5C;;;OAGG;IACH,sBAHW,MAAM,GAAC,MAAM,GACX,OAAO,CAKnB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,GAAC,MAAM,OAoBvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GAAC,MAAM,gBAmCvB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAAC,MAAM,SACb,MAAM,gBAehB;IAED;;;;;;;OAOG;IACH,wBAJa,MAAM,CAAC,OAAO,cAAc,EAAE,UAAU,EAAE,GAAC,CAAC,GAAC,IAAI,CAqC7D;IAED,eAQC;CACF;AAED;;GAEG;AACH;IACE;;;;;;;OAOG;IACH,oBAPW,OAAO,wBAAwB,EAAE,UAAU,gBAC3C,OAAO,WACP,OAAO,UACP,OAAO,EASjB;IAJC,oDAAoB;IACpB,sBAAgC;IAChC,iBAAsB;IACtB,eAAkB;IAGpB;;;;;OAKG;IACH,iBAJW,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAiB9B;IAED;;;;;;;OAOG;IACH,6BAHW,MAAM,GACJ,OAAO,CAAC,kBAAkB,CAAC,CA+HvC;CACF;sBA/kBqB,gBAAgB"}
+{"version":3,"file":"imagefiledirectory.d.ts","sourceRoot":"","sources":["../src/imagefiledirectory.js"],"names":[],"mappings":"AAyQA;IACE;;;;;;OAMG;IACH,8HAFW,MAAM,EAQhB;IALC,gCAAwC;IACxC,8BAAoC;IACpC,2CAA4C;IAC5C,8BAAoC;IACpC,0BAA0C;IAG5C;;;OAGG;IACH,sBAHW,MAAM,GAAC,MAAM,GACX,OAAO,CAKnB;IAED;;;;;OAKG;IACH,wBAJW,MAAM,GAAC,MAAM,OAoBvB;IAED;;;;OAIG;IACH,yBAHW,MAAM,GAAC,MAAM,gBAmCvB;IAED;;;;;OAKG;IACH,gCAJW,MAAM,GAAC,MAAM,SACb,MAAM,gBAehB;IAED;;;;;;;OAOG;IACH,wBAJa,OAAO,CAAC,MAAM,CAAC,OAAO,cAAc,EAAE,UAAU,EAAE,GAAC,CAAC,CAAC,GAAC,IAAI,CAqCtE;IAED,eAQC;CACF;AAED;;GAEG;AACH;IACE;;;;;;;OAOG;IACH,oBAPW,OAAO,wBAAwB,EAAE,UAAU,gBAC3C,OAAO,WACP,OAAO,UACP,OAAO,EASjB;IAJC,oDAAoB;IACpB,sBAAgC;IAChC,iBAAsB;IACtB,eAAkB;IAGpB;;;;;OAKG;IACH,iBAJW,MAAM,WACN,MAAM,GACJ,OAAO,CAAC,SAAS,CAAC,CAiB9B;IAED;;;;;;;OAOG;IACH,6BAHW,MAAM,GACJ,OAAO,CAAC,kBAAkB,CAAC,CA+HvC;CACF;sBA3lBqB,gBAAgB"}

package/dist-module/imagefiledirectory.js

@@ -4,7 +4,7 @@ import { fieldTypes, geoKeyNames, tagDefinitions, resolveTag, getFieldTypeSize,
  * Allocates an appropriate TypedArray based on the TIFF field type.
  * @param {number} fieldType - TIFF field type constant from fieldTypes
  * @param {number} count - Number of elements to allocate
- * @returns {TypedArray} The allocated typed array for the given field type
+ * @returns {import('./geotiff.js').TypedArray|Array<number>} The allocated typed array for the given field type
  * @throws {RangeError} If the field type is invalid
  */
 function getArrayForSamples(fieldType, count) {
@@ -83,17 +83,28 @@ function getDataSliceReader(dataSlice, fieldType) {
     }
 }
 /**
- * Reads field values from a DataSlice.
- * @param {TypedArray|null} outValues - Optional pre-allocated output array
+ * @overload
+ * @param {import('./geotiff.js').TypedArray|Array<number>|null} outValues - Optional pre-allocated output array
  * @param {Function} readMethod - DataView read method (e.g., getUint16)
  * @param {DataSlice} dataSlice - Source data slice
  * @param {number} fieldType - TIFF field type constant
  * @param {number} count - Number of values to read
  * @param {number} offset - Byte offset to start reading
- * @param {boolean} isArray - Whether to always return an array (vs single value)
- * @returns {TypedArray|string|number} The decoded value(s)
+ * @param {true} isArray - Whether to always return an array (vs single value)
+ * @returns {import('./geotiff.js').TypedArray|Array<number>} The decoded value(s)
+ */
+/**
+ * Reads field values from a DataSlice.
+ * @param {import('./geotiff.js').TypedArray|Array<number>|null} outValues - Optional pre-allocated output array
+ * @param {Function} readMethod - DataView read method (e.g., getUint16)
+ * @param {DataSlice} dataSlice - Source data slice
+ * @param {import('./globals.js').FieldType} fieldType - TIFF field type constant
+ * @param {number} count - Number of values to read
+ * @param {number} offset - Byte offset to start reading
+ * @param {boolean} [isArray] - Whether to always return an array (vs single value)
+ * @returns {import('./geotiff.js').TypedArray|Array<number>|string|number} The decoded value(s)
  */
-function getValues(outValues = null, readMethod, dataSlice, fieldType, count, offset, isArray) {
+function getValues(outValues = null, readMethod, dataSlice, fieldType, count, offset, isArray = false) {
     const fieldTypeLength = getFieldTypeSize(fieldType);
     const values = outValues || getArrayForSamples(fieldType, count);
     // const readMethod = getDataSliceReader(dataSlice, fieldType);
@@ -112,7 +123,7 @@ function getValues(outValues = null, readMethod, dataSlice, fieldType, count, of
         }
     }
     if (fieldType === fieldTypes.ASCII) {
-        return new TextDecoder('utf-8').decode(values);
+        return new TextDecoder('utf-8').decode(/** @type {Uint8Array} */ (values));
     }
     if (count === 1 && !isArray && !isRational) {
         return values[0];
@@ -130,7 +141,7 @@ class DeferredArray {
      * @param {import("./source/basesource.js").BaseSource} source - Data source for fetching
      * @param {number} arrayOffset - Byte offset where the array data starts
      * @param {boolean} littleEndian - Endianness of the data
-     * @param {number} fieldType - TIFF field type constant
+     * @param {import('./globals.js').FieldType} fieldType - TIFF field type constant
      * @param {number} length - Number of elements in the array
      */
     constructor(source, arrayOffset, littleEndian, fieldType, length) {
@@ -148,7 +159,7 @@ class DeferredArray {
     /**
      * Loads all values in the deferred array at once.
      * Subsequent calls return the same promise to avoid redundant fetches.
-     * @returns {Promise<TypedArray>} Promise resolving to the fully loaded array
+     * @returns {Promise<import('./geotiff.js').TypedArray|Array<number>>} Promise resolving to the fully loaded array
      */
     async loadAll() {
         if (!this.fullFetchPromise) {
@@ -305,7 +316,7 @@ export class ImageFileDirectory {
      * Parses the GeoTIFF GeoKeyDirectory tag into a structured object.
      * The GeoKeyDirectory is a special TIFF tag that contains geographic metadata
      * in a key-value format as defined by the GeoTIFF specification.
-     * @returns {Record<import('./globals.js').GeoKeyName, *>|null} Parsed geo key directory
+     * @returns {Partial<Record<import('./globals.js').GeoKeyName, *>>|null} Parsed geo key directory
      *     mapping key names to values, or null if not present
      * @throws {Error} If a referenced geo key value cannot be retrieved
      */
@@ -314,7 +325,7 @@ export class ImageFileDirectory {
         if (!rawGeoKeyDirectory) {
             return null;
         }
-        /** @type {Record<import('./globals.js').GeoKeyName, *>} */
+        /** @type {Partial<Record<import('./globals.js').GeoKeyName, *>>} */
         const geoKeyDirectory = {};
         for (let i = 4; i <= rawGeoKeyDirectory[3] * 4; i += 4) {
             const key = geoKeyNames[rawGeoKeyDirectory[i]];
@@ -415,7 +426,7 @@ export class ImageFileDirectoryParser {
         let i = offset + (this.bigTiff ? 8 : 2);
         for (let entryCount = 0; entryCount < numDirEntries; i += entrySize, ++entryCount) {
             const fieldTag = dataSlice.readUint16(i);
-            const fieldType = dataSlice.readUint16(i + 2);
+            const fieldType = /** @type {import('./globals.js').FieldType} */ (dataSlice.readUint16(i + 2));
             const typeCount = this.bigTiff
                 ? dataSlice.readUint64(i + 4)
                 : dataSlice.readUint32(i + 4);