@cogeotiff/core 9.1.2 → 9.3.0

package/build/read/tiff.gdal.js

@@ -22,14 +22,7 @@ export var GhostOptionTileLeader;
  * this class represents the optimizations that GDAL has applied
  */
 export class TiffGhostOptions {
-    constructor() {
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-    }
+    options = new Map();
     /**
      * Has GDAL optimized this tiff
      */
@@ -89,4 +82,3 @@ export class TiffGhostOptions {
         return this.options.get(GhostOption.MaskInterleavedWithImagery) === 'YES';
     }
 }
-//# sourceMappingURL=tiff.gdal.js.map

package/build/read/tiff.ifd.config.d.ts

@@ -15,3 +15,4 @@ export declare const TiffIfdEntry: {
     43: TiffIfdConfig;
     42: TiffIfdConfig;
 };
+//# sourceMappingURL=tiff.ifd.config.d.ts.map

package/build/read/tiff.ifd.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff.ifd.config.d.ts","sourceRoot":"","sources":["../../src/read/tiff.ifd.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAGvD,eAAO,MAAM,aAAa,EAAE,aAY3B,CAAC;AAEF,eAAO,MAAM,gBAAgB,EAAE,aAe9B,CAAC;AAEF,MAAM,WAAW,aAAa;IAC5B,gBAAgB;IAChB,OAAO,EAAE,WAAW,CAAC;IACrB,qCAAqC;IACrC,OAAO,EAAE,MAAM,CAAC;IAChB,oCAAoC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,2CAA2C;IAC3C,GAAG,EAAE,MAAM,CAAC;CACb;AAED,eAAO,MAAM,YAAY;;;CAGxB,CAAC"}

package/build/read/tiff.ifd.config.js

@@ -32,4 +32,3 @@ export const TiffIfdEntry = {
     [TiffVersion.BigTiff]: TagTiffBigConfig,
     [TiffVersion.Tiff]: TagTiffConfig,
 };
-//# sourceMappingURL=tiff.ifd.config.js.map

package/build/read/tiff.tag.d.ts

@@ -33,7 +33,7 @@ export interface TagInline<T> extends TagBase {
 export interface TagOffset extends TagBase {
     type: 'offset';
     /** Values of the offsets this is a sparse array unless @see {TagOffset.isLoaded} is true */
-    value: number[];
+    value: number[] | Uint32Array | Uint16Array;
     /** Have all the values been read */
     isLoaded: boolean;
     /** Raw buffer of the values for lazy decoding, as reading 100,000s of uint64s can take quite a long time */
@@ -41,3 +41,4 @@ export interface TagOffset extends TagBase {
     /** Where in the file the value is read from */
     dataOffset: number;
 }
+//# sourceMappingURL=tiff.tag.d.ts.map

package/build/read/tiff.tag.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff.tag.d.ts","sourceRoot":"","sources":["../../src/read/tiff.tag.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AACnE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,0BAA0B;AAC1B,MAAM,MAAM,GAAG,CAAC,CAAC,GAAG,OAAO,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC,CAAC,GAAG,SAAS,CAAC;AAErE,MAAM,WAAW,OAAO;IACtB,oBAAoB;IACpB,EAAE,EAAE,OAAO,CAAC;IACZ,2BAA2B;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,SAAS,EAAE,MAAM,CAAC;IAClB,uBAAuB;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,QAAQ,EAAE,gBAAgB,CAAC;CAC5B;AAED,2EAA2E;AAC3E,MAAM,WAAW,OAAO,CAAC,CAAC,CAAE,SAAQ,OAAO;IACzC,IAAI,EAAE,MAAM,CAAC;IACb,0CAA0C;IAC1C,KAAK,CAAC,EAAE,CAAC,CAAC;IACV,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,kEAAkE;AAClE,MAAM,WAAW,SAAS,CAAC,CAAC,CAAE,SAAQ,OAAO;IAC3C,IAAI,EAAE,QAAQ,CAAC;IACf,uBAAuB;IACvB,KAAK,EAAE,CAAC,CAAC;CACV;AAED,oEAAoE;AACpE,MAAM,WAAW,SAAU,SAAQ,OAAO;IACxC,IAAI,EAAE,QAAQ,CAAC;IACf,4FAA4F;IAC5F,KAAK,EAAE,MAAM,EAAE,GAAG,WAAW,GAAG,WAAW,CAAC;IAC5C,oCAAoC;IACpC,QAAQ,EAAE,OAAO,CAAC;IAClB,4GAA4G;IAC5G,IAAI,CAAC,EAAE,cAAc,CAAC;IACtB,+CAA+C;IAC/C,UAAU,EAAE,MAAM,CAAC;CACpB"}

package/build/read/tiff.tag.factory.d.ts

@@ -1,6 +1,18 @@
+import { TiffTagValueType } from '../const/tiff.tag.value.js';
 import type { Tiff } from '../tiff.js';
 import type { DataViewOffset } from './data.view.offset.js';
 import type { Tag, TagLazy, TagOffset } from './tiff.tag.js';
+/**
+ * Convert a tiff tag value to a typed array if the local endian matches the tiff endian
+ *
+ * @param tiff
+ * @param bytes
+ * @param offset Offset in the data view to read from
+ * @param length Number of bytes to read
+ * @param type type of tiff tag
+ * @returns the value if the type is a typed array and the endianness matches otherwise null
+ */
+export declare function readTypedValue<T>(tiff: Tiff, bytes: DataView, offset: number, length: number, type: TiffTagValueType): T | null;
 /**
  * Determine if all the data for the tiff tag is loaded in and use that to create the specific CogTiffTag
  *
@@ -16,7 +28,9 @@ export declare function fetchLazy<T>(tag: TagLazy<T>, tiff: Tiff): Promise<T>;
 /**
  * Fetch all the values from a {@link TagOffset}
  */
-export declare function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<number[]>;
+export declare function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<TagOffset['value']>;
 export declare function setBytes(tag: TagOffset, view: DataViewOffset): void;
 /** Partially fetch the values of a {@link TagOffset} and return the value for the offset */
 export declare function getValueAt(tiff: Tiff, tag: TagOffset, index: number): Promise<number>;
+export declare function getValueAtSync(tiff: Tiff, tag: TagOffset, index: number): number | null;
+//# sourceMappingURL=tiff.tag.factory.d.ts.map

package/build/read/tiff.tag.factory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff.tag.factory.d.ts","sourceRoot":"","sources":["../../src/read/tiff.tag.factory.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,KAAK,EAAE,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAoD7D;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,CAAC,EAC9B,IAAI,EAAE,IAAI,EACV,KAAK,EAAE,QAAQ,EACf,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,gBAAgB,GACrB,CAAC,GAAG,IAAI,CAkBV;AAgDD;;;;;;;;GAQG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,GAAG,GAAG,CAAC,OAAO,CAAC,CAqDxF;AAED,iDAAiD;AACjD,wBAAsB,SAAS,CAAC,CAAC,EAAE,GAAG,EAAE,OAAO,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,CAAC,CAAC,CAQ1E;AAED;;GAEG;AACH,wBAAsB,eAAe,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,GAAG,OAAO,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,CAa7F;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,SAAS,EAAE,IAAI,EAAE,cAAc,GAAG,IAAI,CAKnE;AAED,4FAA4F;AAC5F,wBAAsB,UAAU,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB3F;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAUvF"}

package/build/read/tiff.tag.factory.js

@@ -3,6 +3,7 @@ import { TiffTag, TiffTagConvertArray } from '../const/tiff.tag.id.js';
 import { TiffTagValueType } from '../const/tiff.tag.value.js';
 import { getUint, getUint64 } from '../util/bytes.js';
 import { hasBytes } from './data.view.offset.js';
+import { isLittleEndian } from './endian.js';
 import { getTiffTagSize } from './tiff.value.reader.js';
 function readTagValue(fieldType, bytes, offset, isLittleEndian) {
     switch (fieldType) {
@@ -36,6 +37,31 @@ function readTagValue(fieldType, bytes, offset, isLittleEndian) {
             throw new Error(`Unknown read type "${fieldType}" "${TiffTagValueType[fieldType]}"`);
     }
 }
+/**
+ * Convert a tiff tag value to a typed array if the local endian matches the tiff endian
+ *
+ * @param tiff
+ * @param bytes
+ * @param offset Offset in the data view to read from
+ * @param length Number of bytes to read
+ * @param type type of tiff tag
+ * @returns the value if the type is a typed array and the endianness matches otherwise null
+ */
+export function readTypedValue(tiff, bytes, offset, length, type) {
+    switch (type) {
+        case TiffTagValueType.Uint8:
+            return new Uint8Array(bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length));
+        case TiffTagValueType.Uint16:
+            if (tiff.isLittleEndian !== isLittleEndian)
+                return null;
+            return new Uint16Array(bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length));
+        case TiffTagValueType.Uint32:
+            if (tiff.isLittleEndian !== isLittleEndian)
+                return null;
+            return new Uint32Array(bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length));
+    }
+    return null;
+}
 function readValue(tiff, tagId, bytes, offset, type, count) {
     const typeSize = getTiffTagSize(type);
     const dataLength = count * typeSize;
@@ -51,6 +77,15 @@ function readValue(tiff, tagId, bytes, offset, type, count) {
         case TiffTagValueType.Ascii:
             return String.fromCharCode.apply(null, new Uint8Array(bytes.buffer, offset, dataLength - 1));
     }
+    // TODO should we convert all tag values to typed arrays if possible?
+    if (tagId === TiffTag.TileOffsets ||
+        tagId === TiffTag.TileByteCounts ||
+        tagId === TiffTag.StripOffsets ||
+        tagId === TiffTag.StripByteCounts) {
+        const typedOutput = readTypedValue(tiff, bytes, offset, dataLength, type);
+        if (typedOutput)
+            return typedOutput;
+    }
     const output = [];
     for (let i = 0; i < dataLength; i += typeSize) {
         output.push(readTagValue(type, bytes, offset + i, tiff.isLittleEndian));
@@ -94,9 +129,16 @@ export function createTag(tiff, view, offset) {
                 value: [],
                 tagOffset: offset,
             };
-            // Some offsets are quite long and don't need to read them often, so only read the tags we are interested in when we need to
-            if (tagId === TiffTag.TileOffsets && hasBytes(view, dataOffset, dataLength))
-                setBytes(tag, view);
+            if (hasBytes(view, dataOffset, dataLength)) {
+                const val = readTypedValue(tiff, view, dataOffset - view.sourceOffset, dataLength, dataType);
+                if (val) {
+                    tag.value = val;
+                    tag.isLoaded = true;
+                }
+                else {
+                    setBytes(tag, view);
+                }
+            }
             return tag;
     }
     // If we already have the bytes in the view read them in
@@ -128,6 +170,7 @@ export async function fetchAllOffsets(tiff, tag) {
         tag.view.sourceOffset = tag.dataOffset;
     }
     tag.value = readValue(tiff, tag.id, tag.view, 0, tag.dataType, tag.count);
+    tag.view = undefined;
     tag.isLoaded = true;
     return tag.value;
 }
@@ -161,4 +204,17 @@ export async function getValueAt(tiff, tag, index) {
     tag.value[index] = value;
     return value;
 }
-//# sourceMappingURL=tiff.tag.factory.js.map
+export function getValueAtSync(tiff, tag, index) {
+    if (index > tag.count || index < 0)
+        throw new Error('TagOffset: out of bounds :' + index);
+    if (tag.value[index] != null)
+        return tag.value[index];
+    if (tag.view == null)
+        return null;
+    const dataTypeSize = getTiffTagSize(tag.dataType);
+    const value = readValue(tiff, undefined, tag.view, index * dataTypeSize, tag.dataType, 1);
+    if (typeof value !== 'number')
+        throw new Error('Value is not a number');
+    tag.value[index] = value;
+    return value;
+}

package/build/read/tiff.tag.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=tiff.tag.js.map

package/build/read/tiff.value.reader.d.ts

@@ -1,3 +1,4 @@
 import { TiffTagValueType } from '../const/tiff.tag.value.js';
 import type { ByteSize } from '../util/bytes.js';
 export declare function getTiffTagSize(fieldType: TiffTagValueType): ByteSize;
+//# sourceMappingURL=tiff.value.reader.d.ts.map

package/build/read/tiff.value.reader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff.value.reader.d.ts","sourceRoot":"","sources":["../../src/read/tiff.value.reader.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAEjD,wBAAgB,cAAc,CAAC,SAAS,EAAE,gBAAgB,GAAG,QAAQ,CAyBpE"}

package/build/read/tiff.value.reader.js

@@ -25,4 +25,3 @@ export function getTiffTagSize(fieldType) {
             throw new Error(`Invalid fieldType ${String(fieldType)}`);
     }
 }
-//# sourceMappingURL=tiff.value.reader.js.map

package/build/source.d.ts

@@ -11,7 +11,10 @@ export interface Source {
         size?: number;
     };
     /** Fetch bytes from a source */
-    fetch(offset: number, length?: number): Promise<ArrayBuffer>;
+    fetch(offset: number, length?: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<ArrayBuffer>;
     /** Optionally close the source, useful for sources that have open connections of file descriptors */
     close?(): Promise<void>;
 }
+//# sourceMappingURL=source.d.ts.map

package/build/source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"source.d.ts","sourceRoot":"","sources":["../src/source.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,WAAW,MAAM;IACrB,kCAAkC;IAClC,GAAG,EAAE,GAAG,CAAC;IAET,iFAAiF;IACjF,QAAQ,CAAC,EAAE;QACT,2CAA2C;QAC3C,IAAI,CAAC,EAAE,MAAM,CAAC;KACf,CAAC;IAEF,gCAAgC;IAChC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;IAEjG,qGAAqG;IACrG,KAAK,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACzB"}

package/build/source.js

@@ -1,2 +1 @@
 export {};
-//# sourceMappingURL=source.js.map

package/build/tiff.d.ts

@@ -3,6 +3,10 @@ import { TiffGhostOptions } from './read/tiff.gdal.js';
 import type { TiffIfdConfig } from './read/tiff.ifd.config.js';
 import type { Source } from './source.js';
 import { TiffImage } from './tiff.image.js';
+export interface TiffCreationOptions {
+    /** When initializing the tiff, read data in blocks of this size (in KB) */
+    defaultReadSize: number;
+}
 export declare class Tiff {
     /** Read 16KB blocks at a time */
     static DefaultReadSize: number;
@@ -23,11 +27,15 @@ export declare class Tiff {
     /** Has init() been called */
     isInitialized: boolean;
     private _initPromise?;
-    constructor(source: Source);
+    /** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
+    constructor(source: Source, options?: TiffCreationOptions);
     /** Create a tiff and initialize it by reading the tiff headers */
-    static create(source: Source): Promise<Tiff>;
+    static create(source: Source, options?: TiffCreationOptions): Promise<Tiff>;
     /**
-     * Initialize the tiff loading in the header and all image headers
+     * Initialize the tiff loading in the header and all image headers.
+     *
+     * This is only required if the Tiff was created with the constructor, if you
+     * used {@link create} this will have already been called.
      */
     init(): Promise<Tiff>;
     /**
@@ -46,3 +54,4 @@ export declare class Tiff {
      */
     private readIfd;
 }
+//# sourceMappingURL=tiff.d.ts.map

package/build/tiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff.d.ts","sourceRoot":"","sources":["../src/tiff.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AAItD,OAAO,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAG/D,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,WAAW,mBAAmB;IAClC,2EAA2E;IAC3E,eAAe,EAAE,MAAM,CAAC;CACzB;AAED,qBAAa,IAAI;IACf,iCAAiC;IACjC,MAAM,CAAC,eAAe,SAAa;IACnC,iCAAiC;IACjC,eAAe,SAAwB;IACvC,+CAA+C;IAC/C,MAAM,EAAE,MAAM,CAAC;IACf,wBAAwB;IACxB,OAAO,cAAoB;IAC3B,0CAA0C;IAC1C,MAAM,EAAE,SAAS,EAAE,CAAM;IACzB,2BAA2B;IAC3B,OAAO,CAAC,EAAE,gBAAgB,CAAC;IAC3B,4CAA4C;IAC5C,SAAS,EAAE,aAAa,CAAiB;IACzC,8CAA8C;IAC9C,cAAc,UAAS;IACvB,6BAA6B;IAC7B,aAAa,UAAS;IAEtB,OAAO,CAAC,YAAY,CAAC,CAAgB;IAErC,sFAAsF;gBAC1E,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE,mBAA+D;IAKpG,kEAAkE;IAClE,MAAM,CAAC,MAAM,CACX,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,mBAA+D,GACvE,OAAO,CAAC,IAAI,CAAC;IAIhB;;;;;OAKG;IACH,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAMrB;;;;OAIG;IACH,oBAAoB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS;IAoBnD,qEAAqE;YACvD,UAAU;IAgExB;;;;;OAKG;IACH,OAAO,CAAC,OAAO;CAsBhB"}

package/build/tiff.image.d.ts

@@ -17,6 +17,7 @@ export interface TiffImageTileCount {
 }
 /** Tags that are commonly accessed for geotiffs */
 export declare const ImportantTags: Set<TiffTag>;
+export declare const ImportantGeoTags: Set<TiffTag>;
 /**
  * Size of a individual tile
  */
@@ -198,7 +199,9 @@ export declare class TiffImage {
     /** The jpeg header is stored in the IFD, read the JPEG header and adjust the byte array to include it */
     getJpegHeader(bytes: ArrayBuffer): ArrayBuffer;
     /** Read image bytes at the given offset */
-    getBytes(offset: number, byteCount: number): Promise<{
+    getBytes(offset: number, byteCount: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
         mimeType: TiffMimeType;
         bytes: ArrayBuffer;
         compression: Compression;
@@ -211,7 +214,9 @@ export declare class TiffImage {
      * @param x Tile x offset
      * @param y Tile y offset
      */
-    getTile(x: number, y: number): Promise<{
+    getTile(x: number, y: number, options?: {
+        signal?: AbortSignal;
+    }): Promise<{
         mimeType: TiffMimeType;
         bytes: ArrayBuffer;
         compression: Compression;
@@ -230,6 +235,9 @@ export declare class TiffImage {
     hasTile(x: number, y: number): Promise<boolean>;
     /**
      * Load the offset and byteCount of a tile
+     *
+     * if the tiff is sparse, offset and byteCount will be zero if the tile is empty
+     *
      * @param index index in the tile array
      * @returns Offset and byteCount for the tile
      */
@@ -238,3 +246,4 @@ export declare class TiffImage {
         imageSize: number;
     }>;
 }
+//# sourceMappingURL=tiff.image.d.ts.map

package/build/tiff.image.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff.image.d.ts","sourceRoot":"","sources":["../src/tiff.image.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmD,YAAY,EAAE,MAAM,sBAAsB,CAAC;AACrG,OAAO,KAAK,EAAE,cAAc,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AAC1E,OAAO,EAAE,WAAW,EAA8B,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAEtG,OAAO,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AACpE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEtC,OAAO,KAAK,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,aAAa,CAAC;AAErD,wBAAwB;AACxB,eAAO,MAAM,qBAAqB,QAAQ,CAAC;AAE3C;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,oCAAoC;IACpC,CAAC,EAAE,MAAM,CAAC;IACV,oCAAoC;IACpC,CAAC,EAAE,MAAM,CAAC;CACX;AAED,mDAAmD;AACnD,eAAO,MAAM,aAAa,cASxB,CAAC;AAEH,eAAO,MAAM,gBAAgB,cAAsF,CAAC;AAEpH;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAC;IACd,2BAA2B;IAC3B,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,qBAAa,SAAS;IACpB;;;;;OAKG;IACH,EAAE,EAAE,MAAM,CAAC;IACX,iDAAiD;IACjD,IAAI,EAAE,IAAI,CAAC;IACX,sCAAsC;IACtC,eAAe,UAAS;IACxB,iDAAiD;IACjD,OAAO,EAAE,GAAG,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC,CAAa;IACjE,qDAAqD;IACrD,IAAI,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC,CAAC;gBAEZ,IAAI,EAAE,IAAI,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,GAAG,CAAC,OAAO,EAAE,GAAG,CAAC;IAM3D;;;;OAIG;IACG,IAAI,CAAC,WAAW,UAAO,GAAG,OAAO,CAAC,IAAI,CAAC;IAgB7C;;;;;;;;OAQG;IACH,KAAK,CAAC,CAAC,SAAS,MAAM,WAAW,EAAE,GAAG,EAAE,CAAC,GAAG,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI;IAQjE;;;;;;;;;;OAUG;IACH,GAAG,CAAC,CAAC,SAAS,MAAM,WAAW,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO;IAIjD;;;;;;;;;;;OAWG;IACU,KAAK,CAAC,CAAC,SAAS,MAAM,WAAW,EAAE,GAAG,EAAE,CAAC,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC;IASvF;;;;;;;;OAQG;IACH,QAAQ,CAAC,CAAC,SAAS,MAAM,cAAc,EAAE,GAAG,EAAE,CAAC,GAAG,cAAc,CAAC,CAAC,CAAC,GAAG,IAAI;IAK1E;;;;;OAKG;IACH,IAAI,MAAM,IAAI,MAAM,GAAG,IAAI,CAK1B;IAED;;;;OAIG;IACG,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IA8CtC;;;;OAIG;IACH,IAAI,MAAM,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAiBrC;IAED,6FAA6F;IAC7F,IAAI,YAAY,IAAI,OAAO,CAO1B;IAED;;;;OAIG;IACH,IAAI,UAAU,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAqBzC;IAED;;;;OAIG;IACH,IAAI,UAAU,IAAI,OAAO,CAExB;IAED;;;;OAIG;IACH,IAAI,IAAI,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAgB3C;IAED;;;;;;OAMG;IACH,IAAI,WAAW,IAAI,YAAY,GAAG,IAAI,CAIrC;IAED;;;;;;OAMG;IACH,IAAI,IAAI,IAAI,MAAM,GAAG,IAAI,CAsBxB;IAED;;;;OAIG;IACH,IAAI,IAAI,IAAI,IAAI,CAMf;IAED;;OAEG;IACI,OAAO,IAAI,OAAO;IAIzB;;OAEG;IACH,IAAI,QAAQ,IAAI,iBAAiB,CAKhC;IAED;;OAEG;IACH,IAAI,SAAS,IAAI,kBAAkB,CAMlC;IAED;;;;;;OAMG;IACH,IAAI,UAAU,IAAI,SAAS,GAAG,SAAS,CAAC,MAAM,EAAE,CAAC,CAIhD;IAED;;;;;;OAMG;IACH,IAAI,UAAU,IAAI,MAAM,CAEvB;IAGD,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,WAAW;IAShD;;;;;;OAMG;IACG,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,QAAQ,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAAC;IAe7F,yGAAyG;IACzG,aAAa,CAAC,KAAK,EAAE,WAAW,GAAG,WAAW;IAiB9C,2CAA2C;IACrC,QAAQ,CACZ,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,OAAO,CAAC;QAAE,QAAQ,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,WAAW,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAAC;IAgB3F;;;;;;;OAOG;IACG,OAAO,CACX,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,OAAO,CAAC,EAAE;QAAE,MAAM,CAAC,EAAE,WAAW,CAAA;KAAE,GACjC,OAAO,CAAC;QAAE,QAAQ,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,WAAW,EAAE,WAAW,CAAA;KAAE,GAAG,IAAI,CAAC;IAuB3F;;;;;;;;;;OAUG;IACG,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAerD;;;;;;;OAOG;IACG,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAA;KAAE,CAAC;CA6BjF"}

package/build/tiff.image.js

@@ -1,6 +1,6 @@
 import { getCompressionMimeType, TiffCompressionMimeType, TiffMimeType } from './const/tiff.mime.js';
 import { Compression, ModelTypeCode, SubFileType, TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
-import { fetchAllOffsets, fetchLazy, getValueAt } from './read/tiff.tag.factory.js';
+import { fetchAllOffsets, fetchLazy, getValueAt, getValueAtSync } from './read/tiff.tag.factory.js';
 import { getUint } from './util/bytes.js';
 /** Invalid EPSG code */
 export const InvalidProjectionCode = 32767;
@@ -14,53 +14,25 @@ export const ImportantTags = new Set([
     TiffTag.ModelTransformation,
     TiffTag.TileHeight,
     TiffTag.TileWidth,
-    TiffTag.GeoKeyDirectory,
-    TiffTag.GeoAsciiParams,
-    TiffTag.GeoDoubleParams,
-    TiffTag.TileOffsets,
 ]);
+export const ImportantGeoTags = new Set([TiffTag.GeoKeyDirectory, TiffTag.GeoAsciiParams, TiffTag.GeoDoubleParams]);
 export class TiffImage {
+    /**
+     * Id of the tif image, generally the image index inside the tif
+     * where 0 is the root image, and every sub image is +1
+     *
+     * @example 0, 1, 2
+     */
+    id;
+    /** Reference to the TIFF that owns this image */
+    tiff;
+    /** Has loadGeoTiffTags been called */
+    isGeoTagsLoaded = false;
+    /** Sub tags stored in TiffTag.GeoKeyDirectory */
+    tagsGeo = new Map();
+    /** All IFD tags that have been read for the image */
+    tags;
     constructor(tiff, id, tags) {
-        /**
-         * Id of the tif image, generally the image index inside the tif
-         * where 0 is the root image, and every sub image is +1
-         *
-         * @example 0, 1, 2
-         */
-        Object.defineProperty(this, "id", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Reference to the TIFF that owns this image */
-        Object.defineProperty(this, "tiff", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Has loadGeoTiffTags been called */
-        Object.defineProperty(this, "isGeoTagsLoaded", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        /** Sub tags stored in TiffTag.GeoKeyDirectory */
-        Object.defineProperty(this, "tagsGeo", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: new Map()
-        });
-        /** All IFD tags that have been read for the image */
-        Object.defineProperty(this, "tags", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
         this.tiff = tiff;
         this.id = id;
         this.tags = tags;
@@ -71,20 +43,14 @@ export class TiffImage {
      * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
      */
     async init(loadGeoTags = true) {
-        const requiredTags = [
-            this.fetch(TiffTag.Compression),
-            this.fetch(TiffTag.ImageHeight),
-            this.fetch(TiffTag.ImageWidth),
-            this.fetch(TiffTag.ModelPixelScale),
-            this.fetch(TiffTag.ModelTiePoint),
-            this.fetch(TiffTag.ModelTransformation),
-            this.fetch(TiffTag.TileHeight),
-            this.fetch(TiffTag.TileWidth),
-        ];
+        const requiredTags = [];
+        ImportantTags.forEach((tag) => {
+            requiredTags.push(this.fetch(tag));
+        });
         if (loadGeoTags) {
-            requiredTags.push(this.fetch(TiffTag.GeoKeyDirectory));
-            requiredTags.push(this.fetch(TiffTag.GeoAsciiParams));
-            requiredTags.push(this.fetch(TiffTag.GeoDoubleParams));
+            ImportantGeoTags.forEach((tag) => {
+                requiredTags.push(this.fetch(tag));
+            });
         }
         await Promise.all(requiredTags);
         if (loadGeoTags)
@@ -457,13 +423,13 @@ export class TiffImage {
         const actualBytes = new Uint8Array(bytes.byteLength + tableData.length - 2);
         actualBytes.set(tableData, 0);
         actualBytes.set(new Uint8Array(bytes).slice(2), tableData.length);
-        return actualBytes;
+        return actualBytes.buffer.slice(actualBytes.byteOffset, actualBytes.byteOffset + actualBytes.byteLength);
     }
     /** Read image bytes at the given offset */
-    async getBytes(offset, byteCount) {
+    async getBytes(offset, byteCount, options) {
         if (byteCount === 0)
             return null;
-        const bytes = await this.tiff.source.fetch(offset, byteCount);
+        const bytes = await this.tiff.source.fetch(offset, byteCount, options);
         if (bytes.byteLength < byteCount) {
             throw new Error(`Failed to fetch bytes from offset:${offset} wanted:${byteCount} got:${bytes.byteLength}`);
         }
@@ -483,7 +449,7 @@ export class TiffImage {
      * @param x Tile x offset
      * @param y Tile y offset
      */
-    async getTile(x, y) {
+    async getTile(x, y, options) {
         const size = this.size;
         const tiles = this.tileSize;
         if (tiles == null)
@@ -499,7 +465,7 @@ export class TiffImage {
         if (idx >= totalTiles)
             throw new Error(`Tile index is outside of tile range: ${idx} >= ${totalTiles}`);
         const { offset, imageSize } = await this.getTileSize(idx);
-        return this.getBytes(offset, imageSize);
+        return this.getBytes(offset, imageSize, options);
     }
     /**
      * Does this tile exist in the tiff and does it actually have a value
@@ -528,15 +494,25 @@ export class TiffImage {
     }
     /**
      * Load the offset and byteCount of a tile
+     *
+     * if the tiff is sparse, offset and byteCount will be zero if the tile is empty
+     *
      * @param index index in the tile array
      * @returns Offset and byteCount for the tile
      */
     async getTileSize(index) {
+        // If both the tile offset and tile byte counts are loaded,
+        // we can get the offset and byte count synchronously without needing to fetch any additional data
+        const byteCounts = this.tags.get(TiffTag.TileByteCounts);
+        const tileOffset = getOffsetSync(this.tiff, this.tileOffset, index);
+        const tileSize = getOffsetSync(this.tiff, byteCounts, index);
+        if (tileOffset != null && tileSize != null)
+            return { offset: tileOffset, imageSize: tileSize };
         // GDAL optimizes tiles by storing the size of the tile in
         // the few bytes leading up to the tile
         const leaderBytes = this.tiff.options?.tileLeaderByteSize;
         if (leaderBytes) {
-            const offset = await getOffset(this.tiff, this.tileOffset, index);
+            const offset = tileOffset ?? (await getOffset(this.tiff, this.tileOffset, index));
             // Sparse tiff no data found
             if (offset === 0)
                 return { offset: 0, imageSize: 0 };
@@ -545,17 +521,22 @@ export class TiffImage {
             const bytes = await this.tiff.source.fetch(offset - leaderBytes, leaderBytes);
             return { offset, imageSize: getUint(new DataView(bytes), 0, leaderBytes, this.tiff.isLittleEndian) };
         }
-        const byteCounts = this.tags.get(TiffTag.TileByteCounts);
         if (byteCounts == null)
             throw new Error('No tile byte counts found');
         const [offset, imageSize] = await Promise.all([
-            getOffset(this.tiff, this.tileOffset, index),
-            getOffset(this.tiff, byteCounts, index),
+            tileOffset ?? getOffset(this.tiff, this.tileOffset, index),
+            tileSize ?? getOffset(this.tiff, byteCounts, index),
         ]);
         return { offset, imageSize };
     }
 }
 function getOffset(tiff, x, index) {
+    const val = getOffsetSync(tiff, x, index);
+    if (val != null)
+        return Promise.resolve(val);
+    return getValueAt(tiff, x, index);
+}
+function getOffsetSync(tiff, x, index) {
     if (index < 0) {
         throw new Error(`Tiff: ${tiff.source.url.href} out of bounds ${TiffTag[x.id]} index:${index} total:${x.count}`);
     }
@@ -564,6 +545,7 @@ function getOffset(tiff, x, index) {
         return 0;
     if (x.type === 'inline')
         return x.value[index];
-    return getValueAt(tiff, x, index);
+    if (x.isLoaded)
+        return x.value[index];
+    return getValueAtSync(tiff, x, index);
 }
-//# sourceMappingURL=tiff.image.js.map

package/build/tiff.js

@@ -8,77 +8,39 @@ import { TiffImage } from './tiff.image.js';
 import { getUint } from './util/bytes.js';
 import { toHex } from './util/util.hex.js';
 export class Tiff {
-    constructor(source) {
-        /** Read 16KB blocks at a time */
-        Object.defineProperty(this, "defaultReadSize", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: Tiff.DefaultReadSize
-        });
-        /** Where this cog is fetching its data from */
-        Object.defineProperty(this, "source", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Big or small Tiff */
-        Object.defineProperty(this, "version", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: TiffVersion.Tiff
-        });
-        /** List of images, o is the base image */
-        Object.defineProperty(this, "images", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        /** Ghost header options */
-        Object.defineProperty(this, "options", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        /** Configuration for the size of the IFD */
-        Object.defineProperty(this, "ifdConfig", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: TagTiffConfig
-        });
-        /** Is the tiff being read is little Endian */
-        Object.defineProperty(this, "isLittleEndian", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        /** Has init() been called */
-        Object.defineProperty(this, "isInitialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        Object.defineProperty(this, "_initPromise", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
+    /** Read 16KB blocks at a time */
+    static DefaultReadSize = 16 * 1024;
+    /** Read 16KB blocks at a time */
+    defaultReadSize = Tiff.DefaultReadSize;
+    /** Where this cog is fetching its data from */
+    source;
+    /** Big or small Tiff */
+    version = TiffVersion.Tiff;
+    /** List of images, o is the base image */
+    images = [];
+    /** Ghost header options */
+    options;
+    /** Configuration for the size of the IFD */
+    ifdConfig = TagTiffConfig;
+    /** Is the tiff being read is little Endian */
+    isLittleEndian = false;
+    /** Has init() been called */
+    isInitialized = false;
+    _initPromise;
+    /** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
+    constructor(source, options = { defaultReadSize: Tiff.DefaultReadSize }) {
         this.source = source;
+        this.defaultReadSize = options.defaultReadSize;
     }
     /** Create a tiff and initialize it by reading the tiff headers */
-    static create(source) {
-        return new Tiff(source).init();
+    static create(source, options = { defaultReadSize: Tiff.DefaultReadSize }) {
+        return new Tiff(source, options).init();
     }
     /**
-     * Initialize the tiff loading in the header and all image headers
+     * Initialize the tiff loading in the header and all image headers.
+     *
+     * This is only required if the Tiff was created with the constructor, if you
+     * used {@link create} this will have already been called.
      */
     init() {
         if (this._initPromise)
@@ -190,13 +152,6 @@ export class Tiff {
         return getUint(view, startOffset + tagCount * ifdSize, this.ifdConfig.pointer, this.isLittleEndian);
     }
 }
-/** Read 16KB blocks at a time */
-Object.defineProperty(Tiff, "DefaultReadSize", {
-    enumerable: true,
-    configurable: true,
-    writable: true,
-    value: 16 * 1024
-});
 function getMaxLength(source, offset, length) {
     const size = source.metadata?.size;
     // max length is unknown, roll the dice and hope the chunk exists
@@ -207,4 +162,3 @@ function getMaxLength(source, offset, length) {
         return size - offset;
     return length;
 }
-//# sourceMappingURL=tiff.js.map