@cogeotiff/core 9.1.2 → 9.3.0

package/build/util/bytes.d.ts

@@ -17,3 +17,4 @@ export declare enum ByteSize {
  */
 export declare function getUint64(view: DataView, offset: number, isLittleEndian: boolean): number;
 export declare function getUint(view: DataView, offset: number, bs: ByteSize, isLittleEndian: boolean): number;
+//# sourceMappingURL=bytes.d.ts.map

package/build/util/bytes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bytes.d.ts","sourceRoot":"","sources":["../../src/util/bytes.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACvB,MAAM,IAAI;IACV,OAAO,IAAI;CACZ;AAED,oBAAY,QAAQ;IAClB,MAAM,IAAI;IACV,MAAM,IAAI;IACV,MAAM,IAAI;IACV,KAAK,IAAI;CACV;AAID;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,cAAc,EAAE,OAAO,GAAG,MAAM,CAazF;AAED,wBAAgB,OAAO,CAAC,IAAI,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,QAAQ,EAAE,cAAc,EAAE,OAAO,GAAG,MAAM,CAWrG"}

package/build/util/bytes.js

@@ -42,4 +42,3 @@ export function getUint(view, offset, bs, isLittleEndian) {
             return getUint64(view, offset, isLittleEndian);
     }
 }
-//# sourceMappingURL=bytes.js.map

package/build/util/util.hex.d.ts

@@ -8,3 +8,4 @@
  * @returns hex string eg 0x0015
  **/
 export declare function toHex(num: number, padding?: number, prefix?: boolean): string;
+//# sourceMappingURL=util.hex.d.ts.map

package/build/util/util.hex.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.hex.d.ts","sourceRoot":"","sources":["../../src/util/util.hex.ts"],"names":[],"mappings":"AAAA;;;;;;;;IAQI;AACJ,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,SAAI,EAAE,MAAM,UAAO,GAAG,MAAM,CAIrE"}

package/build/util/util.hex.js

@@ -13,4 +13,3 @@ export function toHex(num, padding = 4, prefix = true) {
         return '0x' + hex;
     return hex;
 }
-//# sourceMappingURL=util.hex.js.map

package/build/vector.d.ts

@@ -11,3 +11,4 @@ export interface BoundingBox extends Point, Size {
 export interface Vector extends Point {
     z: number;
 }
+//# sourceMappingURL=vector.d.ts.map

package/build/vector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vector.d.ts","sourceRoot":"","sources":["../src/vector.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,IAAI;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,MAAM,WAAW,KAAK;IACpB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED,MAAM,WAAW,WAAY,SAAQ,KAAK,EAAE,IAAI;CAAG;AACnD,MAAM,WAAW,MAAO,SAAQ,KAAK;IACnC,CAAC,EAAE,MAAM,CAAC;CACX"}

package/build/vector.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogeotiff/core",
-  "version": "9.1.2",
+  "version": "9.3.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/blacha/cogeotiff.git",
@@ -23,5 +23,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "4781a6375adf419da9f0319d15c8a67284dfb0c4"
+  "gitHead": "82b82e9d9f8996dfb0cb48827c143e134acc9865"
 }

package/src/__benchmark__/cog.read.benchmark.ts

@@ -4,6 +4,7 @@ import { TiffTag } from '../index.js';
 import { Tiff } from '../tiff.js';
 import { SourceMemory } from './source.memory.js';
 
+Tiff.DefaultReadSize = 64 * 1024;
 // console.log = console.trace;
 /** Read a tile from every image inside of a tiff 300 tiles read */
 async function main(): Promise<void> {
@@ -18,9 +19,10 @@ async function main(): Promise<void> {
     // 6 images
     for (const img of tiff.images) await img.getTile(0, 0);
 
+    const img = tiff.images[0];
     // Force loading all the byte arrays in which benchmarks the bulk array loading
-    await tiff.images[0].fetch(TiffTag.TileByteCounts);
-    await tiff.images[0].fetch(TiffTag.TileOffsets);
+    await img.fetch(TiffTag.TileByteCounts);
+    await img.fetch(TiffTag.TileOffsets);
   }
 }
 

package/src/__benchmark__/source.file.ts

@@ -9,6 +9,7 @@ const gunzipP = promisify(gunzip);
 export class TestFileSource implements Source {
   url: URL;
   data: Promise<Buffer>;
+  fetches: { offset: number; length: number }[] = [];
 
   constructor(fileName: URL) {
     this.url = fileName;
@@ -20,7 +21,8 @@ export class TestFileSource implements Source {
 
   async fetch(offset: number, length: number): Promise<ArrayBuffer> {
     const fileData = await this.data;
-    return fileData.buffer.slice(fileData.byteOffset + offset, fileData.byteOffset + offset + length);
+    this.fetches.push({ offset, length });
+    return fileData.buffer.slice(fileData.byteOffset + offset, fileData.byteOffset + offset + length) as ArrayBuffer;
   }
 
   get size(): Promise<number> {

package/src/__benchmark__/source.memory.ts

@@ -7,8 +7,8 @@ export class SourceMemory implements Source {
 
   static toArrayBuffer(buf: Buffer | Uint8Array | ArrayBuffer): ArrayBuffer {
     if (buf instanceof ArrayBuffer) return buf;
-    if (buf.byteLength === buf.buffer.byteLength) return buf.buffer;
-    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    if (buf.byteLength === buf.buffer.byteLength) return buf.buffer as ArrayBuffer;
+    return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength) as ArrayBuffer;
   }
 
   constructor(bytes: Buffer | Uint8Array | ArrayBuffer) {

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

@@ -103,7 +103,7 @@ describe('Cog.Big', () => {
 
   it('should read using a memory source', async () => {
     const bytes = await fs.readFile(new URL('../../data/sparse.tiff', import.meta.url));
-    const source = new SourceMemory(bytes.buffer);
+    const source = new SourceMemory(bytes.buffer as ArrayBuffer);
     const cog = new Tiff(source);
     await cog.init();
 

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

@@ -7,7 +7,7 @@ import { SourceMemory } from '../__benchmark__/source.memory.js';
 import { TiffMimeType } from '../const/tiff.mime.js';
 import { Photometric, SampleFormat } from '../const/tiff.tag.id.js';
 import { TiffVersion } from '../const/tiff.version.js';
-import { TiffTag, TiffTagGeo } from '../index.js';
+import { TagOffset, TiffTag, TiffTagGeo } from '../index.js';
 import { Tiff } from '../tiff.js';
 
 function validate(tif: Tiff): void {
@@ -30,6 +30,8 @@ describe('CogRead', () => {
     assert.equal(tiff.version, TiffVersion.Tiff);
     assert.equal(tiff.images.length, 1);
     const firstImage = tiff.images[0];
+    const byteCounts = await firstImage.fetch(TiffTag.TileByteCounts);
+    assert.deepEqual([...(byteCounts ?? [])], [511]);
 
     assert.equal(firstImage.compression, 'application/zstd');
     assert.equal(firstImage.isTiled(), true);
@@ -48,6 +50,14 @@ describe('CogRead', () => {
     assert.equal(tiff.version, TiffVersion.BigTiff);
     assert.equal(tiff.images[0].epsg, null);
     validate(tiff);
+
+    const [byteCounts, tileOffsets] = await Promise.all([
+      tiff.images[0].fetch(TiffTag.TileByteCounts),
+      tiff.images[0].fetch(TiffTag.TileOffsets),
+    ]);
+
+    assert.deepEqual([...(byteCounts ?? [])], [196608]);
+    assert.deepEqual([...(tileOffsets ?? [])], [272]);
   });
 
   it('should fail reading a empty byte tiff', async () => {
@@ -87,6 +97,88 @@ describe('CogRead', () => {
     assert.equal(tiff.images.length, 5);
   });
 
+  it('should read the byte count array if it is loaded', async () => {
+    const source = new TestFileSource(new URL('../../data/rgba8_cog.tiff', import.meta.url));
+    const fetchSize = 16 * 1024;
+
+    const tiff = new Tiff(source);
+    tiff.defaultReadSize = fetchSize;
+    await tiff.init();
+
+    assert.equal(source.fetches.length, 1);
+    assert.equal(source.fetches[0].length, fetchSize);
+
+    const img = tiff.images[0];
+    const byteCounts = img.tags.get(TiffTag.TileByteCounts) as TagOffset;
+    const tileOffsets = img.tags.get(TiffTag.TileOffsets) as TagOffset;
+    assert.equal(source.fetches.length, 1);
+
+    assert.equal(byteCounts.type, 'offset');
+    assert.equal(byteCounts.isLoaded, true);
+
+    assert.equal(tileOffsets.type, 'offset');
+    assert.equal(tileOffsets.isLoaded, true);
+
+    const tile = await img.getTile(0, 0);
+    assert.equal(tile?.bytes.byteLength, byteCounts.value[0]);
+    assert.equal(source.fetches.length, 2);
+    assert.deepEqual(source.fetches[1], { offset: tileOffsets.value[0], length: byteCounts.value[0] });
+
+    // force the offset to be unloaded
+    byteCounts.isLoaded = false;
+    const oldValue = byteCounts.value;
+    byteCounts.value = [];
+    const tileB = await img.getTile(0, 0);
+    assert.equal(tileB?.bytes.byteLength, oldValue[0]);
+    assert.equal(source.fetches.length, 4);
+
+    // Read the tile offset then the tile
+    assert.deepEqual(source.fetches[2], { offset: tileOffsets.value[0] - 4, length: 4 });
+    assert.deepEqual(source.fetches[3], { offset: tileOffsets.value[0], length: oldValue[0] });
+  });
+
+  it('should read the byte count array if it is loaded (BigTiff)', async () => {
+    const source = new TestFileSource(new URL('../../data/rgba8_cog_big.tiff', import.meta.url));
+    const fetchSize = 16 * 1024;
+
+    const tiff = new Tiff(source);
+    tiff.defaultReadSize = fetchSize;
+    await tiff.init();
+
+    assert.equal(source.fetches.length, 1);
+    assert.equal(source.fetches[0].length, fetchSize);
+
+    const img = tiff.images[0];
+    const byteCounts = img.tags.get(TiffTag.TileByteCounts) as TagOffset;
+    const tileOffsets = img.tags.get(TiffTag.TileOffsets) as TagOffset;
+    assert.equal(source.fetches.length, 1);
+
+    assert.equal(byteCounts.type, 'offset');
+    assert.equal(byteCounts.isLoaded, true);
+    assert.equal(byteCounts.view == null, true);
+
+    assert.equal(tileOffsets.type, 'offset');
+    assert.equal(tileOffsets.isLoaded, false);
+    assert.equal(tileOffsets.view == null, false);
+
+    const tile = await img.getTile(0, 0);
+    assert.equal(tile?.bytes.byteLength, byteCounts.value[0]);
+    assert.equal(source.fetches.length, 2);
+    assert.deepEqual(source.fetches[1], { offset: tileOffsets.value[0], length: byteCounts.value[0] });
+
+    // force the offset to be unloaded
+    byteCounts.isLoaded = false;
+    const oldValue = byteCounts.value;
+    byteCounts.value = [];
+    byteCounts.view = undefined;
+    const tileB = await img.getTile(0, 0);
+    assert.equal(tileB?.bytes.byteLength, oldValue[0]);
+    assert.equal(source.fetches.length, 4);
+    // Read the tile offset then the tile
+    assert.deepEqual(source.fetches[2], { offset: tileOffsets.value[0] - 4, length: 4 });
+    assert.deepEqual(source.fetches[3], { offset: tileOffsets.value[0], length: oldValue[0] });
+  });
+
   it('should read ifds from anywhere in the file', async () => {
     const source = new TestFileSource(new URL('../../data/DEM_BS28_2016_1000_1141.tif', import.meta.url));
     const tiff = await Tiff.create(source);
@@ -109,7 +201,9 @@ describe('CogRead', () => {
 
     assert.equal(im.valueGeo(TiffTagGeo.GTCitationGeoKey), 'NZGD2000 / New Zealand Transverse Mercator 2000');
     assert.equal(im.valueGeo(TiffTagGeo.GeodeticCitationGeoKey), 'NZGD2000');
-    assert.deepEqual(await im.fetch(TiffTag.StripByteCounts), [8064, 8064, 8064, 8064, 8064, 8064, 8064, 5040]);
+
+    const stripCount = await im.fetch(TiffTag.StripByteCounts);
+    assert.deepEqual([...(stripCount ?? [])], [8064, 8064, 8064, 8064, 8064, 8064, 8064, 5040]);
   });
 
   it('should read sub array ifds', async () => {
@@ -167,5 +261,16 @@ describe('CogRead', () => {
     const tiff = await Tiff.create(source);
     assert.equal(tiff.images.length, 5);
     assert.equal(tiff.images[0].epsg, 3857);
+
+    const [byteCounts, tileOffsets] = await Promise.all([
+      tiff.images[0].fetch(TiffTag.TileByteCounts),
+      tiff.images[0].fetch(TiffTag.TileOffsets),
+    ]);
+
+    assert.deepEqual([...(byteCounts ?? [])], [64, 64, 68, 64, 64, 68, 64, 64, 68, 64, 64, 64, 64, 64, 64, 68]);
+    assert.deepEqual(
+      [...(tileOffsets ?? [])],
+      [797, 861, 925, 993, 1057, 1121, 1189, 1253, 1317, 1385, 1449, 1513, 1577, 1641, 1705, 1769],
+    );
   });
 });

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

@@ -86,6 +86,14 @@ export enum PlanarConfiguration {
   Separate = 2,
 }
 
+export enum Predictor {
+  None = 1,
+  /** Horizontal differencing */
+  Horizontal = 2,
+  /** Floating point */
+  FloatingPoint = 3,
+}
+
 export enum SampleFormat {
   /** Unsigned integer data */
   Uint = 1,
@@ -417,13 +425,14 @@ export interface TiffTagType {
 
   [TiffTag.TileWidth]: number;
   [TiffTag.TileHeight]: number;
-  [TiffTag.TileOffsets]: number[];
-  [TiffTag.TileByteCounts]: number[];
+  [TiffTag.TileOffsets]: number[] | Uint32Array | Uint16Array;
+  [TiffTag.TileByteCounts]: number[] | Uint32Array | Uint16Array;
   [TiffTag.JpegTables]: number[];
 
-  [TiffTag.StripByteCounts]: number[];
-  [TiffTag.StripOffsets]: number[];
+  [TiffTag.StripByteCounts]: number[] | Uint32Array | Uint16Array;
+  [TiffTag.StripOffsets]: number[] | Uint32Array | Uint16Array;
 
+  [TiffTag.SamplesPerPixel]: number;
   [TiffTag.SampleFormat]: SampleFormat[];
   [TiffTag.GdalMetadata]: string;
   [TiffTag.GdalNoData]: string;
@@ -436,6 +445,7 @@ export interface TiffTagType {
 
   [TiffTag.PlanarConfiguration]: PlanarConfiguration;
   [TiffTag.Orientation]: Orientation;
+  [TiffTag.Predictor]: Predictor;
 
   [TiffTag.LercParameters]: number[];
 
@@ -460,7 +470,6 @@ export interface TiffTagType {
   [TiffTag.Model]: unknown;
   [TiffTag.ResolutionUnit]: unknown;
   [TiffTag.RowsPerStrip]: unknown;
-  [TiffTag.SamplesPerPixel]: unknown;
   [TiffTag.Software]: unknown;
 
   [TiffTag.Threshholding]: unknown;
@@ -478,7 +487,6 @@ export interface TiffTagType {
   [TiffTag.Indexed]: unknown;
   [TiffTag.PageName]: unknown;
   [TiffTag.PageNumber]: unknown;
-  [TiffTag.Predictor]: unknown;
   [TiffTag.PrimaryChromaticities]: unknown;
   [TiffTag.ReferenceBlackWhite]: unknown;
   [TiffTag.SMinSampleValue]: unknown;
@@ -751,7 +759,7 @@ export interface TiffTagGeoType {
 /**
  * EPSG Angular Units. exist between [9100,  9199]
  *
- * Taken from libegotiff
+ * Taken from libgeotiff
  */
 export enum AngularUnit {
   Radian = 9101,
@@ -766,7 +774,7 @@ export enum AngularUnit {
 /**
  * ESPG Liner units exist between [9000,  9099]
  *
- * Taken from libegotiff
+ * Taken from libgeotiff
  */
 export enum LinearUnit {
   Metre = 9001,

package/src/index.ts

@@ -1,17 +1,6 @@
 export { TiffEndian } from './const/tiff.endian.js';
 export { TiffCompressionMimeType as TiffCompression, TiffMimeType } from './const/tiff.mime.js';
 export type { TiffTagGeoType, TiffTagType } from './const/tiff.tag.id.js';
-export { TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
-export { TiffTagValueType } from './const/tiff.tag.value.js';
-export { TiffVersion } from './const/tiff.version.js';
-export type { Tag, TagInline, TagLazy, TagOffset } from './read/tiff.tag.js';
-export { getTiffTagSize } from './read/tiff.value.reader.js';
-export type { Source } from './source.js';
-export { TiffImage } from './tiff.image.js';
-export { Tiff } from './tiff.js';
-export { toHex } from './util/util.hex.js';
-export type { BoundingBox, Point, Size, Vector } from './vector.js';
-
 // Tag value constants
 export {
   AngularUnit,
@@ -22,7 +11,21 @@ export {
   Orientation,
   Photometric,
   PlanarConfiguration,
+  Predictor,
   RasterTypeKey,
   SampleFormat,
   SubFileType,
+  TiffTag,
+  TiffTagGeo,
 } from './const/tiff.tag.id.js';
+export { TiffTagValueType } from './const/tiff.tag.value.js';
+export { TiffVersion } from './const/tiff.version.js';
+export type { Tag, TagInline, TagLazy, TagOffset } from './read/tiff.tag.js';
+export { getTiffTagSize } from './read/tiff.value.reader.js';
+export type { Source } from './source.js';
+export type { TiffImageTileCount } from './tiff.image.js';
+export { TiffImage } from './tiff.image.js';
+export type { TiffCreationOptions } from './tiff.js';
+export { Tiff } from './tiff.js';
+export { toHex } from './util/util.hex.js';
+export type { BoundingBox, Point, Size, Vector } from './vector.js';

package/src/read/endian.ts

@@ -0,0 +1,6 @@
+const buffer = new ArrayBuffer(4);
+const uint32 = new Uint32Array(buffer);
+const uint8 = new Uint8Array(buffer);
+uint32[0] = 1;
+
+export const isLittleEndian = uint8[0] === 1;

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

@@ -5,6 +5,7 @@ import type { Tiff } 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';
+import { isLittleEndian } from './endian.js';
 import type { Tag, TagLazy, TagOffset } from './tiff.tag.js';
 import { getTiffTagSize } from './tiff.value.reader.js';
 
@@ -57,6 +58,42 @@ function readTagValue(
   }
 }
 
+/**
+ * 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<T>(
+  tiff: Tiff,
+  bytes: DataView,
+  offset: number,
+  length: number,
+  type: TiffTagValueType,
+): T | null {
+  switch (type) {
+    case TiffTagValueType.Uint8:
+      return new Uint8Array(
+        bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length),
+      ) as unknown as T;
+    case TiffTagValueType.Uint16:
+      if (tiff.isLittleEndian !== isLittleEndian) return null;
+      return new Uint16Array(
+        bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length),
+      ) as unknown as T;
+    case TiffTagValueType.Uint32:
+      if (tiff.isLittleEndian !== isLittleEndian) return null;
+      return new Uint32Array(
+        bytes.buffer.slice(bytes.byteOffset + offset, bytes.byteOffset + offset + length),
+      ) as unknown as T;
+  }
+  return null;
+}
+
 function readValue<T>(
   tiff: Tiff,
   tagId: TiffTag | undefined,
@@ -84,6 +121,17 @@ function readValue<T>(
       ) as unknown as T;
   }
 
+  // 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 as unknown as T;
+  }
+
   const output = [];
   for (let i = 0; i < dataLength; i += typeSize) {
     output.push(readTagValue(type, bytes, offset + i, tiff.isLittleEndian));
@@ -133,8 +181,17 @@ export function createTag(tiff: Tiff, view: DataViewOffset, offset: number): Tag
         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 as number[] | Uint32Array | Uint16Array;
+          tag.isLoaded = true;
+        } else {
+          setBytes(tag, view);
+        }
+      }
+
       return tag;
   }
 
@@ -161,7 +218,7 @@ 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<number[]> {
+export async function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<TagOffset['value']> {
   const dataTypeSize = getTiffTagSize(tag.dataType);
 
   if (tag.view == null) {
@@ -171,6 +228,7 @@ export async function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<numbe
   }
 
   tag.value = readValue(tiff, tag.id, tag.view, 0, tag.dataType, tag.count);
+  tag.view = undefined;
   tag.isLoaded = true;
   return tag.value;
 }
@@ -204,3 +262,15 @@ export async function getValueAt(tiff: Tiff, tag: TagOffset, index: number): Pro
   tag.value[index] = value;
   return value;
 }
+
+export function getValueAtSync(tiff: Tiff, tag: TagOffset, index: number): number | null {
+  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/src/read/tiff.tag.ts

@@ -38,7 +38,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 */

package/src/source.ts

@@ -13,7 +13,7 @@ export interface Source {
   };
 
   /** 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>;