@loaders.gl/geotiff 4.0.0-alpha.1 → 4.0.0-alpha.11

package/dist/lib/ome/ome-utils.js

@@ -1,73 +1,63 @@
-import { getDims, getLabels } from './utils';
-export const DTYPE_LOOKUP = {
-  uint8: 'Uint8',
-  uint16: 'Uint16',
-  uint32: 'Uint32',
-  float: 'Float32',
-  double: 'Float64',
-  int8: 'Int8',
-  int16: 'Int16',
-  int32: 'Int32'
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOmePixelSourceMeta = exports.DTYPE_LOOKUP = void 0;
+const utils_1 = require("./utils");
+exports.DTYPE_LOOKUP = {
+    uint8: 'Uint8',
+    uint16: 'Uint16',
+    uint32: 'Uint32',
+    float: 'Float32',
+    double: 'Float64',
+    int8: 'Int8',
+    int16: 'Int16',
+    int32: 'Int32'
 };
-export function getOmePixelSourceMeta({
-  Pixels
-}) {
-  const labels = getLabels(Pixels.DimensionOrder);
-  const dims = getDims(labels);
-  const shape = Array(labels.length).fill(0);
-  shape[dims('t')] = Pixels.SizeT;
-  shape[dims('c')] = Pixels.SizeC;
-  shape[dims('z')] = Pixels.SizeZ;
-
-  if (Pixels.Interleaved) {
-    labels.push('_c');
-    shape.push(3);
-  }
-
-  const getShape = level => {
-    const s = [...shape];
-    s[dims('x')] = Pixels.SizeX >> level;
-    s[dims('y')] = Pixels.SizeY >> level;
-    return s;
-  };
-
-  if (!(Pixels.Type in DTYPE_LOOKUP)) {
-    throw Error("Pixel type ".concat(Pixels.Type, " not supported."));
-  }
-
-  const dtype = DTYPE_LOOKUP[Pixels.Type];
-
-  if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {
-    const physicalSizes = {
-      x: {
-        size: Pixels.PhysicalSizeX,
-        unit: Pixels.PhysicalSizeXUnit
-      },
-      y: {
-        size: Pixels.PhysicalSizeY,
-        unit: Pixels.PhysicalSizeYUnit
-      }
-    };
-
-    if (Pixels.PhysicalSizeZ) {
-      physicalSizes.z = {
-        size: Pixels.PhysicalSizeZ,
-        unit: Pixels.PhysicalSizeZUnit
-      };
+function getOmePixelSourceMeta({ Pixels }) {
+    // e.g. 'XYZCT' -> ['t', 'c', 'z', 'y', 'x']
+    const labels = (0, utils_1.getLabels)(Pixels.DimensionOrder);
+    // Compute "shape" of image
+    const dims = (0, utils_1.getDims)(labels);
+    const shape = Array(labels.length).fill(0);
+    shape[dims('t')] = Pixels.SizeT;
+    shape[dims('c')] = Pixels.SizeC;
+    shape[dims('z')] = Pixels.SizeZ;
+    // Push extra dimension if data are interleaved.
+    if (Pixels.Interleaved) {
+        // @ts-ignore
+        labels.push('_c');
+        shape.push(3);
     }
-
-    return {
-      labels,
-      getShape,
-      physicalSizes,
-      dtype
+    // Creates a new shape for different level of pyramid.
+    // Assumes factor-of-two downsampling.
+    const getShape = (level) => {
+        const s = [...shape];
+        s[dims('x')] = Pixels.SizeX >> level;
+        s[dims('y')] = Pixels.SizeY >> level;
+        return s;
     };
-  }
-
-  return {
-    labels,
-    getShape,
-    dtype
-  };
+    if (!(Pixels.Type in exports.DTYPE_LOOKUP)) {
+        throw Error(`Pixel type ${Pixels.Type} not supported.`);
+    }
+    const dtype = exports.DTYPE_LOOKUP[Pixels.Type];
+    if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {
+        const physicalSizes = {
+            x: {
+                size: Pixels.PhysicalSizeX,
+                unit: Pixels.PhysicalSizeXUnit
+            },
+            y: {
+                size: Pixels.PhysicalSizeY,
+                unit: Pixels.PhysicalSizeYUnit
+            }
+        };
+        if (Pixels.PhysicalSizeZ) {
+            physicalSizes.z = {
+                size: Pixels.PhysicalSizeZ,
+                unit: Pixels.PhysicalSizeZUnit
+            };
+        }
+        return { labels, getShape, physicalSizes, dtype };
+    }
+    return { labels, getShape, dtype };
 }
-//# sourceMappingURL=ome-utils.js.map
+exports.getOmePixelSourceMeta = getOmePixelSourceMeta;

package/dist/lib/ome/omexml.d.ts

@@ -0,0 +1,49 @@
+export declare function fromString(str: string): {
+    format(): {
+        'Acquisition Date': string;
+        'Dimensions (XY)': string;
+        'Pixels Type': PixelType;
+        'Pixels Size (XYZ)': string;
+        'Z-sections/Timepoints': string;
+        Channels: number;
+    };
+    AquisitionDate: string;
+    Description: string;
+    Pixels: {
+        Channels: ({
+            Color: [number, number, number, number];
+            ID: string;
+            SamplesPerPixel: number;
+            Name?: string | undefined;
+        } | {
+            ID: string;
+            SamplesPerPixel: number;
+            Name?: string | undefined;
+        })[];
+        PhysicalSizeX: number;
+        PhysicalSizeY: number;
+        PhysicalSizeZ: number;
+        SignificantBits: number;
+        SizeX: number;
+        SizeY: number;
+        SizeZ: number;
+        SizeT: number;
+        SizeC: number;
+        PhysicalSizeXUnit: UnitsLength;
+        PhysicalSizeYUnit: UnitsLength;
+        PhysicalSizeZUnit: UnitsLength;
+        BigEndian: boolean;
+        Interleaved: boolean;
+        ID: string;
+        DimensionOrder: DimensionOrder;
+        Type: PixelType;
+    };
+    ID: string;
+    Name: string;
+}[];
+export type OMEXML = ReturnType<typeof fromString>;
+export type DimensionOrder = 'XYZCT' | 'XYZTC' | 'XYCTZ' | 'XYCZT' | 'XYTCZ' | 'XYTZC';
+type PixelType = 'int8' | 'int16' | 'int32' | 'uint8' | 'uint16' | 'uint32' | 'float' | 'bit' | 'double' | 'complex' | 'double-complex';
+export type UnitsLength = 'Ym' | 'Zm' | 'Em' | 'Pm' | 'Tm' | 'Gm' | 'Mm' | 'km' | 'hm' | 'dam' | 'm' | 'dm' | 'cm' | 'mm' | 'µm' | 'nm' | 'pm' | 'fm' | 'am' | 'zm' | 'ym' | 'Å' | 'thou' | 'li' | 'in' | 'ft' | 'yd' | 'mi' | 'ua' | 'ly' | 'pc' | 'pt' | 'pixel' | 'reference frame';
+export {};
+//# sourceMappingURL=omexml.d.ts.map

package/dist/lib/ome/omexml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omexml.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/omexml.ts"],"names":[],"mappings":"AAmBA,wBAAgB,UAAU,CAAC,GAAG,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8CrC;AAED,MAAM,MAAM,MAAM,GAAG,UAAU,CAAC,OAAO,UAAU,CAAC,CAAC;AACnD,MAAM,MAAM,cAAc,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,GAAG,OAAO,CAAC;AAuBvF,KAAK,SAAS,GACV,MAAM,GACN,OAAO,GACP,OAAO,GACP,OAAO,GACP,QAAQ,GACR,QAAQ,GACR,OAAO,GACP,KAAK,GACL,QAAQ,GACR,SAAS,GACT,gBAAgB,CAAC;AAErB,MAAM,MAAM,WAAW,GACnB,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,KAAK,GACL,GAAG,GACH,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,GAAG,GACH,MAAM,GACN,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,IAAI,GACJ,OAAO,GACP,iBAAiB,CAAC"}

package/dist/lib/ome/omexml.js

@@ -1,66 +1,66 @@
-import parser from 'fast-xml-parser';
-import { ensureArray, intToRgba } from '../utils/tiff-utils';
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fromString = void 0;
+const fast_xml_parser_1 = __importDefault(require("fast-xml-parser"));
+const tiff_utils_1 = require("../utils/tiff-utils");
+// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.
 const PARSER_OPTIONS = {
-  attributeNamePrefix: '',
-  attrNodeName: 'attr',
-  parseNodeValue: true,
-  parseAttributeValue: true,
-  ignoreAttributes: false
+    // Nests attributes withtout prefix under 'attr' key for each node
+    attributeNamePrefix: '',
+    attrNodeName: 'attr',
+    // Parses numbers for both attributes and nodes
+    parseNodeValue: true,
+    parseAttributeValue: true,
+    // Forces attributes to be parsed
+    ignoreAttributes: false
 };
-
-const parse = str => parser.parse(str, PARSER_OPTIONS);
-
-export function fromString(str) {
-  const res = parse(str);
-
-  if (!res.OME) {
-    throw Error('Failed to parse OME-XML metadata.');
-  }
-
-  return ensureArray(res.OME.Image).map(img => {
-    const Channels = ensureArray(img.Pixels.Channel).map(c => {
-      if ('Color' in c.attr) {
-        return { ...c.attr,
-          Color: intToRgba(c.attr.Color)
+const parse = (str) => fast_xml_parser_1.default.parse(str, PARSER_OPTIONS);
+function fromString(str) {
+    const res = parse(str);
+    if (!res.OME) {
+        throw Error('Failed to parse OME-XML metadata.');
+    }
+    return (0, tiff_utils_1.ensureArray)(res.OME.Image).map((img) => {
+        const Channels = (0, tiff_utils_1.ensureArray)(img.Pixels.Channel).map((c) => {
+            if ('Color' in c.attr) {
+                return { ...c.attr, Color: (0, tiff_utils_1.intToRgba)(c.attr.Color) };
+            }
+            return { ...c.attr };
+        });
+        const { AquisitionDate = '', Description = '' } = img;
+        const image = {
+            ...img.attr,
+            AquisitionDate,
+            Description,
+            Pixels: {
+                ...img.Pixels.attr,
+                Channels
+            }
         };
-      }
-
-      return { ...c.attr
-      };
-    });
-    const {
-      AquisitionDate = '',
-      Description = ''
-    } = img;
-    const image = { ...img.attr,
-      AquisitionDate,
-      Description,
-      Pixels: { ...img.Pixels.attr,
-        Channels
-      }
-    };
-    return { ...image,
-
-      format() {
-        const {
-          Pixels
-        } = image;
-        const sizes = ['X', 'Y', 'Z'].map(name => {
-          const size = Pixels["PhysicalSize".concat(name)];
-          const unit = Pixels["PhysicalSize".concat(name, "Unit")];
-          return size && unit ? "".concat(size, " ").concat(unit) : '-';
-        }).join(' x ');
         return {
-          'Acquisition Date': image.AquisitionDate,
-          'Dimensions (XY)': "".concat(Pixels.SizeX, " x ").concat(Pixels.SizeY),
-          'Pixels Type': Pixels.Type,
-          'Pixels Size (XYZ)': sizes,
-          'Z-sections/Timepoints': "".concat(Pixels.SizeZ, " x ").concat(Pixels.SizeT),
-          Channels: Pixels.SizeC
+            ...image,
+            format() {
+                const { Pixels } = image;
+                const sizes = ['X', 'Y', 'Z']
+                    .map((name) => {
+                    const size = Pixels[`PhysicalSize${name}`];
+                    const unit = Pixels[`PhysicalSize${name}Unit`];
+                    return size && unit ? `${size} ${unit}` : '-';
+                })
+                    .join(' x ');
+                return {
+                    'Acquisition Date': image.AquisitionDate,
+                    'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,
+                    'Pixels Type': Pixels.Type,
+                    'Pixels Size (XYZ)': sizes,
+                    'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,
+                    Channels: Pixels.SizeC
+                };
+            }
         };
-      }
-
-    };
-  });
+    });
 }
-//# sourceMappingURL=omexml.js.map
+exports.fromString = fromString;

package/dist/lib/ome/utils.d.ts

@@ -0,0 +1,5 @@
+import type { OMEXML } from '../ome/omexml';
+import type { Labels } from '../../types';
+export declare function getLabels(dimOrder: OMEXML[0]['Pixels']['DimensionOrder']): Labels<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>;
+export declare function getDims<S extends string>(labels: S[]): (name: S) => number;
+//# sourceMappingURL=utils.d.ts.map

package/dist/lib/ome/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAC1C,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,aAAa,CAAC;AAYxC,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,gBAAgB,CAAC,qHAExE;AAWD,wBAAgB,OAAO,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,EAAE,UAKrC,CAAC,YAOhB"}

package/dist/lib/ome/utils.js

@@ -1,21 +1,30 @@
-export function getLabels(dimOrder) {
-  return dimOrder.toLowerCase().split('').reverse();
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDims = exports.getLabels = void 0;
+function getLabels(dimOrder) {
+    return dimOrder.toLowerCase().split('').reverse();
 }
-export function getDims(labels) {
-  const lookup = new Map(labels.map((name, i) => [name, i]));
-
-  if (lookup.size !== labels.length) {
-    throw Error('Labels must be unique, found duplicated label.');
-  }
-
-  return name => {
-    const index = lookup.get(name);
-
-    if (index === undefined) {
-      throw Error('Invalid dimension.');
+exports.getLabels = getLabels;
+/*
+ * Creates an ES6 map of 'label' -> index
+ * > const labels = ['a', 'b', 'c', 'd'];
+ * > const dims = getDims(labels);
+ * > dims('a') === 0;
+ * > dims('b') === 1;
+ * > dims('c') === 2;
+ * > dims('hi!'); // throws
+ */
+function getDims(labels) {
+    const lookup = new Map(labels.map((name, i) => [name, i]));
+    if (lookup.size !== labels.length) {
+        throw Error('Labels must be unique, found duplicated label.');
     }
-
-    return index;
-  };
+    return (name) => {
+        const index = lookup.get(name);
+        if (index === undefined) {
+            throw Error('Invalid dimension.');
+        }
+        return index;
+    };
 }
-//# sourceMappingURL=utils.js.map
+exports.getDims = getDims;

package/dist/lib/tiff-pixel-source.d.ts

@@ -0,0 +1,18 @@
+import type { GeoTIFFImage } from 'geotiff';
+import type { PixelSource, PixelSourceSelection, PixelSourceMeta, Dtype, Labels, RasterSelection, TileSelection, PixelData } from '../types';
+declare class TiffPixelSource<S extends string[]> implements PixelSource<S> {
+    dtype: Dtype;
+    tileSize: number;
+    shape: number[];
+    labels: Labels<S>;
+    meta: PixelSourceMeta | undefined;
+    private _indexer;
+    constructor(indexer: (sel: PixelSourceSelection<S>) => Promise<GeoTIFFImage>, dtype: Dtype, tileSize: number, shape: number[], labels: Labels<S>, meta?: PixelSourceMeta);
+    getRaster({ selection, signal }: RasterSelection<S>): Promise<PixelData>;
+    getTile({ x, y, selection, signal }: TileSelection<S>): Promise<PixelData>;
+    private _readRasters;
+    private _getTileExtent;
+    onTileError(err: Error): void;
+}
+export default TiffPixelSource;
+//# sourceMappingURL=tiff-pixel-source.d.ts.map

package/dist/lib/tiff-pixel-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff-pixel-source.d.ts","sourceRoot":"","sources":["../../src/lib/tiff-pixel-source.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,YAAY,EAAgB,MAAM,SAAS,CAAC;AAGzD,OAAO,KAAK,EACV,WAAW,EACX,oBAAoB,EACpB,eAAe,EACf,KAAK,EACL,MAAM,EACN,eAAe,EACf,aAAa,EACb,SAAS,EAEV,MAAM,UAAU,CAAC;AAElB,cAAM,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE,CAAE,YAAW,WAAW,CAAC,CAAC,CAAC;IAC1D,KAAK,EAAE,KAAK,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAClB,IAAI,EAAE,eAAe,GAAG,SAAS,CAAC;IACzC,OAAO,CAAC,QAAQ,CAA0D;gBAIxE,OAAO,EAAE,CAAC,GAAG,EAAE,oBAAoB,CAAC,CAAC,CAAC,KAAK,OAAO,CAAC,YAAY,CAAC,EAChE,KAAK,EAAE,KAAK,EACZ,QAAQ,EAAE,MAAM,EAChB,KAAK,EAAE,MAAM,EAAE,EACf,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,EACjB,IAAI,CAAC,EAAE,eAAe;IAUlB,SAAS,CAAC,EAAC,SAAS,EAAE,MAAM,EAAC,EAAE,eAAe,CAAC,CAAC,CAAC;IAKjD,OAAO,CAAC,EAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,MAAM,EAAC,EAAE,aAAa,CAAC,CAAC,CAAC;YAU3C,YAAY;IAuB1B,OAAO,CAAC,cAAc;IAetB,WAAW,CAAC,GAAG,EAAE,KAAK;CAGvB;AAED,eAAe,eAAe,CAAC"}

package/dist/lib/tiff-pixel-source.js

@@ -1,111 +1,64 @@
-import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
-import { getImageSize, isInterleaved, SIGNAL_ABORTED } from './utils/tiff-utils';
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tiff_utils_1 = require("./utils/tiff-utils");
 class TiffPixelSource {
-  constructor(indexer, dtype, tileSize, shape, labels, meta) {
-    _defineProperty(this, "dtype", void 0);
-
-    _defineProperty(this, "tileSize", void 0);
-
-    _defineProperty(this, "shape", void 0);
-
-    _defineProperty(this, "labels", void 0);
-
-    _defineProperty(this, "meta", void 0);
-
-    _defineProperty(this, "_indexer", void 0);
-
-    this._indexer = indexer;
-    this.dtype = dtype;
-    this.tileSize = tileSize;
-    this.shape = shape;
-    this.labels = labels;
-    this.meta = meta;
-  }
-
-  async getRaster({
-    selection,
-    signal
-  }) {
-    const image = await this._indexer(selection);
-    return this._readRasters(image, {
-      signal
-    });
-  }
-
-  async getTile({
-    x,
-    y,
-    selection,
-    signal
-  }) {
-    const {
-      height,
-      width
-    } = this._getTileExtent(x, y);
-
-    const x0 = x * this.tileSize;
-    const y0 = y * this.tileSize;
-    const window = [x0, y0, x0 + width, y0 + height];
-    const image = await this._indexer(selection);
-    return this._readRasters(image, {
-      window,
-      width,
-      height,
-      signal
-    });
-  }
-
-  async _readRasters(image, props) {
-    var _props$signal;
-
-    const interleave = isInterleaved(this.shape);
-    const raster = await image.readRasters({
-      interleave,
-      ...props
-    });
-
-    if (props !== null && props !== void 0 && (_props$signal = props.signal) !== null && _props$signal !== void 0 && _props$signal.aborted) {
-      throw SIGNAL_ABORTED;
+    // eslint-disable-next-line max-params
+    constructor(indexer, dtype, tileSize, shape, labels, meta) {
+        this._indexer = indexer;
+        this.dtype = dtype;
+        this.tileSize = tileSize;
+        this.shape = shape;
+        this.labels = labels;
+        this.meta = meta;
     }
-
-    const data = interleave ? raster : raster[0];
-    return {
-      data,
-      width: raster.width,
-      height: raster.height
-    };
-  }
-
-  _getTileExtent(x, y) {
-    const {
-      height: zoomLevelHeight,
-      width: zoomLevelWidth
-    } = getImageSize(this);
-    let height = this.tileSize;
-    let width = this.tileSize;
-    const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);
-    const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);
-
-    if (x === maxXTileCoord) {
-      width = zoomLevelWidth % this.tileSize;
+    async getRaster({ selection, signal }) {
+        const image = await this._indexer(selection);
+        return this._readRasters(image, { signal });
     }
-
-    if (y === maxYTileCoord) {
-      height = zoomLevelHeight % this.tileSize;
+    async getTile({ x, y, selection, signal }) {
+        const { height, width } = this._getTileExtent(x, y);
+        const x0 = x * this.tileSize;
+        const y0 = y * this.tileSize;
+        const window = [x0, y0, x0 + width, y0 + height];
+        const image = await this._indexer(selection);
+        return this._readRasters(image, { window, width, height, signal });
+    }
+    async _readRasters(image, props) {
+        const interleave = (0, tiff_utils_1.isInterleaved)(this.shape);
+        const raster = await image.readRasters({ interleave, ...props });
+        if (props?.signal?.aborted) {
+            throw tiff_utils_1.SIGNAL_ABORTED;
+        }
+        /*
+         * geotiff.js returns objects with different structure
+         * depending on `interleave`. It's weird, but this seems to work.
+         */
+        const data = (interleave ? raster : raster[0]);
+        return {
+            data,
+            width: raster.width,
+            height: raster.height
+        };
+    }
+    /*
+     * Computes tile size given x, y coord.
+     */
+    _getTileExtent(x, y) {
+        const { height: zoomLevelHeight, width: zoomLevelWidth } = (0, tiff_utils_1.getImageSize)(this);
+        let height = this.tileSize;
+        let width = this.tileSize;
+        const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);
+        const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);
+        if (x === maxXTileCoord) {
+            width = zoomLevelWidth % this.tileSize;
+        }
+        if (y === maxYTileCoord) {
+            height = zoomLevelHeight % this.tileSize;
+        }
+        return { height, width };
+    }
+    onTileError(err) {
+        console.error(err); // eslint-disable-line no-console
     }
-
-    return {
-      height,
-      width
-    };
-  }
-
-  onTileError(err) {
-    console.error(err);
-  }
-
 }
-
-export default TiffPixelSource;
-//# sourceMappingURL=tiff-pixel-source.js.map
+exports.default = TiffPixelSource;

package/dist/lib/utils/Pool.d.ts

@@ -0,0 +1,29 @@
+/** eslint-disable */
+import type { FileDirectory } from 'geotiff';
+/**
+ * Pool for workers to decode chunks of the images.
+ * This is a line-for-line copy of GeoTIFFs old implementation: https://github.com/geotiffjs/geotiff.js/blob/v1.0.0-beta.6/src/pool.js
+ */
+export default class Pool {
+    workers: Worker[];
+    idleWorkers: Worker[];
+    waitQueue: any[];
+    decoder: null;
+    /**
+     * @constructor
+     * @param {Number} size The size of the pool. Defaults to the number of CPUs
+     *                      available. When this parameter is `null` or 0, then the
+     *                      decoding will be done in the main thread.
+     */
+    constructor(size?: number);
+    /**
+     * Decode the given block of bytes with the set compression method.
+     * @param {ArrayBuffer} buffer the array buffer of bytes to decode.
+     * @returns {Promise.<ArrayBuffer>} the decoded result as a `Promise`
+     */
+    decode(fileDirectory: FileDirectory, buffer: ArrayBuffer): Promise<unknown>;
+    waitForWorker(): Promise<Worker>;
+    finishTask(currentWorker: Worker): Promise<void>;
+    destroy(): void;
+}
+//# sourceMappingURL=Pool.d.ts.map

package/dist/lib/utils/Pool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Pool.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/Pool.ts"],"names":[],"mappings":"AAAA,qBAAqB;AACrB,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,SAAS,CAAC;AAU3C;;;GAGG;AACH,MAAM,CAAC,OAAO,OAAO,IAAI;IACvB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,SAAS,EAAE,GAAG,EAAE,CAAC;IACjB,OAAO,EAAE,IAAI,CAAC;IAEd;;;;;OAKG;gBACS,IAAI,SAAkB;IAclC;;;;OAIG;IACG,MAAM,CAAC,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW;IAmBxD,aAAa;IAcb,UAAU,CAAC,aAAa,EAAE,MAAM;IAStC,OAAO;CAMR"}