@cogeotiff/core 9.2.0 → 9.4.0

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,3 +204,17 @@ export async function getValueAt(tiff, tag, index) {
     tag.value[index] = value;
     return value;
 }
+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/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;
@@ -24,9 +28,9 @@ export declare class Tiff {
     isInitialized: boolean;
     private _initPromise?;
     /** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
-    constructor(source: Source);
+    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.
      *

package/build/tiff.d.ts.map

@@ -1 +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,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;IAI1B,kEAAkE;IAClE,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5C;;;;;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"}
+{"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

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

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

@@ -1 +1 @@
-{"version":3,"file":"tiff.image.d.ts","sourceRoot":"","sources":["../src/tiff.image.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"tiff.image.d.ts","sourceRoot":"","sources":["../src/tiff.image.ts"],"names":[],"mappings":"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"}

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;
@@ -494,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 };
@@ -511,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}`);
     }
@@ -530,5 +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);
 }

package/build/tiff.js

@@ -28,12 +28,13 @@ export class Tiff {
     isInitialized = false;
     _initPromise;
     /** A Tiff constructed from a source will not be pre-initialized with {@link init}. */
-    constructor(source) {
+    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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cogeotiff/core",
-  "version": "9.2.0",
+  "version": "9.4.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/blacha/cogeotiff.git",
@@ -23,5 +23,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "62a59096f2df47bd12cc969afdda1d90c31d679e"
+  "gitHead": "2cb33fbbd63f87fc2535282a4dd4426a449dd758"
 }

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,6 +21,7 @@ export class TestFileSource implements Source {
 
   async fetch(offset: number, length: number): Promise<ArrayBuffer> {
     const fileData = await this.data;
+    this.fetches.push({ offset, length });
     return fileData.buffer.slice(fileData.byteOffset + offset, fileData.byteOffset + offset + length) as ArrayBuffer;
   }
 

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 {
@@ -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));
@@ -30,6 +36,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 +56,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 +103,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 +207,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 +267,30 @@ 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],
+    );
+  });
+
+  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 {
@@ -86,6 +106,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,
@@ -293,7 +321,7 @@ export enum TiffTag {
    *     0,     0, 0,        1]
    * ```
    */
-  ModelTransformation = 34744,
+  ModelTransformation = 34264,
   /**
    * List of GeoTiff tags
    * {@link TiffTagGeo}
@@ -417,12 +445,12 @@ 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[];
@@ -437,6 +465,7 @@ export interface TiffTagType {
 
   [TiffTag.PlanarConfiguration]: PlanarConfiguration;
   [TiffTag.Orientation]: Orientation;
+  [TiffTag.Predictor]: Predictor;
 
   [TiffTag.LercParameters]: number[];
 
@@ -478,7 +507,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;

package/src/index.ts

@@ -11,6 +11,7 @@ export {
   Orientation,
   Photometric,
   PlanarConfiguration,
+  Predictor,
   RasterTypeKey,
   SampleFormat,
   SubFileType,
@@ -22,7 +23,9 @@ 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;