@cogeotiff/core 8.1.1 → 9.0.1

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

@@ -1,18 +1,18 @@
 export enum TiffTagValueType {
-  Uint8 = 0x0001,
-  Ascii = 0x0002,
-  Uint16 = 0x0003,
-  Uint32 = 0x0004,
-  Rational = 0x0005,
-  Int8 = 0x0006,
-  Undefined = 0x0007,
-  Int16 = 0x0008,
-  Int32 = 0x0009,
-  SignedRational = 0x000a,
-  Float32 = 0x000b,
-  Float64 = 0x000c,
-  // introduced by BigTIFF
-  Uint64 = 0x0010,
-  Int64 = 0x0011,
-  Ifd8 = 0x0012,
+  Uint8 = 1,
+  Ascii = 2,
+  Uint16 = 3,
+  Uint32 = 4,
+  Rational = 5,
+  Int8 = 6,
+  Undefined = 7,
+  Int16 = 8,
+  Int32 = 9,
+  SignedRational = 10,
+  Float32 = 11,
+  Float64 = 12,
+  // BigTiff
+  Uint64 = 16,
+  Int64 = 17,
+  Ifd8 = 18,
 }

package/src/index.ts

@@ -1,12 +1,27 @@
-export { CogTiff } from './cog.tiff.js';
-export { CogTiffImage } from './cog.tiff.image.js';
 export { TiffEndian } from './const/tiff.endian.js';
-export { TiffCompression, TiffMimeType } from './const/tiff.mime.js';
-export { TiffTagGeo, TiffTag } from './const/tiff.tag.id.js';
+export { TiffCompressionMimeType as TiffCompression, TiffMimeType } from './const/tiff.mime.js';
+export { TiffTag, TiffTagGeo, TiffTagGeoType, TiffTagType } from './const/tiff.tag.id.js';
 export { TiffTagValueType } from './const/tiff.tag.value.js';
 export { TiffVersion } from './const/tiff.version.js';
-export { TagInline, TagLazy, TagOffset, Tag } from './read/tiff.tag.js';
+export { Tag, TagInline, TagLazy, TagOffset } from './read/tiff.tag.js';
 export { getTiffTagSize } from './read/tiff.value.reader.js';
 export { 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,
+  Compression,
+  LinearUnit,
+  ModelTypeCode,
+  OldSubFileType,
+  Orientation,
+  Photometric,
+  PlanarConfiguration,
+  RasterTypeKey,
+  SampleFormat,
+  SubFileType,
+} from './const/tiff.tag.id.js';

package/src/read/tiff.gdal.ts

@@ -22,7 +22,7 @@ export enum GhostOptionTileLeader {
  * GDAL has made a ghost set of options for Tiff files
  * this class represents the optimizations that GDAL has applied
  */
-export class CogTifGhostOptions {
+export class TiffGhostOptions {
   options: Map<string, string> = new Map();
 
   /**

package/src/read/tiff.ifd.config.ts

@@ -1,5 +1,5 @@
-import { ByteSize } from '../util/bytes.js';
 import { TiffVersion } from '../const/tiff.version.js';
+import { ByteSize } from '../util/bytes.js';
 
 export const TagTiffConfig: TiffIfdConfig = {
   version: TiffVersion.Tiff,

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

@@ -1,6 +1,6 @@
-import { CogTiff } from '../cog.tiff.js';
-import { TiffTag } from '../const/tiff.tag.id.js';
+import { TiffTag, TiffTagConvertArray } from '../const/tiff.tag.id.js';
 import { TiffTagValueType } from '../const/tiff.tag.value.js';
+import { Tiff } from '../tiff.js';
 import { getUint, getUint64 } from '../util/bytes.js';
 import { DataViewOffset, hasBytes } from './data.view.offset.js';
 import { Tag, TagLazy, TagOffset } from './tiff.tag.js';
@@ -54,11 +54,24 @@ function readTagValue(
   }
 }
 
-function readValue<T>(tiff: CogTiff, bytes: DataView, offset: number, type: TiffTagValueType, count: number): T {
+function readValue<T>(
+  tiff: Tiff,
+  tagId: TiffTag | undefined,
+  bytes: DataView,
+  offset: number,
+  type: TiffTagValueType,
+  count: number,
+): T {
   const typeSize = getTiffTagSize(type);
   const dataLength = count * typeSize;
 
-  if (count === 1) return readTagValue(type, bytes, offset, tiff.isLittleEndian) as unknown as T;
+  if (count === 1) {
+    const val = readTagValue(type, bytes, offset, tiff.isLittleEndian) as unknown as T;
+    // Force some single values to be arrays eg BitsPerSample
+    // makes it easier to not check for number | number[]
+    if (tagId && TiffTagConvertArray[tagId]) return [val] as T;
+    return val;
+  }
 
   switch (type) {
     case TiffTagValueType.Ascii:
@@ -85,7 +98,7 @@ function readValue<T>(tiff: CogTiff, bytes: DataView, offset: number, type: Tiff
  * @param view Bytes to read from
  * @param offset Offset in the dataview to read a tag
  */
-export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number): Tag<unknown> {
+export function createTag(tiff: Tiff, view: DataViewOffset, offset: number): Tag<unknown> {
   const tagId = view.getUint16(offset + 0, tiff.isLittleEndian);
 
   const dataType = view.getUint16(offset + 2, tiff.isLittleEndian) as TiffTagValueType;
@@ -95,8 +108,8 @@ export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number):
 
   // Tag value is inline read the value
   if (dataLength <= tiff.ifdConfig.pointer) {
-    const value = readValue(tiff, view, offset + 4 + tiff.ifdConfig.pointer, dataType, dataCount);
-    return { type: 'inline', id: tagId, count: dataCount, value, dataType, tagOffset: offset };
+    const value = readValue(tiff, tagId, view, offset + 4 + tiff.ifdConfig.pointer, dataType, dataCount);
+    return { type: 'inline', id: tagId, name: TiffTag[tagId], count: dataCount, value, dataType, tagOffset: offset };
   }
 
   const dataOffset = getUint(view, offset + 4 + tiff.ifdConfig.pointer, tiff.ifdConfig.pointer, tiff.isLittleEndian);
@@ -108,6 +121,7 @@ export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number):
       const tag: TagOffset = {
         type: 'offset',
         id: tagId,
+        name: TiffTag[tagId],
         count: dataCount,
         dataType,
         dataOffset,
@@ -122,28 +136,28 @@ export function createTag(tiff: CogTiff, view: DataViewOffset, offset: number):
 
   // If we already have the bytes in the view read them in
   if (hasBytes(view, dataOffset, dataLength)) {
-    const value = readValue(tiff, view, dataOffset - view.sourceOffset, dataType, dataCount);
-    return { type: 'inline', id: tagId, count: dataCount, value, dataType, tagOffset: offset };
+    const value = readValue(tiff, tagId, view, dataOffset - view.sourceOffset, dataType, dataCount);
+    return { type: 'inline', id: tagId, name: TiffTag[tagId], count: dataCount, value, dataType, tagOffset: offset };
   }
 
-  return { type: 'lazy', id: tagId, count: dataCount, dataOffset, dataType, tagOffset: offset };
+  return { type: 'lazy', id: tagId, name: TiffTag[tagId], count: dataCount, dataOffset, dataType, tagOffset: offset };
 }
 
 /** Fetch the value from a {@link TagLazy} tag */
-export async function fetchLazy<T>(tag: TagLazy<T>, tiff: CogTiff): Promise<T> {
+export async function fetchLazy<T>(tag: TagLazy<T>, tiff: Tiff): 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 view = new DataView(bytes);
-  tag.value = readValue(tiff, view, 0, tag.dataType, tag.count);
+  tag.value = readValue(tiff, tag.id, view, 0, tag.dataType, tag.count);
   return tag.value as T;
 }
 
 /**
  * Fetch all the values from a {@link TagOffset}
  */
-export async function fetchAllOffsets(tiff: CogTiff, tag: TagOffset): Promise<number[]> {
+export async function fetchAllOffsets(tiff: Tiff, tag: TagOffset): Promise<number[]> {
   const dataTypeSize = getTiffTagSize(tag.dataType);
 
   if (tag.view == null) {
@@ -152,7 +166,7 @@ export async function fetchAllOffsets(tiff: CogTiff, tag: TagOffset): Promise<nu
     tag.view.sourceOffset = tag.dataOffset;
   }
 
-  tag.value = readValue(tiff, tag.view, 0, tag.dataType, tag.count) as number[];
+  tag.value = readValue(tiff, tag.id, tag.view, 0, tag.dataType, tag.count) as number[];
   tag.isLoaded = true;
   return tag.value;
 }
@@ -165,7 +179,7 @@ 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: CogTiff, tag: TagOffset, index: number): Promise<number> {
+export async function getValueAt(tiff: Tiff, tag: TagOffset, index: number): 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);
@@ -173,12 +187,14 @@ export async function getValueAt(tiff: CogTiff, tag: TagOffset, index: number):
   if (tag.view == null) {
     const bytes = await tiff.source.fetch(tag.dataOffset + index * dataTypeSize, dataTypeSize);
     const view = new DataView(bytes);
-    const value = readValue(tiff, view, 0, tag.dataType, 1) as number;
+    // Skip type conversion to array by using undefined tiff tag id
+    const value = readValue(tiff, undefined, view, 0, tag.dataType, 1) as number;
     tag.value[index] = value;
     return value;
   }
 
-  const value = readValue(tiff, tag.view, index * dataTypeSize, tag.dataType, 1) as number;
+  // Skip type conversion to array by using undefined tiff tag id
+  const value = readValue(tiff, undefined, tag.view, index * dataTypeSize, tag.dataType, 1) as number;
   tag.value[index] = value;
   return value;
 }

package/src/read/tiff.tag.ts

@@ -8,6 +8,8 @@ export type Tag<T = unknown> = TagLazy<T> | TagInline<T> | TagOffset;
 export interface TagBase {
   /** Id of the Tag */
   id: TiffTag;
+  /** Name of the tiff tag */
+  name: string;
   /** Offset in bytes to where this tag was read from */
   tagOffset: number;
   /** Number of values */
@@ -28,6 +30,7 @@ export interface TagLazy<T> extends TagBase {
 /** Tiff tag that's value is inside the IFD and is already read */
 export interface TagInline<T> extends TagBase {
   type: 'inline';
+  /** Value of the tag */
   value: T;
 }
 

package/src/read/tiff.value.reader.ts

@@ -1,5 +1,5 @@
-import { ByteSize } from '../util/bytes.js';
 import { TiffTagValueType } from '../const/tiff.tag.value.js';
+import { ByteSize } from '../util/bytes.js';
 
 export function getTiffTagSize(fieldType: TiffTagValueType): ByteSize {
   switch (fieldType) {

package/src/{cog.tiff.image.ts → tiff.image.ts}

@@ -1,10 +1,10 @@
-import { getUint } from './util/bytes.js';
-import { CogTiff } from './cog.tiff.js';
-import { TiffCompression, TiffMimeType } from './const/tiff.mime.js';
-import { TiffTag, TiffTagGeo } from './const/tiff.tag.id.js';
+import { getCompressionMimeType, TiffCompressionMimeType, TiffMimeType } from './const/tiff.mime.js';
+import { Compression, SubFileType, TiffTag, TiffTagGeo, TiffTagGeoType, TiffTagType } from './const/tiff.tag.id.js';
+import { fetchAllOffsets, fetchLazy, getValueAt } from './read/tiff.tag.factory.js';
 import { Tag, TagInline, TagOffset } from './read/tiff.tag.js';
+import { Tiff } from './tiff.js';
+import { getUint } from './util/bytes.js';
 import { BoundingBox, Size } from './vector.js';
-import { fetchAllOffsets, fetchLazy, getValueAt } from './read/tiff.tag.factory.js';
 
 /** Invalid EPSG code */
 export const InvalidProjectionCode = 32767;
@@ -12,7 +12,7 @@ export const InvalidProjectionCode = 32767;
 /**
  * Number of tiles used inside this image
  */
-export interface CogTiffImageTiledCount {
+export interface TiffImageTileCount {
   /** Number of tiles on the x axis */
   x: number;
   /** Number of tiles on the y axis */
@@ -38,16 +38,14 @@ export const ImportantTags = new Set([
 /**
  * Size of a individual tile
  */
-export interface CogTiffImageTileSize {
+export interface TiffImageTileSize {
   /** Tile width (pixels) */
   width: number;
   /** Tile height (pixels) */
   height: number;
 }
 
-export class CogTiffImage {
-  /** All IFD tags that have been read for the image */
-  tags: Map<TiffTag, Tag>;
+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
@@ -56,13 +54,15 @@ export class CogTiffImage {
    */
   id: number;
   /** Reference to the TIFF that owns this image */
-  tiff: CogTiff;
+  tiff: Tiff;
   /** Has loadGeoTiffTags been called */
   isGeoTagsLoaded = false;
   /** Sub tags stored in TiffTag.GeoKeyDirectory */
-  tagsGeo: Map<TiffTagGeo, string | number> = new Map();
+  tagsGeo: Map<TiffTagGeo, string | number | number[]> = new Map();
+  /** All IFD tags that have been read for the image */
+  tags: Map<TiffTag, Tag>;
 
-  constructor(tiff: CogTiff, id: number, tags: Map<TiffTag, Tag>) {
+  constructor(tiff: Tiff, id: number, tags: Map<TiffTag, Tag>) {
     this.tiff = tiff;
     this.id = id;
     this.tags = tags;
@@ -74,7 +74,7 @@ export class CogTiffImage {
    * @param loadGeoTags Whether to load the GeoKeyDirectory and unpack it
    */
   async init(loadGeoTags = true): Promise<void> {
-    const requiredTags = [
+    const requiredTags: Promise<unknown>[] = [
       this.fetch(TiffTag.Compression),
       this.fetch(TiffTag.ImageHeight),
       this.fetch(TiffTag.ImageWidth),
@@ -96,16 +96,83 @@ export class CogTiffImage {
   }
 
   /**
-   * Get the value of a TiffTag if it has been loaded, null otherwise
+   * Get the value of a TiffTag if it has been loaded, null otherwise.
+   *
+   * If the value is not loaded use {@link TiffImage.fetch} to load the value
+   * Or use {@link TiffImage.has} to check if the tag exists
+   *
    *
-   * if the value is not loaded @see {CogTiffImage.fetch}
    * @returns value if loaded, null otherwise
    */
-  value<T>(tag: TiffTag): T | null {
+  value<T extends keyof TiffTagType>(tag: T): TiffTagType[T] | null {
     const sourceTag = this.tags.get(tag);
     if (sourceTag == null) return null;
     if (sourceTag.type === 'offset' && sourceTag.isLoaded === false) return null;
-    return sourceTag.value as T;
+    // TODO would be good to type check this
+    return sourceTag.value as TiffTagType[T];
+  }
+
+  /**
+   * Does the tag exist
+   *
+   * @example
+   * ```typescript
+   * img.has(TiffTag.ImageWidth) // true
+   * ```
+   *
+   * @param tag Tag to check
+   * @returns true if the tag exists, false otherwise
+   */
+  has<T extends keyof TiffTagType>(tag: T): boolean {
+    return this.tags.has(tag);
+  }
+
+  /**
+   * Load a tag.
+   *
+   * If it is not currently loaded, fetch the required data for the tag.
+   *
+   * @example
+   * ```typescript
+   * await img.fetch(TiffTag.ImageWidth) // 512 (px)
+   * ```
+   *
+   * @param tag tag to fetch
+   */
+  public async fetch<T extends keyof TiffTagType>(tag: T): 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.isLoaded) return sourceTag.value as TiffTagType[T];
+    if (sourceTag.type === 'offset') return fetchAllOffsets(this.tiff, sourceTag) as Promise<TiffTagType[T]>;
+    throw new Error('Cannot fetch:' + tag);
+  }
+  /**
+   * Get the associated TiffTagGeo
+   *
+   * @example
+   * ```typescript
+   * image.valueGeo(TiffTagGeo.GTRasterTypeGeoKey)
+   * ```
+   * @throws if {@link loadGeoTiffTags} has not been called
+   */
+  valueGeo<T extends keyof TiffTagGeoType>(tag: T): TiffTagGeoType[T] | null {
+    if (this.isGeoTagsLoaded === false) throw new Error('loadGeoTiffTags() has not been called');
+    return this.tagsGeo.get(tag) as TiffTagGeoType[T];
+  }
+
+  /**
+   * Load and parse the GDAL_NODATA Tifftag
+   *
+   * @throws if the tag is not loaded
+   * @returns null if the tag does not exist
+   */
+  get noData(): number | null {
+    const tag = this.tags.get(TiffTag.GdalNoData);
+    if (tag == null) return null;
+    if (tag.value) return Number(tag.value);
+    throw new Error('GdalNoData tag is not loaded');
   }
 
   /**
@@ -152,60 +219,31 @@ export class CogTiffImage {
         this.tagsGeo.set(key, tag.value.slice(offset, offset + count - 1).trim());
       } else if (Array.isArray(tag.value)) {
         if (count === 1) this.tagsGeo.set(key, tag.value[offset]);
-        else this.tagsGeo.set(key, tag.value.slice(offset, offset + count) as any);
+        else this.tagsGeo.set(key, tag.value.slice(offset, offset + count));
       } else {
         throw new Error('Failed to extract GeoTiffTags');
       }
     }
   }
 
-  /**
-   * Get the associated TiffTagGeo
-   *
-   * @example
-   * ```typescript
-   * image.valueGeo(TiffTagGeo.GTRasterTypeGeoKey)
-   * ```
-   * @throws if {@link loadGeoTiffTags} has not been called
-   */
-  valueGeo(tag: TiffTagGeo): string | number | undefined {
-    if (this.isGeoTagsLoaded === false) throw new Error('loadGeoTiffTags() has not been called');
-    return this.tagsGeo.get(tag);
-  }
-
-  /**
-   * Load a tag, if it is not currently loaded, fetch the required data for the tag.
-   *
-   * @param tag tag to fetch
-   */
-  public async fetch<T>(tag: TiffTag): Promise<T | null> {
-    const sourceTag = this.tags.get(tag);
-    if (sourceTag == null) return null;
-    if (sourceTag.type === 'inline') return sourceTag.value as unknown as T;
-    if (sourceTag.type === 'lazy') return fetchLazy(sourceTag, this.tiff) as T;
-    if (sourceTag.isLoaded) return sourceTag.value as unknown as T;
-    if (sourceTag.type === 'offset') return fetchAllOffsets(this.tiff, sourceTag) as T;
-    throw new Error('Cannot fetch:' + tag);
-  }
-
   /**
    * Get the origin point for the image
    *
    * @returns origin point of the image
    */
   get origin(): [number, number, number] {
-    const tiePoints: number[] | null = this.value<number[]>(TiffTag.ModelTiePoint);
+    const tiePoints = this.value(TiffTag.ModelTiePoint);
     if (tiePoints != null && tiePoints.length === 6) {
       return [tiePoints[3], tiePoints[4], tiePoints[5]];
     }
 
-    const modelTransformation = this.value<number[]>(TiffTag.ModelTransformation);
+    const modelTransformation = this.value(TiffTag.ModelTransformation);
     if (modelTransformation != null) {
       return [modelTransformation[3], modelTransformation[7], modelTransformation[11]];
     }
 
     // If this is a sub image, use the origin from the top level image
-    if (this.value(TiffTag.NewSubFileType) === 1 && this.id !== 0) {
+    if (this.value(TiffTag.SubFileType) === SubFileType.ReducedImage && this.id !== 0) {
       return this.tiff.images[0].origin;
     }
 
@@ -218,7 +256,7 @@ export class CogTiffImage {
       this.value(TiffTag.ModelPixelScale) != null || this.value(TiffTag.ModelTransformation) != null;
     if (isImageLocated) return true;
     // If this is a sub image, use the isGeoLocated from the top level image
-    if (this.value(TiffTag.NewSubFileType) === 1 && this.id !== 0) return this.tiff.images[0].isGeoLocated;
+    if (this.isSubImage && this.id !== 0) return this.tiff.images[0].isGeoLocated;
     return false;
   }
 
@@ -238,7 +276,7 @@ export class CogTiffImage {
     }
 
     // If this is a sub image, use the resolution from the top level image
-    if (this.value(TiffTag.NewSubFileType) === 1 && this.id !== 0) {
+    if (this.isSubImage && this.id !== 0) {
       const firstImg = this.tiff.images[0];
       const [resX, resY, resZ] = firstImg.resolution;
       const firstImgSize = firstImg.size;
@@ -250,6 +288,15 @@ export class CogTiffImage {
     throw new Error('Image does not have a geo transformation.');
   }
 
+  /**
+   * Is this image a reduced size image
+   * @see {@link TiffTag.SubFileType}
+   * @returns true if SubFileType is Reduces image, false otherwise
+   */
+  get isSubImage(): boolean {
+    return this.value(TiffTag.SubFileType) === SubFileType.ReducedImage;
+  }
+
   /**
    * Bounding box of the image
    *
@@ -276,23 +323,25 @@ export class CogTiffImage {
   /**
    * Get the compression used by the tile
    *
-   * @see {@link TiffCompression}
+   * @see {@link TiffCompressionMimeType}
    *
    * @returns Compression type eg webp
    */
   get compression(): TiffMimeType | null {
     const compression = this.value(TiffTag.Compression);
-    if (compression == null || typeof compression !== 'number') return null;
-    return TiffCompression[compression];
+    if (compression == null) return null;
+    return TiffCompressionMimeType[compression];
   }
 
   /**
    * Attempt to read the EPSG Code from TiffGeoTags
    *
+   * looks at both TiffTagGeo.ProjectionGeoKey and TiffTagGeo.ProjectedCRSGeoKey
+   *
    * @returns EPSG Code if it exists
    */
   get epsg(): number | null {
-    const projection = this.valueGeo(TiffTagGeo.ProjectedCSTypeGeoKey) as number;
+    const projection = this.valueGeo(TiffTagGeo.ProjectionGeoKey) ?? this.valueGeo(TiffTagGeo.ProjectedCRSGeoKey);
     if (projection === InvalidProjectionCode) return null;
     return projection;
   }
@@ -303,10 +352,11 @@ export class CogTiffImage {
    * @returns Size in pixels
    */
   get size(): Size {
-    return {
-      width: this.value<number>(TiffTag.ImageWidth) as number,
-      height: this.value<number>(TiffTag.ImageHeight) as number,
-    };
+    const width = this.value(TiffTag.ImageWidth);
+    const height = this.value(TiffTag.ImageWidth);
+    if (width == null || height == null) throw new Error('Tiff has no height or width');
+
+    return { width, height };
   }
 
   /**
@@ -319,17 +369,17 @@ export class CogTiffImage {
   /**
    * Get size of individual tiles
    */
-  get tileSize(): CogTiffImageTileSize {
-    return {
-      width: this.value<number>(TiffTag.TileWidth) as number,
-      height: this.value<number>(TiffTag.TileHeight) as number,
-    };
+  get tileSize(): TiffImageTileSize {
+    const width = this.value(TiffTag.TileWidth);
+    const height = this.value(TiffTag.TileHeight);
+    if (width == null || height == null) throw new Error('Tiff is not tiled');
+    return { width, height };
   }
 
   /**
    * Number of tiles used to create this image
    */
-  get tileCount(): CogTiffImageTiledCount {
+  get tileCount(): TiffImageTileCount {
     const size = this.size;
     const tileSize = this.tileSize;
     const x = Math.ceil(size.width / tileSize.width);
@@ -344,7 +394,7 @@ export class CogTiffImage {
    *
    * @returns file offset to where the tiffs are stored
    */
-  get tileOffset(): TagOffset {
+  get tileOffset(): TagOffset | TagInline<number[]> {
     const tileOffset = this.tags.get(TiffTag.TileOffsets) as TagOffset;
     if (tileOffset == null) throw new Error('No tile offsets found');
     return tileOffset;
@@ -358,9 +408,7 @@ export class CogTiffImage {
    * @returns number of strips present
    */
   get stripCount(): number {
-    const tileOffset = this.tags.get(TiffTag.StripByteCounts) as TagOffset;
-    if (tileOffset == null) return 0;
-    return tileOffset.count;
+    return this.tags.get(TiffTag.StripByteCounts)?.count ?? 0;
   }
 
   // Clamp the bounds of the output image to the size of the image, as sometimes the edge tiles are not full tiles
@@ -396,10 +444,10 @@ export class CogTiffImage {
   }
 
   /** The jpeg header is stored in the IFD, read the JPEG header and adjust the byte array to include it */
-  private getJpegHeader(bytes: ArrayBuffer): ArrayBuffer {
+  getJpegHeader(bytes: ArrayBuffer): ArrayBuffer {
     // Both the JPEGTable and the Bytes with have the start of image and end of image markers
     // StartOfImage 0xffd8 EndOfImage 0xffd9
-    const tables = this.value<number[]>(TiffTag.JPEGTables);
+    const tables = this.value(TiffTag.JpegTables);
     if (tables == null) throw new Error('Unable to find Jpeg header');
 
     // Remove EndOfImage marker
@@ -411,20 +459,23 @@ export class CogTiffImage {
   }
 
   /** Read image bytes at the given offset */
-  private async getBytes(
+  async getBytes(
     offset: number,
     byteCount: number,
-  ): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer } | null> {
-    const mimeType = this.compression;
-    if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TiffTag.Compression));
+  ): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer; compression: Compression } | null> {
     if (byteCount === 0) return null;
 
     const bytes = await this.tiff.source.fetch(offset, byteCount);
     if (bytes.byteLength < byteCount) {
       throw new Error(`Failed to fetch bytes from offset:${offset} wanted:${byteCount} got:${bytes.byteLength}`);
     }
-    if (this.compression === TiffMimeType.Jpeg) return { mimeType, bytes: this.getJpegHeader(bytes) };
-    return { mimeType, bytes };
+
+    let compression = this.value(TiffTag.Compression);
+    if (compression == null) compression = Compression.None; // No compression found default ??
+    const mimeType = getCompressionMimeType(compression) ?? TiffMimeType.None;
+
+    if (compression === Compression.Jpeg) return { mimeType, bytes: this.getJpegHeader(bytes), compression };
+    return { mimeType, bytes, compression };
   }
 
   /**
@@ -435,13 +486,14 @@ export class CogTiffImage {
    * @param x Tile x offset
    * @param y Tile y offset
    */
-  async getTile(x: number, y: number): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer } | null> {
-    const mimeType = this.compression;
+  async getTile(
+    x: number,
+    y: number,
+  ): Promise<{ mimeType: TiffMimeType; bytes: ArrayBuffer; compression: Compression } | null> {
     const size = this.size;
     const tiles = this.tileSize;
 
     if (tiles == null) throw new Error('Tiff is not tiled');
-    if (mimeType == null) throw new Error('Unsupported compression: ' + this.value(TiffTag.Compression));
 
     // TODO support GhostOptionTileOrder
     const nyTiles = Math.ceil(size.height / tiles.height);
@@ -497,7 +549,7 @@ export class CogTiffImage {
     const leaderBytes = this.tiff.options?.tileLeaderByteSize;
     if (leaderBytes) {
       const offset = await getOffset(this.tiff, this.tileOffset, index);
-      // Sparse COG no data found
+      // 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
@@ -516,15 +568,8 @@ export class CogTiffImage {
   }
 }
 
-function getOffset(
-  tiff: CogTiff,
-  x: TagOffset | TagInline<number | number[]>,
-  index: number,
-): number | Promise<number> {
+function getOffset(tiff: Tiff, x: TagOffset | TagInline<number[]>, index: number): number | Promise<number> {
   if (index > x.count || index < 0) throw new Error('TagIndex: out of bounds ' + x.id + ' @ ' + index);
-  if (x.type === 'inline') {
-    if (x.count > 1) return (x.value as number[])[index] as number;
-    return x.value as number;
-  }
+  if (x.type === 'inline') return x.value[index] as number;
   return getValueAt(tiff, x, index);
 }