@loaders.gl/geotiff 3.1.0-alpha.4 → 3.1.0-beta.3

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDims = exports.getLabels = void 0;
+function getLabels(dimOrder) {
+    return dimOrder.toLowerCase().split('').reverse();
+}
+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 (name) => {
+        const index = lookup.get(name);
+        if (index === undefined) {
+            throw Error('Invalid dimension.');
+        }
+        return index;
+    };
+}
+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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tiff_utils_1 = require("./utils/tiff-utils");
+class TiffPixelSource {
+    // 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;
+    }
+    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) {
+        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
+    }
+}
+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"}

package/dist/lib/utils/Pool.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// import Worker from 'web-worker:./decoder.worker.ts';
+// https://developer.mozilla.org/en-US/docs/Web/API/NavigatorConcurrentHardware/hardwareConcurrency
+// We need to give a different way of getting this for safari, so 4 is probably a safe bet
+// for parallel processing in the meantime.  More can't really hurt since they'll just block
+// each other and not the UI thread, which is the real benefit.
+const defaultPoolSize = globalThis?.navigator?.hardwareConcurrency ?? 4;
+/**
+ * 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
+ */
+class Pool {
+    /**
+     * @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 = defaultPoolSize) {
+        this.workers = [];
+        this.idleWorkers = [];
+        this.waitQueue = [];
+        this.decoder = null;
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < size; ++i) {
+            const w = new Worker('./decoder.worker');
+            this.workers.push(w);
+            this.idleWorkers.push(w);
+        }
+    }
+    /**
+     * 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`
+     */
+    async decode(fileDirectory, buffer) {
+        const currentWorker = await this.waitForWorker();
+        return new Promise((resolve, reject) => {
+            currentWorker.onmessage = (event) => {
+                // this.workers.push(currentWorker);
+                // eslint-disable-next-line
+                this.finishTask(currentWorker);
+                resolve(event.data[0]);
+            };
+            currentWorker.onerror = (error) => {
+                // this.workers.push(currentWorker);
+                // eslint-disable-next-line
+                this.finishTask(currentWorker);
+                reject(error);
+            };
+            currentWorker.postMessage(['decode', fileDirectory, buffer], [buffer]);
+        });
+    }
+    async waitForWorker() {
+        const idleWorker = this.idleWorkers.pop();
+        if (idleWorker) {
+            return idleWorker;
+        }
+        const waiter = {};
+        const promise = new Promise((resolve) => {
+            waiter.resolve = resolve;
+        });
+        this.waitQueue.push(waiter);
+        return promise;
+    }
+    async finishTask(currentWorker) {
+        const waiter = this.waitQueue.pop();
+        if (waiter) {
+            waiter.resolve(currentWorker);
+        }
+        else {
+            this.idleWorkers.push(currentWorker);
+        }
+    }
+    destroy() {
+        // eslint-disable-next-line no-plusplus
+        for (let i = 0; i < this.workers.length; ++i) {
+            this.workers[i].terminate();
+        }
+    }
+}
+exports.default = Pool;

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

@@ -0,0 +1,6 @@
+import type { GeoTIFF } from 'geotiff';
+import type Pool from './Pool';
+export declare function checkProxies(tiff: GeoTIFF): void;
+export declare function createOffsetsProxy(tiff: GeoTIFF, offsets: number[]): GeoTIFF;
+export declare function createPoolProxy(tiff: GeoTIFF, pool: Pool): GeoTIFF;
+//# sourceMappingURL=proxies.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"proxies.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/proxies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAC,MAAM,SAAS,CAAC;AACrC,OAAO,KAAK,IAAI,MAAM,QAAQ,CAAC;AAU/B,wBAAgB,YAAY,CAAC,IAAI,EAAE,OAAO,QAQzC;AAqBD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,WAsBlE;AAUD,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,WAmBxD"}

package/dist/lib/utils/proxies.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPoolProxy = exports.createOffsetsProxy = exports.checkProxies = void 0;
+const VIV_PROXY_KEY = '__viv';
+const OFFSETS_PROXY_KEY = `${VIV_PROXY_KEY}-offsets`;
+const POOL_PROXY_KEY = `${VIV_PROXY_KEY}-decoder-pool`;
+/*
+ * Inspect if the GeoTIFF source is wrapped in our proxies,
+ * and warn if missing.
+ */
+function checkProxies(tiff) {
+    if (!isProxy(tiff, OFFSETS_PROXY_KEY)) {
+        console.warn('GeoTIFF source is missing offsets proxy.'); // eslint-disable-line no-console
+    }
+    if (!isProxy(tiff, POOL_PROXY_KEY)) {
+        console.warn('GeoTIFF source is missing decoder-pool proxy.'); // eslint-disable-line no-console
+    }
+}
+exports.checkProxies = checkProxies;
+/*
+ * > isProxy(tiff, POOL_PROXY_KEY) === true; // false
+ * > tiff = createPoolProxy(tiff, new Pool());
+ * > isProxy(tiff, POOL_PROXY_KEY) === true; // true
+ */
+function isProxy(tiff, proxyFlag) {
+    return tiff[proxyFlag];
+}
+/*
+ * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy
+ * handler intercepts calls to `tiff.getImage` and uses our custom
+ * pre-computed offsets to pre-fetch the correct file directory.
+ *
+ * This is a bit of a hack. Internally GeoTIFF inspects `this.ifdRequests`
+ * to see which fileDirectories need to be traversed. By adding the
+ * ifdRequest for an 'index' manually, GeoTIFF will await that request
+ * rather than traversing the file system remotely.
+ */
+function createOffsetsProxy(tiff, offsets) {
+    const get = (target, key) => {
+        // Intercept `tiff.getImage`
+        if (key === 'getImage') {
+            return (index) => {
+                // Manually add ifdRequest to tiff if missing and we have an offset.
+                if (!(index in target.ifdRequests) && index in offsets) {
+                    const offset = offsets[index];
+                    target.ifdRequests[index] = target.parseFileDirectoryAt(offset);
+                }
+                return target.getImage(index);
+            };
+        }
+        // tiff['__viv-offsets'] === true
+        if (key === OFFSETS_PROXY_KEY) {
+            return true;
+        }
+        return Reflect.get(target, key);
+    };
+    return new Proxy(tiff, { get });
+}
+exports.createOffsetsProxy = createOffsetsProxy;
+/*
+ * Creates an ES6 Proxy that wraps a GeoTIFF object. The proxy
+ * handler intercepts calls to `tiff.readRasters` and injects
+ * a pool argument to every call. This means our TiffPixelSource
+ * doesn't need to be aware of whether a decoder pool is in use.
+ *
+ * > tiff.readRasters({ window }) -> tiff.readRasters({ window, pool });
+ */
+function createPoolProxy(tiff, pool) {
+    const get = (target, key) => {
+        // Intercept calls to `image.readRasters`
+        if (key === 'readRasters') {
+            return (options) => {
+                // Inject `pool` argument with other raster options.
+                // @ts-ignore
+                return target.readRasters({ ...options, pool });
+            };
+        }
+        // tiff['__viv-decoder-pool'] === true
+        if (key === POOL_PROXY_KEY) {
+            return true;
+        }
+        return Reflect.get(target, key);
+    };
+    return new Proxy(tiff, { get });
+}
+exports.createPoolProxy = createPoolProxy;

package/dist/lib/utils/tiff-utils.d.ts

@@ -0,0 +1,10 @@
+import type { PixelSource } from '../../types';
+export declare function ensureArray<T>(x: T | T[]): T[];
+export declare function intToRgba(int: number): [number, number, number, number];
+export declare function isInterleaved(shape: number[]): boolean;
+export declare function getImageSize<T extends string[]>(source: PixelSource<T>): {
+    height: number;
+    width: number;
+};
+export declare const SIGNAL_ABORTED = "__vivSignalAborted";
+//# sourceMappingURL=tiff-utils.d.ts.map

package/dist/lib/utils/tiff-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tiff-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/tiff-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,aAAa,CAAC;AAE7C,wBAAgB,WAAW,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,GAAG,CAAC,EAAE,OAExC;AASD,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,oCAapC;AAOD,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,EAAE,WAG5C;AAED,wBAAgB,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,EAAE,MAAM,EAAE,WAAW,CAAC,CAAC,CAAC;;;EAItE;AAED,eAAO,MAAM,cAAc,uBAAuB,CAAC"}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIGNAL_ABORTED = exports.getImageSize = exports.isInterleaved = exports.intToRgba = exports.ensureArray = void 0;
+function ensureArray(x) {
+    return Array.isArray(x) ? x : [x];
+}
+exports.ensureArray = ensureArray;
+/*
+ * Converts 32-bit integer color representation to RGBA tuple.
+ * Used to serialize colors from OME-XML metadata.
+ *
+ * > console.log(intToRgba(100100));
+ * > // [0, 1, 135, 4]
+ */
+function intToRgba(int) {
+    if (!Number.isInteger(int)) {
+        throw Error('Not an integer.');
+    }
+    // Write number to int32 representation (4 bytes).
+    const buffer = new ArrayBuffer(4);
+    const view = new DataView(buffer);
+    view.setInt32(0, int, false); // offset === 0, littleEndian === false
+    // Take u8 view and extract number for each byte (1 byte for R/G/B/A).
+    const bytes = new Uint8Array(buffer);
+    return Array.from(bytes);
+}
+exports.intToRgba = intToRgba;
+/*
+ * Helper method to determine whether pixel data is interleaved or not.
+ * > isInterleaved([1, 24, 24]) === false;
+ * > isInterleaved([1, 24, 24, 3]) === true;
+ */
+function isInterleaved(shape) {
+    const lastDimSize = shape[shape.length - 1];
+    return lastDimSize === 3 || lastDimSize === 4;
+}
+exports.isInterleaved = isInterleaved;
+function getImageSize(source) {
+    const interleaved = isInterleaved(source.shape);
+    const [height, width] = source.shape.slice(interleaved ? -3 : -2);
+    return { height, width };
+}
+exports.getImageSize = getImageSize;
+exports.SIGNAL_ABORTED = '__vivSignalAborted';

package/dist/types.d.ts

@@ -0,0 +1,47 @@
+import { DTYPE_LOOKUP } from './lib/ome/ome-utils';
+export declare type Dtype = typeof DTYPE_LOOKUP[keyof typeof DTYPE_LOOKUP];
+export declare type TypedArray = InstanceType<typeof globalThis[`${Dtype}Array`]>;
+export interface PixelData {
+    data: TypedArray;
+    width: number;
+    height: number;
+}
+export declare type PixelSourceSelection<S extends string[]> = {
+    [K in S[number]]: number;
+};
+export interface RasterSelection<S extends string[]> {
+    selection: PixelSourceSelection<S>;
+    signal?: AbortSignal;
+}
+export interface TileSelection<S extends string[]> {
+    x: number;
+    y: number;
+    selection: PixelSourceSelection<S>;
+    signal?: AbortSignal;
+}
+interface PhysicalSize {
+    size: number;
+    unit: string;
+}
+export interface PixelSourceMeta {
+    physicalSizes?: Record<string, PhysicalSize>;
+    photometricInterpretation?: number;
+}
+export declare type Labels<S extends string[]> = [...S, 'y', 'x'] | [...S, 'y', 'x', '_c'];
+/**
+ * Interface to load tiles from a data source
+ */
+export interface PixelSource<S extends string[]> {
+    /** Loads a 2D plane */
+    getRaster(sel: RasterSelection<S>): Promise<PixelData>;
+    /** Loads a tile */
+    getTile(sel: TileSelection<S>): Promise<PixelData>;
+    onTileError(err: Error): void;
+    shape: number[];
+    dtype: Dtype;
+    labels: Labels<S>;
+    tileSize: number;
+    meta?: PixelSourceMeta;
+}
+export {};
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,YAAY,EAAC,MAAM,qBAAqB,CAAC;AAEjD,oBAAY,KAAK,GAAG,OAAO,YAAY,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC;AACnE,oBAAY,UAAU,GAAG,YAAY,CAAC,OAAO,UAAU,CAAC,GAAG,KAAK,OAAO,CAAC,CAAC,CAAC;AAE1E,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,UAAU,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,oBAAY,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI;KACpD,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,GAAG,MAAM;CACzB,CAAC;AAEF,MAAM,WAAW,eAAe,CAAC,CAAC,SAAS,MAAM,EAAE;IACjD,SAAS,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC;IACnC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,MAAM,WAAW,aAAa,CAAC,CAAC,SAAS,MAAM,EAAE;IAC/C,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;IACV,SAAS,EAAE,oBAAoB,CAAC,CAAC,CAAC,CAAC;IACnC,MAAM,CAAC,EAAE,WAAW,CAAC;CACtB;AAED,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,eAAe;IAC9B,aAAa,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC;IAC7C,yBAAyB,CAAC,EAAE,MAAM,CAAC;CACpC;AAED,oBAAY,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,IAAI,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC;AAEnF;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,CAAC,SAAS,MAAM,EAAE;IAC7C,uBAAuB;IACvB,SAAS,CAAC,GAAG,EAAE,eAAe,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACvD,mBAAmB;IACnB,OAAO,CAAC,GAAG,EAAE,aAAa,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,SAAS,CAAC,CAAC;IACnD,WAAW,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB,KAAK,EAAE,KAAK,CAAC;IACb,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;IACjB,IAAI,CAAC,EAAE,eAAe,CAAC;CACxB"}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/typings/geotiff.d.ts

@@ -0,0 +1,60 @@
+declare type TypedArray = import('../types').TypedArray;
+declare module 'geotiff' {
+    function fromUrl(url: string, headers?: Record<string, unknown>): Promise<GeoTIFF>;
+    function fromBlob(blob: Blob): Promise<GeoTIFF>;
+    function fromFile(path: string): Promise<GeoTIFF>;
+    class GeoTIFF {
+        readRasters(options?: RasterOptions): Promise<TypedArray>;
+        getImage(index: number): Promise<GeoTIFFImage>;
+        parseFileDirectoryAt(offset: number): Promise<ImageFileDirectory>;
+        ifdRequests: {
+            [key: number]: Promise<ImageFileDirectory>;
+        };
+        dataView: DataView;
+        littleEndian: boolean;
+        cache: any;
+        source: any;
+    }
+    interface Pool {
+        decode(fileDirectory: FileDirectory, buffer: ArrayBuffer): Promise<ArrayBuffer>;
+    }
+    interface RasterOptions {
+        window?: number[];
+        bbox?: number[];
+        samples?: number[];
+        interleave?: boolean;
+        pool?: Pool;
+        width?: number;
+        height?: number;
+        resampleMethod?: string;
+        enableAlpha?: boolean;
+        signal?: AbortSignal;
+    }
+    type RasterData = (TypedArray | TypedArray[]) & {
+        width: number;
+        height: number;
+    };
+    class GeoTIFFImage {
+        constructor(fileDirectory: FileDirectory, geoKeyDirectory: any, dataView: DataView, littleEndian: boolean, cache: any, source: any);
+        fileDirectory: FileDirectory;
+        getBoundingBox(): number[];
+        getFileDirectory(): FileDirectory;
+        getBytesPerPixel(): number;
+        getHeight(): number;
+        getSamplesPerPixel(): number;
+        getTileHeight(): number;
+        getTileWidth(): number;
+        getWidth(): number;
+        readRasters(options?: RasterOptions): Promise<RasterData>;
+    }
+    interface FileDirectory {
+        ImageDescription: string;
+        SubIFDs?: number[];
+        PhotometricInterpretation?: number;
+    }
+    interface ImageFileDirectory {
+        fileDirectory: FileDirectory;
+        geoKeyDirectory: any;
+    }
+}
+//# sourceMappingURL=geotiff.d.ts.map

package/dist/typings/geotiff.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"geotiff.d.ts","sourceRoot":"","sources":["../../src/typings/geotiff.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,UAAU,GAAG,OAAO,UAAU,EAAE,UAAU,CAAC;AAExD,OAAO,QAAQ,SAAS,CAAC;IACvB,SAAS,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACnF,SAAS,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAChD,SAAS,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAElD,MAAM,OAAO;QACX,WAAW,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC;QACzD,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;QAC9C,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC;QACjE,WAAW,EAAE;YAAC,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAAA;SAAC,CAAC;QAC1D,QAAQ,EAAE,QAAQ,CAAC;QACnB,YAAY,EAAE,OAAO,CAAC;QACtB,KAAK,EAAE,GAAG,CAAC;QACX,MAAM,EAAE,GAAG,CAAC;KACb;IAED,UAAU,IAAI;QACZ,MAAM,CAAC,aAAa,EAAE,aAAa,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;KACjF;IAED,UAAU,aAAa;QACrB,MAAM,CAAC,EAAE,MAAM,EAAE,CAAC;QAClB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;QAChB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,UAAU,CAAC,EAAE,OAAO,CAAC;QACrB,IAAI,CAAC,EAAE,IAAI,CAAC;QACZ,KAAK,CAAC,EAAE,MAAM,CAAC;QACf,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,cAAc,CAAC,EAAE,MAAM,CAAC;QACxB,WAAW,CAAC,EAAE,OAAO,CAAC;QACtB,MAAM,CAAC,EAAE,WAAW,CAAC;KACtB;IAED,KAAK,UAAU,GAAG,CAAC,UAAU,GAAG,UAAU,EAAE,CAAC,GAAG;QAC9C,KAAK,EAAE,MAAM,CAAC;QACd,MAAM,EAAE,MAAM,CAAC;KAChB,CAAC;IACF,MAAM,YAAY;oBAEd,aAAa,EAAE,aAAa,EAC5B,eAAe,EAAE,GAAG,EACpB,QAAQ,EAAE,QAAQ,EAClB,YAAY,EAAE,OAAO,EACrB,KAAK,EAAE,GAAG,EACV,MAAM,EAAE,GAAG;QAEb,aAAa,EAAE,aAAa,CAAC;QAC7B,cAAc,IAAI,MAAM,EAAE;QAC1B,gBAAgB,IAAI,aAAa;QACjC,gBAAgB,IAAI,MAAM;QAC1B,SAAS,IAAI,MAAM;QACnB,kBAAkB,IAAI,MAAM;QAC5B,aAAa,IAAI,MAAM;QACvB,YAAY,IAAI,MAAM;QACtB,QAAQ,IAAI,MAAM;QAClB,WAAW,CAAC,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,UAAU,CAAC;KAC1D;IAED,UAAU,aAAa;QACrB,gBAAgB,EAAE,MAAM,CAAC;QACzB,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;QACnB,yBAAyB,CAAC,EAAE,MAAM,CAAC;KACpC;IAED,UAAU,kBAAkB;QAC1B,aAAa,EAAE,aAAa,CAAC;QAC7B,eAAe,EAAE,GAAG,CAAC;KACtB;CACF"}

package/dist/typings/geotiff.js

@@ -0,0 +1 @@
+"use strict";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/geotiff",
-  "version": "3.1.0-alpha.4",
+  "version": "3.1.0-beta.3",
   "description": "Framework-independent loaders for tiff and geotiff",
   "license": "MIT",
   "publishConfig": {
@@ -18,7 +18,7 @@
     "tiff",
     "geotiff"
   ],
-  "types": "src/index.ts",
+  "types": "dist/index.d.ts",
   "main": "dist/es5/index.js",
   "module": "dist/esm/index.js",
   "sideEffects": false,
@@ -29,8 +29,8 @@
     "README.md"
   ],
   "scripts": {
-    "pre-build": "npm run build-bundle",
-    "build-bundle": "webpack --display=minimal --config ../../scripts/webpack/bundle.js"
+    "pre-build": "# npm run build-bundle",
+    "build-bundle": "esbuild src/bundle.ts --outfile=dist/dist.min.js --bundle --minify --sourcemap --external:{fs,http,https}"
   },
   "dependencies-disabled": {
     "geotiff": "ilan-gold/geotiff.js#ilan-gold/viv_094"
@@ -39,5 +39,5 @@
     "fast-xml-parser": "^3.16.0",
     "geotiff": "^1.0.4"
   },
-  "gitHead": "e309784af37ef9f3640c7733c7851124c72e1fa3"
+  "gitHead": "3537c382b3ea4e092b24b6f94c3edee72076039c"
 }