@cogeotiff/core 9.3.0 → 9.5.0

package/build/tiff.image.js

@@ -42,14 +42,14 @@ export class TiffImage {
      *
      * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
      */
-    async init(loadGeoTags = true) {
+    async init(loadGeoTags = true, options) {
         const requiredTags = [];
         ImportantTags.forEach((tag) => {
-            requiredTags.push(this.fetch(tag));
+            requiredTags.push(this.fetch(tag, options));
         });
         if (loadGeoTags) {
             ImportantGeoTags.forEach((tag) => {
-                requiredTags.push(this.fetch(tag));
+                requiredTags.push(this.fetch(tag, options));
             });
         }
         await Promise.all(requiredTags);
@@ -100,18 +100,18 @@ export class TiffImage {
      *
      * @param tag tag to fetch
      */
-    async fetch(tag) {
+    async fetch(tag, options) {
         const sourceTag = this.tags.get(tag);
         if (sourceTag == null)
             return null;
         if (sourceTag.type === 'inline')
             return sourceTag.value;
         if (sourceTag.type === 'lazy')
-            return fetchLazy(sourceTag, this.tiff);
+            return fetchLazy(sourceTag, this.tiff, options);
         if (sourceTag.isLoaded)
             return sourceTag.value;
         if (sourceTag.type === 'offset')
-            return fetchAllOffsets(this.tiff, sourceTag);
+            return fetchAllOffsets(this.tiff, sourceTag, options);
         throw new Error('Cannot fetch:' + tag);
     }
     /**
@@ -138,7 +138,7 @@ export class TiffImage {
         const tag = this.tags.get(TiffTag.GdalNoData);
         if (tag == null)
             return null;
-        if (tag.value)
+        if (tag.value != null)
             return Number(tag.value);
         throw new Error('GdalNoData tag is not loaded');
     }
@@ -398,7 +398,7 @@ export class TiffImage {
      *
      * @param index Strip index to read
      */
-    async getStrip(index) {
+    async getStrip(index, options) {
         if (this.isTiled())
             throw new Error('Cannot read stripes, tiff is tiled: ' + index);
         const byteCounts = this.tags.get(TiffTag.StripByteCounts);
@@ -406,10 +406,10 @@ export class TiffImage {
         if (index >= byteCounts.count)
             throw new Error('Cannot read strip, index out of bounds');
         const [byteCount, offset] = await Promise.all([
-            getOffset(this.tiff, offsets, index),
-            getOffset(this.tiff, byteCounts, index),
+            getOffset(this.tiff, offsets, index, options),
+            getOffset(this.tiff, byteCounts, index, options),
         ]);
-        return this.getBytes(byteCount, offset);
+        return this.getBytes(byteCount, offset, options);
     }
     /** The jpeg header is stored in the IFD, read the JPEG header and adjust the byte array to include it */
     getJpegHeader(bytes) {
@@ -464,7 +464,7 @@ export class TiffImage {
         const totalTiles = nxTiles * nyTiles;
         if (idx >= totalTiles)
             throw new Error(`Tile index is outside of tile range: ${idx} >= ${totalTiles}`);
-        const { offset, imageSize } = await this.getTileSize(idx);
+        const { offset, imageSize } = await this.getTileSize(idx, options);
         return this.getBytes(offset, imageSize, options);
     }
     /**
@@ -478,7 +478,7 @@ export class TiffImage {
      *
      * @returns if the tile exists and has data
      */
-    async hasTile(x, y) {
+    async hasTile(x, y, options) {
         const tiles = this.tileSize;
         const size = this.size;
         if (tiles == null)
@@ -489,7 +489,7 @@ export class TiffImage {
         if (x >= nxTiles || y >= nyTiles)
             return false;
         const idx = y * nxTiles + x;
-        const ret = await this.getTileSize(idx);
+        const ret = await this.getTileSize(idx, options);
         return ret.offset > 0;
     }
     /**
@@ -500,7 +500,7 @@ export class TiffImage {
      * @param index index in the tile array
      * @returns Offset and byteCount for the tile
      */
-    async getTileSize(index) {
+    async getTileSize(index, options) {
         // 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);
@@ -512,29 +512,29 @@ export class TiffImage {
         // the few bytes leading up to the tile
         const leaderBytes = this.tiff.options?.tileLeaderByteSize;
         if (leaderBytes) {
-            const offset = tileOffset ?? (await getOffset(this.tiff, this.tileOffset, index));
+            const offset = tileOffset ?? (await getOffset(this.tiff, this.tileOffset, index, options));
             // Sparse tiff no data found
             if (offset === 0)
                 return { offset: 0, imageSize: 0 };
             // This fetch will generally load in the bytes needed for the image too
             // provided the image size is less than the size of a chunk
-            const bytes = await this.tiff.source.fetch(offset - leaderBytes, leaderBytes);
+            const bytes = await this.tiff.source.fetch(offset - leaderBytes, leaderBytes, options);
             return { offset, imageSize: getUint(new DataView(bytes), 0, leaderBytes, this.tiff.isLittleEndian) };
         }
         if (byteCounts == null)
             throw new Error('No tile byte counts found');
         const [offset, imageSize] = await Promise.all([
-            tileOffset ?? getOffset(this.tiff, this.tileOffset, index),
-            tileSize ?? getOffset(this.tiff, byteCounts, index),
+            tileOffset ?? getOffset(this.tiff, this.tileOffset, index, options),
+            tileSize ?? getOffset(this.tiff, byteCounts, index, options),
         ]);
         return { offset, imageSize };
     }
 }
-function getOffset(tiff, x, index) {
+function getOffset(tiff, x, index, options) {
     const val = getOffsetSync(tiff, x, index);
     if (val != null)
         return Promise.resolve(val);
-    return getValueAt(tiff, x, index);
+    return getValueAt(tiff, x, index, options);
 }
 function getOffsetSync(tiff, x, index) {
     if (index < 0) {

package/build/tiff.js

@@ -34,7 +34,7 @@ export class Tiff {
     }
     /** Create a tiff and initialize it by reading the tiff headers */
     static create(source, options = { defaultReadSize: Tiff.DefaultReadSize }) {
-        return new Tiff(source, options).init();
+        return new Tiff(source, options).init(options);
     }
     /**
      * Initialize the tiff loading in the header and all image headers.
@@ -42,10 +42,12 @@ export class Tiff {
      * This is only required if the Tiff was created with the constructor, if you
      * used {@link create} this will have already been called.
      */
-    init() {
+    init(options) {
+        if (this.isInitialized)
+            return Promise.resolve(this);
         if (this._initPromise)
             return this._initPromise;
-        this._initPromise = this.readHeader();
+        this._initPromise = this.readHeader(options);
         return this._initPromise;
     }
     /**
@@ -71,11 +73,11 @@ export class Tiff {
         return firstImage;
     }
     /** Read the Starting header and all Image headers from the source */
-    async readHeader() {
+    async readHeader(options) {
         if (this.isInitialized)
             return this;
         // limit the read to the size of the file if it is known, for small tiffs
-        const bytes = new DataView(await this.source.fetch(0, getMaxLength(this.source, 0, this.defaultReadSize)));
+        const bytes = new DataView(await this.source.fetch(0, getMaxLength(this.source, 0, this.defaultReadSize), options));
         if (bytes.byteLength === 0)
             throw new Error('Unable to read empty tiff');
         bytes.sourceOffset = 0;
@@ -117,13 +119,13 @@ export class Tiff {
             // Ensure at least 1KB near at the IFD offset is ready for reading
             // TODO is 1KB enough, most IFD entries are in the order of 100-300 bytes
             if (!hasBytes(lastView, nextOffsetIfd, 1024)) {
-                const bytes = await this.source.fetch(nextOffsetIfd, getMaxLength(this.source, nextOffsetIfd, this.defaultReadSize));
+                const bytes = await this.source.fetch(nextOffsetIfd, getMaxLength(this.source, nextOffsetIfd, this.defaultReadSize), options);
                 lastView = new DataView(bytes);
                 lastView.sourceOffset = nextOffsetIfd;
             }
             nextOffsetIfd = this.readIfd(nextOffsetIfd, lastView);
         }
-        await Promise.all(this.images.map((i) => i.init()));
+        await Promise.all(this.images.map((i) => i.init(true, options)));
         this.isInitialized = true;
         return this;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogeotiff/core",
-  "version": "9.3.0",
+  "version": "9.5.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/blacha/cogeotiff.git",
@@ -17,11 +17,12 @@
   "scripts": {
     "test": "node --test \"build/**/*.test.js\""
   },
+  "dependencies": {},
   "devDependencies": {
     "@types/node": "^20.0.0"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "82b82e9d9f8996dfb0cb48827c143e134acc9865"
+  "gitHead": "c489ebab2136a779a705bf1dedebbc250e17a747"
 }

package/src/__test__/cog.image.test.ts

@@ -7,6 +7,9 @@ import { TestFileSource } from '../__benchmark__/source.file.js';
 import { SourceMemory } from '../__benchmark__/source.memory.js';
 import { TiffMimeType } from '../const/tiff.mime.js';
 import { Photometric, TiffTag } from '../const/tiff.tag.id.js';
+import { TiffTagValueType } from '../const/tiff.tag.value.js';
+import type { Tag } from '../read/tiff.tag.js';
+import { TiffImage } from '../tiff.image.js';
 import { Tiff } from '../tiff.js';
 import { ByteSize } from '../util/bytes.js';
 
@@ -214,3 +217,61 @@ describe('CogStrip', () => {
     assert.equal(stripB?.bytes.byteLength, 152);
   });
 });
+
+describe('TiffImage.noData', () => {
+  /** Create a TiffImage with a specific GdalNoData tag value for testing */
+  function imageWithNoData(value: string): TiffImage {
+    const tags = new Map<TiffTag, Tag>();
+    tags.set(TiffTag.GdalNoData, {
+      id: TiffTag.GdalNoData,
+      name: 'GdalNoData',
+      tagOffset: 0,
+      count: 1,
+      dataType: TiffTagValueType.Ascii,
+      type: 'inline',
+      value,
+    });
+    return new TiffImage(null as unknown as Tiff, 0, tags);
+  }
+
+  it('should return null when GdalNoData tag is absent', () => {
+    const img = new TiffImage(null as unknown as Tiff, 0, new Map());
+    assert.equal(img.noData, null);
+  });
+
+  it('should parse a negative nodata value', () => {
+    const img = imageWithNoData('-9999');
+    assert.equal(img.noData, -9999);
+  });
+
+  it('should parse nodata value of "0" (falsy string)', () => {
+    const img = imageWithNoData('0');
+    assert.equal(img.noData, 0);
+  });
+
+  it('should parse a positive nodata value', () => {
+    const img = imageWithNoData('255');
+    assert.equal(img.noData, 255);
+  });
+
+  it('should parse a floating point nodata value', () => {
+    const img = imageWithNoData('-3.4028234663852886e+38');
+    assert.equal(img.noData, -3.4028234663852886e38);
+  });
+
+  it('should throw when lazy tag value is undefined (not yet fetched)', () => {
+    const tags = new Map<TiffTag, Tag>();
+    tags.set(TiffTag.GdalNoData, {
+      id: TiffTag.GdalNoData,
+      name: 'GdalNoData',
+      tagOffset: 0,
+      count: 1,
+      dataType: TiffTagValueType.Ascii,
+      type: 'lazy',
+      dataOffset: 0,
+      value: undefined,
+    });
+    const img = new TiffImage(null as unknown as Tiff, 0, tags);
+    assert.throws(() => img.noData, /GdalNoData tag is not loaded/);
+  });
+});

package/src/__test__/cog.read.test.ts

@@ -19,6 +19,12 @@ function validate(tif: Tiff): void {
   assert.deepEqual(firstTif.size, { width: 64, height: 64 });
 }
 
+describe('TiffTag', () => {
+  it('should have the correct ModelTransformation tag id', () => {
+    assert.equal(TiffTag.ModelTransformation, 34264);
+  });
+});
+
 describe('CogRead', () => {
   it('should read big endian', async () => {
     const source = new TestFileSource(new URL('../../data/big.endian.tiff', import.meta.url));
@@ -273,4 +279,18 @@ describe('CogRead', () => {
       [797, 861, 925, 993, 1057, 1121, 1189, 1253, 1317, 1385, 1449, 1513, 1577, 1641, 1705, 1769],
     );
   });
+
+  it('should load a file with a model transformation tag', async () => {
+    const cogSourceFile = new URL('../../data/model_transformation.tif', import.meta.url);
+
+    const buf = await readFile(cogSourceFile);
+    const source = new SourceMemory(buf);
+
+    const tiff = await Tiff.create(source);
+    assert.equal(tiff.images.length, 1);
+    assert.deepEqual(
+      tiff.images[0].tags.get(TiffTag.ModelTransformation)?.value,
+      [10, 0, 0, 418080, 0, 10, 0, 4423680, 0, 0, 0, 0, 0, 0, 0, 1],
+    );
+  });
 });

package/src/const/tiff.mime.ts

@@ -5,6 +5,9 @@ import { Compression } from './tiff.tag.id.js';
  */
 export enum TiffMimeType {
   None = 'application/octet-stream',
+  Jbig = 'image/jbig',
+  Dcs = 'image/x-kodak-dcs',
+  PackBits = 'application/packbits',
   Jpeg = 'image/jpeg',
   Jp2000 = 'image/jp2',
   JpegXl = 'image/jpegxl',
@@ -29,6 +32,26 @@ export const TiffCompressionMimeType: Record<Compression, TiffMimeType> = {
   [Compression.Zstd]: TiffMimeType.Zstd,
   [Compression.Webp]: TiffMimeType.Webp,
   [Compression.JpegXl]: TiffMimeType.JpegXl,
+  [Compression.Ccittrle]: TiffMimeType.None,
+  [Compression.CcittT4]: TiffMimeType.None,
+  [Compression.CcittT6]: TiffMimeType.None,
+  [Compression.T85]: TiffMimeType.Jbig,
+  [Compression.T43]: TiffMimeType.Jbig,
+  [Compression.Next]: TiffMimeType.None,
+  [Compression.Ccittrlew]: TiffMimeType.None,
+  [Compression.PackBits]: TiffMimeType.PackBits,
+  [Compression.ThunderScan]: TiffMimeType.None,
+  [Compression.It8ctpad]: TiffMimeType.None,
+  [Compression.It8lw]: TiffMimeType.None,
+  [Compression.It8mp]: TiffMimeType.None,
+  [Compression.It8bl]: TiffMimeType.None,
+  [Compression.PixarFilm]: TiffMimeType.None,
+  [Compression.PixarLog]: TiffMimeType.None,
+  [Compression.Dcs]: TiffMimeType.Dcs,
+  [Compression.Jbig]: TiffMimeType.Jbig,
+  [Compression.SgiLog]: TiffMimeType.None,
+  [Compression.SgiLog24]: TiffMimeType.None,
+  [Compression.JpegXlDng17]: TiffMimeType.JpegXl,
 };
 
 /**

package/src/const/tiff.tag.id.ts

@@ -66,17 +66,37 @@ export enum OldSubFileType {
 /** Tiff compression types */
 export enum Compression {
   None = 1,
+  Ccittrle = 2,
+  CcittT4 = 3,
+  CcittT6 = 4,
   Lzw = 5,
   Jpeg6 = 6,
   Jpeg = 7,
   DeflateOther = 8,
+  T85 = 9,
+  T43 = 10,
+  Next = 32766,
+  Ccittrlew = 32771,
+  PackBits = 32773,
+  ThunderScan = 32809,
+  It8ctpad = 32895,
+  It8lw = 32896,
+  It8mp = 32897,
+  It8bl = 32898,
+  PixarFilm = 32908,
+  PixarLog = 32909,
   Deflate = 32946,
-  Jp2000 = 3417,
+  Dcs = 32947,
+  Jbig = 34661,
+  SgiLog = 34676,
+  SgiLog24 = 34677,
+  Jp2000 = 34712,
   Lerc = 34887,
   Lzma = 34925,
   Zstd = 50000,
   Webp = 50001,
   JpegXl = 50002,
+  JpegXlDng17 = 52546,
 }
 
 export enum PlanarConfiguration {
@@ -301,7 +321,7 @@ export enum TiffTag {
    *     0,     0, 0,        1]
    * ```
    */
-  ModelTransformation = 34744,
+  ModelTransformation = 34264,
   /**
    * List of GeoTiff tags
    * {@link TiffTagGeo}
@@ -436,9 +456,30 @@ export interface TiffTagType {
   [TiffTag.SampleFormat]: SampleFormat[];
   [TiffTag.GdalMetadata]: string;
   [TiffTag.GdalNoData]: string;
-  [TiffTag.ModelPixelScale]: number[];
+  // Always [ScaleX, ScaleY, ScaleZ]
+  // https://web.archive.org/web/20240329145238/https://www.awaresystems.be/imaging/tiff/tifftags/modelpixelscaletag.html
+  [TiffTag.ModelPixelScale]: [scaleX: number, scaleY: number, scaleZ: number];
   [TiffTag.ModelTiePoint]: number[];
-  [TiffTag.ModelTransformation]: number[];
+  // Always 16 numbers
+  // https://web.archive.org/web/20240329145255/https://www.awaresystems.be/imaging/tiff/tifftags/modeltransformationtag.html
+  [TiffTag.ModelTransformation]: [
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+    number,
+  ];
   [TiffTag.GeoKeyDirectory]: number[];
   [TiffTag.GeoDoubleParams]: number[];
   [TiffTag.GeoAsciiParams]: string;

package/src/read/tiff.tag.factory.ts

@@ -1,7 +1,7 @@
 /* eslint-disable @typescript-eslint/no-unsafe-enum-comparison */
 import { TiffTag, TiffTagConvertArray } from '../const/tiff.tag.id.js';
 import { TiffTagValueType } from '../const/tiff.tag.value.js';
-import type { Tiff } from '../tiff.js';
+import type { Tiff, TiffFetchOptions } from '../tiff.js';
 import { getUint, getUint64 } from '../util/bytes.js';
 import type { DataViewOffset } from './data.view.offset.js';
 import { hasBytes } from './data.view.offset.js';
@@ -205,11 +205,11 @@ export function createTag(tiff: Tiff, view: DataViewOffset, offset: number): Tag
 }
 
 /** Fetch the value from a {@link TagLazy} tag */
-export async function fetchLazy<T>(tag: TagLazy<T>, tiff: Tiff): Promise<T> {
+export async function fetchLazy<T>(tag: TagLazy<T>, tiff: Tiff, options?: TiffFetchOptions): Promise<T> {
   if (tag.value != null) return tag.value;
   const dataTypeSize = getTiffTagSize(tag.dataType);
   const dataLength = dataTypeSize * tag.count;
-  const bytes = await tiff.source.fetch(tag.dataOffset, dataLength);
+  const bytes = await tiff.source.fetch(tag.dataOffset, dataLength, options);
   const view = new DataView(bytes);
   tag.value = readValue(tiff, tag.id, view, 0, tag.dataType, tag.count);
   return tag.value as T;
@@ -218,11 +218,15 @@ export async function fetchLazy<T>(tag: TagLazy<T>, tiff: Tiff): Promise<T> {
 /**
  * Fetch all the values from a {@link TagOffset}
  */
-export async function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<TagOffset['value']> {
+export async function fetchAllOffsets(
+  tiff: Tiff,
+  tag: TagOffset,
+  options?: TiffFetchOptions,
+): Promise<TagOffset['value']> {
   const dataTypeSize = getTiffTagSize(tag.dataType);
 
   if (tag.view == null) {
-    const bytes = await tiff.source.fetch(tag.dataOffset, dataTypeSize * tag.count);
+    const bytes = await tiff.source.fetch(tag.dataOffset, dataTypeSize * tag.count, options);
     tag.view = new DataView(bytes) as DataViewOffset;
     tag.view.sourceOffset = tag.dataOffset;
   }
@@ -241,13 +245,18 @@ export function setBytes(tag: TagOffset, view: DataViewOffset): void {
 }
 
 /** Partially fetch the values of a {@link TagOffset} and return the value for the offset */
-export async function getValueAt(tiff: Tiff, tag: TagOffset, index: number): Promise<number> {
+export async function getValueAt(
+  tiff: Tiff,
+  tag: TagOffset,
+  index: number,
+  options?: TiffFetchOptions,
+): Promise<number> {
   if (index > tag.count || index < 0) throw new Error('TagOffset: out of bounds :' + index);
   if (tag.value[index] != null) return tag.value[index];
   const dataTypeSize = getTiffTagSize(tag.dataType);
 
   if (tag.view == null) {
-    const bytes = await tiff.source.fetch(tag.dataOffset + index * dataTypeSize, dataTypeSize);
+    const bytes = await tiff.source.fetch(tag.dataOffset + index * dataTypeSize, dataTypeSize, options);
     const view = new DataView(bytes);
     // Skip type conversion to array by using undefined tiff tag id
     const value = readValue(tiff, undefined, view, 0, tag.dataType, 1);

package/src/tiff.image.ts

@@ -3,7 +3,7 @@ import type { TiffTagGeoType, TiffTagType } from './const/tiff.tag.id.js';
 import { Compression, ModelTypeCode, SubFileType, TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
 import { fetchAllOffsets, fetchLazy, getValueAt, getValueAtSync } from './read/tiff.tag.factory.js';
 import type { Tag, TagInline, TagOffset } from './read/tiff.tag.js';
-import type { Tiff } from './tiff.js';
+import type { Tiff, TiffFetchOptions } from './tiff.js';
 import { getUint } from './util/bytes.js';
 import type { BoundingBox, Size } from './vector.js';
 
@@ -72,15 +72,15 @@ export class TiffImage {
    *
    * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
    */
-  async init(loadGeoTags = true): Promise<void> {
+  async init(loadGeoTags = true, options?: TiffFetchOptions): Promise<void> {
     const requiredTags: Promise<unknown>[] = [];
     ImportantTags.forEach((tag) => {
-      requiredTags.push(this.fetch(tag));
+      requiredTags.push(this.fetch(tag, options));
     });
 
     if (loadGeoTags) {
       ImportantGeoTags.forEach((tag) => {
-        requiredTags.push(this.fetch(tag));
+        requiredTags.push(this.fetch(tag, options));
       });
     }
 
@@ -132,13 +132,13 @@ export class TiffImage {
    *
    * @param tag tag to fetch
    */
-  public async fetch<T extends keyof TiffTagType>(tag: T): Promise<TiffTagType[T] | null> {
+  public async fetch<T extends keyof TiffTagType>(tag: T, options?: TiffFetchOptions): Promise<TiffTagType[T] | null> {
     const sourceTag = this.tags.get(tag);
     if (sourceTag == null) return null;
     if (sourceTag.type === 'inline') return sourceTag.value as TiffTagType[T];
-    if (sourceTag.type === 'lazy') return fetchLazy(sourceTag, this.tiff) as Promise<TiffTagType[T]>;
+    if (sourceTag.type === 'lazy') return fetchLazy(sourceTag, this.tiff, options) as Promise<TiffTagType[T]>;
     if (sourceTag.isLoaded) return sourceTag.value as TiffTagType[T];
-    if (sourceTag.type === 'offset') return fetchAllOffsets(this.tiff, sourceTag) as Promise<TiffTagType[T]>;
+    if (sourceTag.type === 'offset') return fetchAllOffsets(this.tiff, sourceTag, options) as Promise<TiffTagType[T]>;
     throw new Error('Cannot fetch:' + tag);
   }
   /**
@@ -164,7 +164,7 @@ export class TiffImage {
   get noData(): number | null {
     const tag = this.tags.get(TiffTag.GdalNoData);
     if (tag == null) return null;
-    if (tag.value) return Number(tag.value);
+    if (tag.value != null) return Number(tag.value);
     throw new Error('GdalNoData tag is not loaded');
   }
 
@@ -439,7 +439,10 @@ export class TiffImage {
    *
    * @param index Strip index to read
    */
-  async getStrip(index: number): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer } | null> {
+  async getStrip(
+    index: number,
+    options?: TiffFetchOptions,
+  ): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer } | null> {
     if (this.isTiled()) throw new Error('Cannot read stripes, tiff is tiled: ' + index);
 
     const byteCounts = this.tags.get(TiffTag.StripByteCounts) as TagOffset;
@@ -448,10 +451,10 @@ export class TiffImage {
     if (index >= byteCounts.count) throw new Error('Cannot read strip, index out of bounds');
 
     const [byteCount, offset] = await Promise.all([
-      getOffset(this.tiff, offsets, index),
-      getOffset(this.tiff, byteCounts, index),
+      getOffset(this.tiff, offsets, index, options),
+      getOffset(this.tiff, byteCounts, index, options),
     ]);
-    return this.getBytes(byteCount, offset);
+    return this.getBytes(byteCount, offset, options);
   }
 
   /** The jpeg header is stored in the IFD, read the JPEG header and adjust the byte array to include it */
@@ -476,7 +479,7 @@ export class TiffImage {
   async getBytes(
     offset: number,
     byteCount: number,
-    options?: { signal?: AbortSignal },
+    options?: TiffFetchOptions,
   ): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer; compression: Compression } | null> {
     if (byteCount === 0) return null;
 
@@ -504,7 +507,7 @@ export class TiffImage {
   async getTile(
     x: number,
     y: number,
-    options?: { signal?: AbortSignal },
+    options?: TiffFetchOptions,
   ): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer; compression: Compression } | null> {
     const size = this.size;
     const tiles = this.tileSize;
@@ -523,7 +526,7 @@ export class TiffImage {
     const totalTiles = nxTiles * nyTiles;
     if (idx >= totalTiles) throw new Error(`Tile index is outside of tile range: ${idx} >= ${totalTiles}`);
 
-    const { offset, imageSize } = await this.getTileSize(idx);
+    const { offset, imageSize } = await this.getTileSize(idx, options);
 
     return this.getBytes(offset, imageSize, options);
   }
@@ -539,7 +542,7 @@ export class TiffImage {
    *
    * @returns if the tile exists and has data
    */
-  async hasTile(x: number, y: number): Promise<boolean> {
+  async hasTile(x: number, y: number, options?: TiffFetchOptions): Promise<boolean> {
     const tiles = this.tileSize;
     const size = this.size;
 
@@ -550,7 +553,7 @@ export class TiffImage {
     const nxTiles = Math.ceil(size.width / tiles.width);
     if (x >= nxTiles || y >= nyTiles) return false;
     const idx = y * nxTiles + x;
-    const ret = await this.getTileSize(idx);
+    const ret = await this.getTileSize(idx, options);
     return ret.offset > 0;
   }
 
@@ -562,7 +565,7 @@ export class TiffImage {
    * @param index index in the tile array
    * @returns Offset and byteCount for the tile
    */
-  async getTileSize(index: number): Promise<{ offset: number; imageSize: number }> {
+  async getTileSize(index: number, options?: TiffFetchOptions): Promise<{ offset: number; imageSize: number }> {
     // 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) as TagOffset | TagInline<number[]>;
@@ -574,29 +577,34 @@ export class TiffImage {
     // the few bytes leading up to the tile
     const leaderBytes = this.tiff.options?.tileLeaderByteSize;
     if (leaderBytes) {
-      const offset = tileOffset ?? (await getOffset(this.tiff, this.tileOffset, index));
+      const offset = tileOffset ?? (await getOffset(this.tiff, this.tileOffset, index, options));
       // Sparse tiff no data found
       if (offset === 0) return { offset: 0, imageSize: 0 };
 
       // This fetch will generally load in the bytes needed for the image too
       // provided the image size is less than the size of a chunk
-      const bytes = await this.tiff.source.fetch(offset - leaderBytes, leaderBytes);
+      const bytes = await this.tiff.source.fetch(offset - leaderBytes, leaderBytes, options);
       return { offset, imageSize: getUint(new DataView(bytes), 0, leaderBytes, this.tiff.isLittleEndian) };
     }
 
     if (byteCounts == null) throw new Error('No tile byte counts found');
     const [offset, imageSize] = await Promise.all([
-      tileOffset ?? getOffset(this.tiff, this.tileOffset, index),
-      tileSize ?? getOffset(this.tiff, byteCounts, index),
+      tileOffset ?? getOffset(this.tiff, this.tileOffset, index, options),
+      tileSize ?? getOffset(this.tiff, byteCounts, index, options),
     ]);
     return { offset, imageSize };
   }
 }
 
-function getOffset(tiff: Tiff, x: TagOffset | TagInline<number[]>, index: number): number | Promise<number> {
+function getOffset(
+  tiff: Tiff,
+  x: TagOffset | TagInline<number[]>,
+  index: number,
+  options?: TiffFetchOptions,
+): number | Promise<number> {
   const val = getOffsetSync(tiff, x, index);
   if (val != null) return Promise.resolve(val);
-  return getValueAt(tiff, x as TagOffset, index);
+  return getValueAt(tiff, x as TagOffset, index, options);
 }
 
 function getOffsetSync(tiff: Tiff, x: TagOffset | TagInline<number[]>, index: number): number | null {