@loaders.gl/geotiff 4.2.0-alpha.4 → 4.2.0-alpha.5

package/dist/geotiff-loader.js

@@ -1,59 +1,78 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { fromArrayBuffer } from 'geotiff';
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
 const VERSION = typeof "4.2.0-alpha.4" !== 'undefined' ? "4.2.0-alpha.4" : 'latest';
+/** GeoTIFF loader */
 export const GeoTIFFLoader = {
-  id: 'geotiff',
-  name: 'GeoTIFF',
-  module: 'geotiff',
-  version: VERSION,
-  options: {
-    enableAlpha: true
-  },
-  mimeTypes: ['image/tiff', 'image/geotiff'],
-  extensions: ['geotiff', 'tiff', 'geotif', 'tif'],
-  parse: parseGeoTIFF
+    id: 'geotiff',
+    name: 'GeoTIFF',
+    module: 'geotiff',
+    version: VERSION,
+    options: {
+        enableAlpha: true
+    },
+    mimeTypes: ['image/tiff', 'image/geotiff'],
+    extensions: ['geotiff', 'tiff', 'geotif', 'tif'],
+    parse: parseGeoTIFF
 };
 export function isTiff(arrayBuffer) {
-  const dataView = new DataView(arrayBuffer);
-  const endianness = dataView.getUint16(0);
-  let littleEndian;
-  switch (endianness) {
-    case 0x4949:
-      littleEndian = true;
-      break;
-    case 0x4d4d:
-      littleEndian = false;
-      break;
-    default:
-      return false;
-  }
-  if (dataView.getUint16(2, littleEndian) !== 42) {
-    return false;
-  }
-  return true;
+    const dataView = new DataView(arrayBuffer);
+    // Byte offset
+    const endianness = dataView.getUint16(0);
+    let littleEndian;
+    switch (endianness) {
+        case 0x4949:
+            littleEndian = true;
+            break;
+        case 0x4d4d:
+            littleEndian = false;
+            break;
+        default:
+            return false;
+        // throw new Error(`invalid byte order: 0x${endianness.toString(16)}`);
+    }
+    // Magic number
+    if (dataView.getUint16(2, littleEndian) !== 42) {
+        return false;
+    }
+    return true;
 }
+/**
+ * Loads a GeoTIFF file containing a RGB image.
+ */
 async function parseGeoTIFF(data, options) {
-  var _options$geotiff;
-  const tiff = await fromArrayBuffer(data);
-  const image = await tiff.getImage();
-  const rgbData = await image.readRGB({
-    enableAlpha: options === null || options === void 0 ? void 0 : (_options$geotiff = options.geotiff) === null || _options$geotiff === void 0 ? void 0 : _options$geotiff.enableAlpha
-  });
-  const width = image.getWidth();
-  const height = image.getHeight();
-  const imageData = new Uint8ClampedArray(rgbData);
-  const bounds = image.getBoundingBox();
-  const metadata = image.getGeoKeys();
-  let crs;
-  if (metadata !== null && metadata !== void 0 && metadata.ProjectedCSTypeGeoKey) {
-    crs = `EPSG:${metadata.ProjectedCSTypeGeoKey}`;
-  }
-  return {
-    crs,
-    bounds,
-    width,
-    height,
-    data: imageData,
-    metadata
-  };
+    // Load using Geotiff.js
+    const tiff = await fromArrayBuffer(data);
+    // Assumes we only have one image inside TIFF
+    const image = await tiff.getImage();
+    // Read image and size
+    // TODO: Add support for worker pools here.
+    // TODO: Add support for more image formats.
+    const rgbData = await image.readRGB({
+        enableAlpha: options?.geotiff?.enableAlpha
+    });
+    const width = image.getWidth();
+    const height = image.getHeight();
+    // Create a new ImageData object
+    const imageData = new Uint8ClampedArray(rgbData);
+    // Get geo data
+    const bounds = image.getBoundingBox();
+    const metadata = image.getGeoKeys();
+    // ProjectedCSTypeGeoKey is the only key we support for now, we assume it is an EPSG code
+    let crs;
+    if (metadata?.ProjectedCSTypeGeoKey) {
+        crs = `EPSG:${metadata.ProjectedCSTypeGeoKey}`;
+    }
+    // Return GeoReferenced image data
+    return {
+        crs,
+        bounds,
+        width,
+        height,
+        data: imageData,
+        metadata
+    };
 }
-//# sourceMappingURL=geotiff-loader.js.map

package/dist/index.cjs

@@ -17,18 +17,18 @@ var __copyProps = (to, from, except, desc) => {
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
+// dist/index.js
+var dist_exports = {};
+__export(dist_exports, {
   GeoTIFFLoader: () => GeoTIFFLoader,
   TiffPixelSource: () => TiffPixelSource,
   loadGeoTiff: () => loadGeoTiff
 });
-module.exports = __toCommonJS(src_exports);
+module.exports = __toCommonJS(dist_exports);
 
-// src/geotiff-loader.ts
+// dist/geotiff-loader.js
 var import_geotiff = require("geotiff");
-var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+var VERSION = true ? "4.2.0-alpha.4" : "latest";
 var GeoTIFFLoader = {
   id: "geotiff",
   name: "GeoTIFF",
@@ -67,10 +67,10 @@ async function parseGeoTIFF(data, options) {
   };
 }
 
-// src/lib/load-geotiff.ts
+// dist/lib/load-geotiff.js
 var import_geotiff2 = require("geotiff");
 
-// src/lib/utils/tiff-utils.ts
+// dist/lib/utils/tiff-utils.js
 function ensureArray(x) {
   return Array.isArray(x) ? x : [x];
 }
@@ -95,7 +95,7 @@ function getImageSize(source) {
 }
 var SIGNAL_ABORTED = "__vivSignalAborted";
 
-// src/lib/tiff-pixel-source.ts
+// dist/lib/tiff-pixel-source.js
 var TiffPixelSource = class {
   // eslint-disable-next-line max-params
   constructor(indexer, dtype, tileSize, shape, labels, meta) {
@@ -154,7 +154,7 @@ var TiffPixelSource = class {
   }
 };
 
-// src/lib/ome/ome-indexers.ts
+// dist/lib/ome/ome-indexers.js
 function getOmeLegacyIndexer(tiff, rootMeta) {
   const imgMeta = rootMeta[0];
   const { SizeT, SizeC, SizeZ } = imgMeta.Pixels;
@@ -223,7 +223,7 @@ function getOmeIFDIndexer(imgMeta) {
   }
 }
 
-// src/lib/ome/utils.ts
+// dist/lib/ome/utils.js
 function getLabels(dimOrder) {
   return dimOrder.toLowerCase().split("").reverse();
 }
@@ -241,7 +241,7 @@ function getDims(labels) {
   };
 }
 
-// src/lib/ome/ome-utils.ts
+// dist/lib/ome/ome-utils.js
 var DTYPE_LOOKUP = {
   uint8: "Uint8",
   uint16: "Uint16",
@@ -295,7 +295,7 @@ function getOmePixelSourceMeta({ Pixels }) {
   return { labels, getShape, dtype };
 }
 
-// src/lib/ome/omexml.ts
+// dist/lib/ome/omexml.js
 var import_fast_xml_parser = require("fast-xml-parser");
 var xmlParser = new import_fast_xml_parser.XMLParser({
   // Nests attributes withtout prefix under 'attr' key for each node
@@ -352,14 +352,10 @@ function fromString(str) {
   });
 }
 
-// src/lib/ome/load-ome-tiff.ts
+// dist/lib/ome/load-ome-tiff.js
 var isOmeTiff = (img) => img.fileDirectory.ImageDescription.includes("<OME");
 async function loadOmeTiff(tiff, firstImage) {
-  const {
-    ImageDescription,
-    SubIFDs,
-    PhotometricInterpretation: photometricInterpretation
-  } = firstImage.fileDirectory;
+  const { ImageDescription, SubIFDs, PhotometricInterpretation: photometricInterpretation } = firstImage.fileDirectory;
   const omexml = fromString(ImageDescription);
   let levels;
   let pyramidIndexer;
@@ -383,7 +379,7 @@ async function loadOmeTiff(tiff, firstImage) {
   return { data, metadata: imgMeta };
 }
 
-// src/lib/load-geotiff.ts
+// dist/lib/load-geotiff.js
 async function loadGeoTiff(source, opts = {}) {
   const { headers, offsets } = opts;
   let tiff;
@@ -402,3 +398,4 @@ async function loadGeoTiff(source, opts = {}) {
   }
   throw new Error("GeoTIFF not recognized.");
 }
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["index.js", "geotiff-loader.js", "lib/load-geotiff.js", "lib/utils/tiff-utils.js", "lib/tiff-pixel-source.js", "lib/ome/ome-indexers.js", "lib/ome/utils.js", "lib/ome/ome-utils.js", "lib/ome/omexml.js", "lib/ome/load-ome-tiff.js"],
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport { GeoTIFFLoader } from \"./geotiff-loader.js\";\nexport { loadGeoTiff } from \"./lib/load-geotiff.js\";\nexport { TiffPixelSource } from \"./lib/tiff-pixel-source.js\";\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { fromArrayBuffer } from 'geotiff';\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof \"4.2.0-alpha.4\" !== 'undefined' ? \"4.2.0-alpha.4\" : 'latest';\n/** GeoTIFF loader */\nexport const GeoTIFFLoader = {\n    id: 'geotiff',\n    name: 'GeoTIFF',\n    module: 'geotiff',\n    version: VERSION,\n    options: {\n        enableAlpha: true\n    },\n    mimeTypes: ['image/tiff', 'image/geotiff'],\n    extensions: ['geotiff', 'tiff', 'geotif', 'tif'],\n    parse: parseGeoTIFF\n};\nexport function isTiff(arrayBuffer) {\n    const dataView = new DataView(arrayBuffer);\n    // Byte offset\n    const endianness = dataView.getUint16(0);\n    let littleEndian;\n    switch (endianness) {\n        case 0x4949:\n            littleEndian = true;\n            break;\n        case 0x4d4d:\n            littleEndian = false;\n            break;\n        default:\n            return false;\n        // throw new Error(`invalid byte order: 0x${endianness.toString(16)}`);\n    }\n    // Magic number\n    if (dataView.getUint16(2, littleEndian) !== 42) {\n        return false;\n    }\n    return true;\n}\n/**\n * Loads a GeoTIFF file containing a RGB image.\n */\nasync function parseGeoTIFF(data, options) {\n    // Load using Geotiff.js\n    const tiff = await fromArrayBuffer(data);\n    // Assumes we only have one image inside TIFF\n    const image = await tiff.getImage();\n    // Read image and size\n    // TODO: Add support for worker pools here.\n    // TODO: Add support for more image formats.\n    const rgbData = await image.readRGB({\n        enableAlpha: options?.geotiff?.enableAlpha\n    });\n    const width = image.getWidth();\n    const height = image.getHeight();\n    // Create a new ImageData object\n    const imageData = new Uint8ClampedArray(rgbData);\n    // Get geo data\n    const bounds = image.getBoundingBox();\n    const metadata = image.getGeoKeys();\n    // ProjectedCSTypeGeoKey is the only key we support for now, we assume it is an EPSG code\n    let crs;\n    if (metadata?.ProjectedCSTypeGeoKey) {\n        crs = `EPSG:${metadata.ProjectedCSTypeGeoKey}`;\n    }\n    // Return GeoReferenced image data\n    return {\n        crs,\n        bounds,\n        width,\n        height,\n        data: imageData,\n        metadata\n    };\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { fromUrl, fromBlob, GeoTIFF } from 'geotiff';\n// import {\n//   // createPoolProxy,\n//   createOffsetsProxy,\n//   checkProxies\n// } from './utils/proxies.ts.disabled';\n// import Pool from './lib/Pool';\nimport { loadOmeTiff, isOmeTiff } from \"./ome/load-ome-tiff.js\";\n/**\n * Opens an OME-TIFF via URL and returns data source and associated metadata for first image.\n *\n * @param source url string, File/Blob object, or GeoTIFF object\n * @param opts options for initializing a tiff pixel source.\n *  - `opts.headers` are passed to each underlying fetch request.\n *  - `opts.offsets` are a performance enhancment to index the remote tiff source using pre-computed byte-offsets.\n *  - `opts.pool` indicates whether a multi-threaded pool of image decoders should be used to decode tiles (default = true).\n * @return data source and associated OME-Zarr metadata.\n */\nexport async function loadGeoTiff(source, opts = {}) {\n    const { headers, offsets } = opts;\n    // Create tiff source\n    let tiff;\n    if (source instanceof GeoTIFF) {\n        tiff = source;\n    }\n    else if (typeof source === 'string') {\n        tiff = await fromUrl(source, headers);\n    }\n    else {\n        tiff = await fromBlob(source);\n    }\n    // if (pool) {\n    /*\n     * Creates a worker pool to decode tiff tiles. Wraps tiff\n     * in a Proxy that injects 'pool' into `tiff.readRasters`.\n     */\n    // tiff = createPoolProxy(tiff, new Pool());\n    // }\n    if (offsets) {\n        /*\n         * Performance enhancement. If offsets are provided, we\n         * create a proxy that intercepts calls to `tiff.getImage`\n         * and injects the pre-computed offsets.\n         */\n        // tiff = createOffsetsProxy(tiff, offsets);\n    }\n    /*\n     * Inspect tiff source for our performance enhancing proxies.\n     * Prints warnings to console if `offsets` or `pool` are missing.\n     */\n    // checkProxies(tiff);\n    const firstImage = await tiff.getImage(0);\n    if (isOmeTiff(firstImage)) {\n        return loadOmeTiff(tiff, firstImage);\n    }\n    throw new Error('GeoTIFF not recognized.');\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport function ensureArray(x) {\n    return Array.isArray(x) ? x : [x];\n}\n/*\n * Converts 32-bit integer color representation to RGBA tuple.\n * Used to serialize colors from OME-XML metadata.\n *\n * > console.log(intToRgba(100100));\n * > // [0, 1, 135, 4]\n */\nexport function intToRgba(int) {\n    if (!Number.isInteger(int)) {\n        throw Error('Not an integer.');\n    }\n    // Write number to int32 representation (4 bytes).\n    const buffer = new ArrayBuffer(4);\n    const view = new DataView(buffer);\n    view.setInt32(0, int, false); // offset === 0, littleEndian === false\n    // Take u8 view and extract number for each byte (1 byte for R/G/B/A).\n    const bytes = new Uint8Array(buffer);\n    return Array.from(bytes);\n}\n/*\n * Helper method to determine whether pixel data is interleaved or not.\n * > isInterleaved([1, 24, 24]) === false;\n * > isInterleaved([1, 24, 24, 3]) === true;\n */\nexport function isInterleaved(shape) {\n    const lastDimSize = shape[shape.length - 1];\n    return lastDimSize === 3 || lastDimSize === 4;\n}\nexport function getImageSize(source) {\n    const interleaved = isInterleaved(source.shape);\n    const [height, width] = source.shape.slice(interleaved ? -3 : -2);\n    return { height, width };\n}\nexport const SIGNAL_ABORTED = '__vivSignalAborted';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { getImageSize, isInterleaved, SIGNAL_ABORTED } from \"./utils/tiff-utils.js\";\nexport class TiffPixelSource {\n    // eslint-disable-next-line max-params\n    constructor(indexer, dtype, tileSize, shape, labels, meta) {\n        this._indexer = indexer;\n        this.dtype = dtype;\n        this.tileSize = tileSize;\n        this.shape = shape;\n        this.labels = labels;\n        this.meta = meta;\n    }\n    async getRaster({ selection, signal }) {\n        const image = await this._indexer(selection);\n        return this._readRasters(image, { signal });\n    }\n    async getTile({ x, y, selection, signal }) {\n        const { height, width } = this._getTileExtent(x, y);\n        const x0 = x * this.tileSize;\n        const y0 = y * this.tileSize;\n        const window = [x0, y0, x0 + width, y0 + height];\n        const image = await this._indexer(selection);\n        return this._readRasters(image, { window, width, height, signal });\n    }\n    async _readRasters(image, props) {\n        const interleave = isInterleaved(this.shape);\n        const raster = await image.readRasters({ interleave, ...props });\n        if (props?.signal?.aborted) {\n            throw SIGNAL_ABORTED;\n        }\n        /*\n         * geotiff.js returns objects with different structure\n         * depending on `interleave`. It's weird, but this seems to work.\n         */\n        const data = (interleave ? raster : raster[0]);\n        return {\n            data,\n            width: raster.width,\n            height: raster.height\n        };\n    }\n    /*\n     * Computes tile size given x, y coord.\n     */\n    _getTileExtent(x, y) {\n        const { height: zoomLevelHeight, width: zoomLevelWidth } = getImageSize(this);\n        let height = this.tileSize;\n        let width = this.tileSize;\n        const maxXTileCoord = Math.floor(zoomLevelWidth / this.tileSize);\n        const maxYTileCoord = Math.floor(zoomLevelHeight / this.tileSize);\n        if (x === maxXTileCoord) {\n            width = zoomLevelWidth % this.tileSize;\n        }\n        if (y === maxYTileCoord) {\n            height = zoomLevelHeight % this.tileSize;\n        }\n        return { height, width };\n    }\n    onTileError(err) {\n        console.error(err); // eslint-disable-line no-console\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n/*\n * An \"indexer\" for a GeoTIFF-based source is a function that takes a\n * \"selection\" (e.g. { z, t, c }) and returns a Promise for the GeoTIFFImage\n * object corresponding to that selection.\n *\n * For OME-TIFF images, the \"selection\" object is the same regardless of\n * the format version. However, modern version of Bioformats have a different\n * memory layout for pyramidal resolutions. Thus, we have two different \"indexers\"\n * depending on which format version is detected.\n *\n * TODO: We currently only support indexing the first image in the OME-TIFF with\n * our indexers. There can be multiple images in an OME-TIFF, so supporting these\n * images will require extending these indexers or creating new methods.\n */\n/*\n * Returns an indexer for legacy Bioformats images. This assumes that\n * downsampled resolutions are stored sequentially in the OME-TIFF.\n */\nexport function getOmeLegacyIndexer(tiff, rootMeta) {\n    const imgMeta = rootMeta[0];\n    const { SizeT, SizeC, SizeZ } = imgMeta.Pixels;\n    const ifdIndexer = getOmeIFDIndexer(imgMeta);\n    return (sel, pyramidLevel) => {\n        // Get IFD index at base pyramid level\n        const index = ifdIndexer(sel);\n        // Get index of first image at pyramidal level\n        const pyramidIndex = pyramidLevel * SizeZ * SizeT * SizeC;\n        // Return image at IFD index for pyramidal level\n        return tiff.getImage(index + pyramidIndex);\n    };\n}\n/*\n * Returns an indexer for modern Bioforamts images that store multiscale\n * resolutions using SubIFDs.\n *\n * The ifdIndexer returns the 'index' to the base resolution for a\n * particular 'selection'. The SubIFDs to the downsampled resolutions\n * of the 'selection' are stored within the `baseImage.fileDirectory`.\n * We use the SubIFDs to get the IFD for the corresponding sub-resolution.\n *\n * NOTE: This function create a custom IFD cache rather than mutating\n * `GeoTIFF.ifdRequests` with a random offset. The IFDs are cached in\n * an ES6 Map that maps a string key that identifies the selection uniquely\n * to the corresponding IFD.\n */\nexport function getOmeSubIFDIndexer(tiff, rootMeta) {\n    const imgMeta = rootMeta[0];\n    const ifdIndexer = getOmeIFDIndexer(imgMeta);\n    const ifdCache = new Map();\n    return async (sel, pyramidLevel) => {\n        const index = ifdIndexer(sel);\n        const baseImage = await tiff.getImage(index);\n        // It's the highest resolution, no need to look up SubIFDs.\n        if (pyramidLevel === 0) {\n            return baseImage;\n        }\n        const { SubIFDs } = baseImage.fileDirectory;\n        if (!SubIFDs) {\n            throw Error('Indexing Error: OME-TIFF is missing SubIFDs.');\n        }\n        // Get IFD for the selection at the pyramidal level\n        const key = `${sel.t}-${sel.c}-${sel.z}-${pyramidLevel}`;\n        if (!ifdCache.has(key)) {\n            // Only create a new request if we don't have the key.\n            const subIfdOffset = SubIFDs[pyramidLevel - 1];\n            ifdCache.set(key, tiff.parseFileDirectoryAt(subIfdOffset));\n        }\n        const ifd = await ifdCache.get(key);\n        // Create a new image object manually from IFD\n        // https://github.com/geotiffjs/geotiff.js/blob/8ef472f41b51d18074aece2300b6a8ad91a21ae1/src/geotiff.js#L447-L453\n        return new baseImage.constructor(ifd.fileDirectory, ifd.geoKeyDirectory, \n        // @ts-expect-error\n        tiff.dataView, tiff.littleEndian, tiff.cache, tiff.source);\n    };\n}\n/*\n * Returns a function that computes the image index based on the dimension\n * order and dimension sizes.\n */\nfunction getOmeIFDIndexer(imgMeta) {\n    const { SizeC, SizeZ, SizeT, DimensionOrder } = imgMeta.Pixels;\n    switch (DimensionOrder) {\n        case 'XYZCT': {\n            return ({ t, c, z }) => t * SizeZ * SizeC + c * SizeZ + z;\n        }\n        case 'XYZTC': {\n            return ({ t, c, z }) => c * SizeZ * SizeT + t * SizeZ + z;\n        }\n        case 'XYCTZ': {\n            return ({ t, c, z }) => z * SizeC * SizeT + t * SizeC + c;\n        }\n        case 'XYCZT': {\n            return ({ t, c, z }) => t * SizeC * SizeZ + z * SizeC + c;\n        }\n        case 'XYTCZ': {\n            return ({ t, c, z }) => z * SizeT * SizeC + c * SizeT + t;\n        }\n        case 'XYTZC': {\n            return ({ t, c, z }) => c * SizeT * SizeZ + z * SizeT + t;\n        }\n        default: {\n            throw new Error(`Invalid OME-XML DimensionOrder, got ${DimensionOrder}.`);\n        }\n    }\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nexport function getLabels(dimOrder) {\n    return dimOrder.toLowerCase().split('').reverse();\n}\n/*\n * Creates an ES6 map of 'label' -> index\n * > const labels = ['a', 'b', 'c', 'd'];\n * > const dims = getDims(labels);\n * > dims('a') === 0;\n * > dims('b') === 1;\n * > dims('c') === 2;\n * > dims('hi!'); // throws\n */\nexport function getDims(labels) {\n    const lookup = new Map(labels.map((name, i) => [name, i]));\n    if (lookup.size !== labels.length) {\n        throw Error('Labels must be unique, found duplicated label.');\n    }\n    return (name) => {\n        const index = lookup.get(name);\n        if (index === undefined) {\n            throw Error('Invalid dimension.');\n        }\n        return index;\n    };\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { getDims, getLabels } from \"./utils.js\";\nexport const DTYPE_LOOKUP = {\n    uint8: 'Uint8',\n    uint16: 'Uint16',\n    uint32: 'Uint32',\n    float: 'Float32',\n    double: 'Float64',\n    int8: 'Int8',\n    int16: 'Int16',\n    int32: 'Int32'\n};\nexport function getOmePixelSourceMeta({ Pixels }) {\n    // e.g. 'XYZCT' -> ['t', 'c', 'z', 'y', 'x']\n    const labels = getLabels(Pixels.DimensionOrder);\n    // Compute \"shape\" of image\n    const dims = getDims(labels);\n    const shape = Array(labels.length).fill(0);\n    shape[dims('t')] = Pixels.SizeT;\n    shape[dims('c')] = Pixels.SizeC;\n    shape[dims('z')] = Pixels.SizeZ;\n    // Push extra dimension if data are interleaved.\n    if (Pixels.Interleaved) {\n        // @ts-ignore\n        labels.push('_c');\n        shape.push(3);\n    }\n    // Creates a new shape for different level of pyramid.\n    // Assumes factor-of-two downsampling.\n    const getShape = (level) => {\n        const s = [...shape];\n        s[dims('x')] = Pixels.SizeX >> level;\n        s[dims('y')] = Pixels.SizeY >> level;\n        return s;\n    };\n    if (!(Pixels.Type in DTYPE_LOOKUP)) {\n        throw Error(`Pixel type ${Pixels.Type} not supported.`);\n    }\n    const dtype = DTYPE_LOOKUP[Pixels.Type];\n    if (Pixels.PhysicalSizeX && Pixels.PhysicalSizeY) {\n        const physicalSizes = {\n            x: {\n                size: Pixels.PhysicalSizeX,\n                unit: Pixels.PhysicalSizeXUnit\n            },\n            y: {\n                size: Pixels.PhysicalSizeY,\n                unit: Pixels.PhysicalSizeYUnit\n            }\n        };\n        if (Pixels.PhysicalSizeZ) {\n            physicalSizes.z = {\n                size: Pixels.PhysicalSizeZ,\n                unit: Pixels.PhysicalSizeZUnit\n            };\n        }\n        return { labels, getShape, physicalSizes, dtype };\n    }\n    return { labels, getShape, dtype };\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { XMLParser } from 'fast-xml-parser';\nimport { ensureArray, intToRgba } from \"../utils/tiff-utils.js\";\n// WARNING: Changes to the parser options _will_ effect the types in types/omexml.d.ts.\nconst xmlParser = new XMLParser({\n    // Nests attributes withtout prefix under 'attr' key for each node\n    attributeNamePrefix: '',\n    attributesGroupName: 'attr',\n    // Parses numbers for both attributes and nodes\n    parseTagValue: true,\n    parseAttributeValue: true,\n    // Forces attributes to be parsed\n    ignoreAttributes: false\n});\nconst parse = (str) => xmlParser.parse(str);\nexport function fromString(str) {\n    const res = parse(str);\n    if (!res.OME) {\n        throw Error('Failed to parse OME-XML metadata.');\n    }\n    return ensureArray(res.OME.Image).map((img) => {\n        const Channels = ensureArray(img.Pixels.Channel).map((c) => {\n            if ('Color' in c.attr) {\n                return { ...c.attr, Color: intToRgba(c.attr.Color) };\n            }\n            return { ...c.attr };\n        });\n        const { AquisitionDate = '', Description = '' } = img;\n        const image = {\n            ...img.attr,\n            AquisitionDate,\n            Description,\n            Pixels: {\n                ...img.Pixels.attr,\n                Channels\n            }\n        };\n        return {\n            ...image,\n            format() {\n                const { Pixels } = image;\n                const sizes = ['X', 'Y', 'Z']\n                    .map((name) => {\n                    const size = Pixels[`PhysicalSize${name}`];\n                    const unit = Pixels[`PhysicalSize${name}Unit`];\n                    return size && unit ? `${size} ${unit}` : '-';\n                })\n                    .join(' x ');\n                return {\n                    'Acquisition Date': image.AquisitionDate,\n                    'Dimensions (XY)': `${Pixels.SizeX} x ${Pixels.SizeY}`,\n                    'Pixels Type': Pixels.Type,\n                    'Pixels Size (XYZ)': sizes,\n                    'Z-sections/Timepoints': `${Pixels.SizeZ} x ${Pixels.SizeT}`,\n                    Channels: Pixels.SizeC\n                };\n            }\n        };\n    });\n}\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\nimport { TiffPixelSource } from \"../tiff-pixel-source.js\";\nimport { getOmeLegacyIndexer, getOmeSubIFDIndexer } from \"./ome-indexers.js\";\nimport { getOmePixelSourceMeta } from \"./ome-utils.js\";\nimport { fromString } from \"./omexml.js\";\nexport const isOmeTiff = (img) => img.fileDirectory.ImageDescription.includes('<OME');\nexport async function loadOmeTiff(tiff, firstImage) {\n    // Get first image from tiff and inspect OME-XML metadata\n    const { ImageDescription, SubIFDs, PhotometricInterpretation: photometricInterpretation } = firstImage.fileDirectory;\n    const omexml = fromString(ImageDescription);\n    /*\n     * Image pyramids are stored differently between versions of Bioformats.\n     * Thus we need a different indexer depending on which format we have.\n     */\n    let levels;\n    let pyramidIndexer;\n    if (SubIFDs) {\n        // Image is >= Bioformats 6.0 and resolutions are stored using SubIFDs.\n        levels = SubIFDs.length + 1;\n        pyramidIndexer = getOmeSubIFDIndexer(tiff, omexml);\n    }\n    else {\n        // Image is legacy format; resolutions are stored as separate images.\n        levels = omexml.length;\n        pyramidIndexer = getOmeLegacyIndexer(tiff, omexml);\n    }\n    // TODO: The OmeTIFF loader only works for the _first_ image in the metadata.\n    const imgMeta = omexml[0];\n    const { labels, getShape, physicalSizes, dtype } = getOmePixelSourceMeta(imgMeta);\n    const tileSize = firstImage.getTileWidth();\n    const meta = { photometricInterpretation, physicalSizes };\n    const data = Array.from({ length: levels }).map((_, resolution) => {\n        const shape = getShape(resolution);\n        const indexer = (sel) => pyramidIndexer(sel, resolution);\n        const source = new TiffPixelSource(indexer, dtype, tileSize, shape, labels, meta);\n        return source;\n    });\n    return { data, metadata: imgMeta };\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACGA,qBAAgC;AAGhC,IAAM,UAAU,OAAyC,kBAAkB;AAEpE,IAAM,gBAAgB;AAAA,EACzB,IAAI;AAAA,EACJ,MAAM;AAAA,EACN,QAAQ;AAAA,EACR,SAAS;AAAA,EACT,SAAS;AAAA,IACL,aAAa;AAAA,EACjB;AAAA,EACA,WAAW,CAAC,cAAc,eAAe;AAAA,EACzC,YAAY,CAAC,WAAW,QAAQ,UAAU,KAAK;AAAA,EAC/C,OAAO;AACX;AA0BA,eAAe,aAAa,MAAM,SAAS;AA7C3C;AA+CI,QAAM,OAAO,UAAM,gCAAgB,IAAI;AAEvC,QAAM,QAAQ,MAAM,KAAK,SAAS;AAIlC,QAAM,UAAU,MAAM,MAAM,QAAQ;AAAA,IAChC,cAAa,wCAAS,YAAT,mBAAkB;AAAA,EACnC,CAAC;AACD,QAAM,QAAQ,MAAM,SAAS;AAC7B,QAAM,SAAS,MAAM,UAAU;AAE/B,QAAM,YAAY,IAAI,kBAAkB,OAAO;AAE/C,QAAM,SAAS,MAAM,eAAe;AACpC,QAAM,WAAW,MAAM,WAAW;AAElC,MAAI;AACJ,MAAI,qCAAU,uBAAuB;AACjC,UAAM,QAAQ,SAAS;AAAA,EAC3B;AAEA,SAAO;AAAA,IACH;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN;AAAA,EACJ;AACJ;;;AC1EA,IAAAA,kBAA2C;;;ACApC,SAAS,YAAY,GAAG;AAC3B,SAAO,MAAM,QAAQ,CAAC,IAAI,IAAI,CAAC,CAAC;AACpC;AAQO,SAAS,UAAU,KAAK;AAC3B,MAAI,CAAC,OAAO,UAAU,GAAG,GAAG;AACxB,UAAM,MAAM,iBAAiB;AAAA,EACjC;AAEA,QAAM,SAAS,IAAI,YAAY,CAAC;AAChC,QAAM,OAAO,IAAI,SAAS,MAAM;AAChC,OAAK,SAAS,GAAG,KAAK,KAAK;AAE3B,QAAM,QAAQ,IAAI,WAAW,MAAM;AACnC,SAAO,MAAM,KAAK,KAAK;AAC3B;AAMO,SAAS,cAAc,OAAO;AACjC,QAAM,cAAc,MAAM,MAAM,SAAS,CAAC;AAC1C,SAAO,gBAAgB,KAAK,gBAAgB;AAChD;AACO,SAAS,aAAa,QAAQ;AACjC,QAAM,cAAc,cAAc,OAAO,KAAK;AAC9C,QAAM,CAAC,QAAQ,KAAK,IAAI,OAAO,MAAM,MAAM,cAAc,KAAK,EAAE;AAChE,SAAO,EAAE,QAAQ,MAAM;AAC3B;AACO,IAAM,iBAAiB;;;ACnCvB,IAAM,kBAAN,MAAsB;AAAA;AAAA,EAEzB,YAAY,SAAS,OAAO,UAAU,OAAO,QAAQ,MAAM;AACvD,SAAK,WAAW;AAChB,SAAK,QAAQ;AACb,SAAK,WAAW;AAChB,SAAK,QAAQ;AACb,SAAK,SAAS;AACd,SAAK,OAAO;AAAA,EAChB;AAAA,EACA,MAAM,UAAU,EAAE,WAAW,OAAO,GAAG;AACnC,UAAM,QAAQ,MAAM,KAAK,SAAS,SAAS;AAC3C,WAAO,KAAK,aAAa,OAAO,EAAE,OAAO,CAAC;AAAA,EAC9C;AAAA,EACA,MAAM,QAAQ,EAAE,GAAG,GAAG,WAAW,OAAO,GAAG;AACvC,UAAM,EAAE,QAAQ,MAAM,IAAI,KAAK,eAAe,GAAG,CAAC;AAClD,UAAM,KAAK,IAAI,KAAK;AACpB,UAAM,KAAK,IAAI,KAAK;AACpB,UAAM,SAAS,CAAC,IAAI,IAAI,KAAK,OAAO,KAAK,MAAM;AAC/C,UAAM,QAAQ,MAAM,KAAK,SAAS,SAAS;AAC3C,WAAO,KAAK,aAAa,OAAO,EAAE,QAAQ,OAAO,QAAQ,OAAO,CAAC;AAAA,EACrE;AAAA,EACA,MAAM,aAAa,OAAO,OAAO;AA1BrC;AA2BQ,UAAM,aAAa,cAAc,KAAK,KAAK;AAC3C,UAAM,SAAS,MAAM,MAAM,YAAY,EAAE,YAAY,GAAG,MAAM,CAAC;AAC/D,SAAI,oCAAO,WAAP,mBAAe,SAAS;AACxB,YAAM;AAAA,IACV;AAKA,UAAM,OAAQ,aAAa,SAAS,OAAO,CAAC;AAC5C,WAAO;AAAA,MACH;AAAA,MACA,OAAO,OAAO;AAAA,MACd,QAAQ,OAAO;AAAA,IACnB;AAAA,EACJ;AAAA;AAAA;AAAA;AAAA,EAIA,eAAe,GAAG,GAAG;AACjB,UAAM,EAAE,QAAQ,iBAAiB,OAAO,eAAe,IAAI,aAAa,IAAI;AAC5E,QAAI,SAAS,KAAK;AAClB,QAAI,QAAQ,KAAK;AACjB,UAAM,gBAAgB,KAAK,MAAM,iBAAiB,KAAK,QAAQ;AAC/D,UAAM,gBAAgB,KAAK,MAAM,kBAAkB,KAAK,QAAQ;AAChE,QAAI,MAAM,eAAe;AACrB,cAAQ,iBAAiB,KAAK;AAAA,IAClC;AACA,QAAI,MAAM,eAAe;AACrB,eAAS,kBAAkB,KAAK;AAAA,IACpC;AACA,WAAO,EAAE,QAAQ,MAAM;AAAA,EAC3B;AAAA,EACA,YAAY,KAAK;AACb,YAAQ,MAAM,GAAG;AAAA,EACrB;AACJ;;;AC1CO,SAAS,oBAAoB,MAAM,UAAU;AAChD,QAAM,UAAU,SAAS,CAAC;AAC1B,QAAM,EAAE,OAAO,OAAO,MAAM,IAAI,QAAQ;AACxC,QAAM,aAAa,iBAAiB,OAAO;AAC3C,SAAO,CAAC,KAAK,iBAAiB;AAE1B,UAAM,QAAQ,WAAW,GAAG;AAE5B,UAAM,eAAe,eAAe,QAAQ,QAAQ;AAEpD,WAAO,KAAK,SAAS,QAAQ,YAAY;AAAA,EAC7C;AACJ;AAeO,SAAS,oBAAoB,MAAM,UAAU;AAChD,QAAM,UAAU,SAAS,CAAC;AAC1B,QAAM,aAAa,iBAAiB,OAAO;AAC3C,QAAM,WAAW,oBAAI,IAAI;AACzB,SAAO,OAAO,KAAK,iBAAiB;AAChC,UAAM,QAAQ,WAAW,GAAG;AAC5B,UAAM,YAAY,MAAM,KAAK,SAAS,KAAK;AAE3C,QAAI,iBAAiB,GAAG;AACpB,aAAO;AAAA,IACX;AACA,UAAM,EAAE,QAAQ,IAAI,UAAU;AAC9B,QAAI,CAAC,SAAS;AACV,YAAM,MAAM,8CAA8C;AAAA,IAC9D;AAEA,UAAM,MAAM,GAAG,IAAI,KAAK,IAAI,KAAK,IAAI,KAAK;AAC1C,QAAI,CAAC,SAAS,IAAI,GAAG,GAAG;AAEpB,YAAM,eAAe,QAAQ,eAAe,CAAC;AAC7C,eAAS,IAAI,KAAK,KAAK,qBAAqB,YAAY,CAAC;AAAA,IAC7D;AACA,UAAM,MAAM,MAAM,SAAS,IAAI,GAAG;AAGlC,WAAO,IAAI,UAAU;AAAA,MAAY,IAAI;AAAA,MAAe,IAAI;AAAA;AAAA,MAExD,KAAK;AAAA,MAAU,KAAK;AAAA,MAAc,KAAK;AAAA,MAAO,KAAK;AAAA,IAAM;AAAA,EAC7D;AACJ;AAKA,SAAS,iBAAiB,SAAS;AAC/B,QAAM,EAAE,OAAO,OAAO,OAAO,eAAe,IAAI,QAAQ;AACxD,UAAQ,gBAAgB;AAAA,IACpB,KAAK,SAAS;AACV,aAAO,CAAC,EAAE,GAAG,GAAG,EAAE,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;AAAA,IAC5D;AAAA,IACA,KAAK,SAAS;AACV,aAAO,CAAC,EAAE,GAAG,GAAG,EAAE,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;AAAA,IAC5D;AAAA,IACA,KAAK,SAAS;AACV,aAAO,CAAC,EAAE,GAAG,GAAG,EAAE,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;AAAA,IAC5D;AAAA,IACA,KAAK,SAAS;AACV,aAAO,CAAC,EAAE,GAAG,GAAG,EAAE,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;AAAA,IAC5D;AAAA,IACA,KAAK,SAAS;AACV,aAAO,CAAC,EAAE,GAAG,GAAG,EAAE,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;AAAA,IAC5D;AAAA,IACA,KAAK,SAAS;AACV,aAAO,CAAC,EAAE,GAAG,GAAG,EAAE,MAAM,IAAI,QAAQ,QAAQ,IAAI,QAAQ;AAAA,IAC5D;AAAA,IACA,SAAS;AACL,YAAM,IAAI,MAAM,uCAAuC,iBAAiB;AAAA,IAC5E;AAAA,EACJ;AACJ;;;ACxGO,SAAS,UAAU,UAAU;AAChC,SAAO,SAAS,YAAY,EAAE,MAAM,EAAE,EAAE,QAAQ;AACpD;AAUO,SAAS,QAAQ,QAAQ;AAC5B,QAAM,SAAS,IAAI,IAAI,OAAO,IAAI,CAAC,MAAM,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC;AACzD,MAAI,OAAO,SAAS,OAAO,QAAQ;AAC/B,UAAM,MAAM,gDAAgD;AAAA,EAChE;AACA,SAAO,CAAC,SAAS;AACb,UAAM,QAAQ,OAAO,IAAI,IAAI;AAC7B,QAAI,UAAU,QAAW;AACrB,YAAM,MAAM,oBAAoB;AAAA,IACpC;AACA,WAAO;AAAA,EACX;AACJ;;;ACvBO,IAAM,eAAe;AAAA,EACxB,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,QAAQ;AAAA,EACR,OAAO;AAAA,EACP,QAAQ;AAAA,EACR,MAAM;AAAA,EACN,OAAO;AAAA,EACP,OAAO;AACX;AACO,SAAS,sBAAsB,EAAE,OAAO,GAAG;AAE9C,QAAM,SAAS,UAAU,OAAO,cAAc;AAE9C,QAAM,OAAO,QAAQ,MAAM;AAC3B,QAAM,QAAQ,MAAM,OAAO,MAAM,EAAE,KAAK,CAAC;AACzC,QAAM,KAAK,GAAG,CAAC,IAAI,OAAO;AAC1B,QAAM,KAAK,GAAG,CAAC,IAAI,OAAO;AAC1B,QAAM,KAAK,GAAG,CAAC,IAAI,OAAO;AAE1B,MAAI,OAAO,aAAa;AAEpB,WAAO,KAAK,IAAI;AAChB,UAAM,KAAK,CAAC;AAAA,EAChB;AAGA,QAAM,WAAW,CAAC,UAAU;AACxB,UAAM,IAAI,CAAC,GAAG,KAAK;AACnB,MAAE,KAAK,GAAG,CAAC,IAAI,OAAO,SAAS;AAC/B,MAAE,KAAK,GAAG,CAAC,IAAI,OAAO,SAAS;AAC/B,WAAO;AAAA,EACX;AACA,MAAI,EAAE,OAAO,QAAQ,eAAe;AAChC,UAAM,MAAM,cAAc,OAAO,qBAAqB;AAAA,EAC1D;AACA,QAAM,QAAQ,aAAa,OAAO,IAAI;AACtC,MAAI,OAAO,iBAAiB,OAAO,eAAe;AAC9C,UAAM,gBAAgB;AAAA,MAClB,GAAG;AAAA,QACC,MAAM,OAAO;AAAA,QACb,MAAM,OAAO;AAAA,MACjB;AAAA,MACA,GAAG;AAAA,QACC,MAAM,OAAO;AAAA,QACb,MAAM,OAAO;AAAA,MACjB;AAAA,IACJ;AACA,QAAI,OAAO,eAAe;AACtB,oBAAc,IAAI;AAAA,QACd,MAAM,OAAO;AAAA,QACb,MAAM,OAAO;AAAA,MACjB;AAAA,IACJ;AACA,WAAO,EAAE,QAAQ,UAAU,eAAe,MAAM;AAAA,EACpD;AACA,SAAO,EAAE,QAAQ,UAAU,MAAM;AACrC;;;AC1DA,6BAA0B;AAG1B,IAAM,YAAY,IAAI,iCAAU;AAAA;AAAA,EAE5B,qBAAqB;AAAA,EACrB,qBAAqB;AAAA;AAAA,EAErB,eAAe;AAAA,EACf,qBAAqB;AAAA;AAAA,EAErB,kBAAkB;AACtB,CAAC;AACD,IAAM,QAAQ,CAAC,QAAQ,UAAU,MAAM,GAAG;AACnC,SAAS,WAAW,KAAK;AAC5B,QAAM,MAAM,MAAM,GAAG;AACrB,MAAI,CAAC,IAAI,KAAK;AACV,UAAM,MAAM,mCAAmC;AAAA,EACnD;AACA,SAAO,YAAY,IAAI,IAAI,KAAK,EAAE,IAAI,CAAC,QAAQ;AAC3C,UAAM,WAAW,YAAY,IAAI,OAAO,OAAO,EAAE,IAAI,CAAC,MAAM;AACxD,UAAI,WAAW,EAAE,MAAM;AACnB,eAAO,EAAE,GAAG,EAAE,MAAM,OAAO,UAAU,EAAE,KAAK,KAAK,EAAE;AAAA,MACvD;AACA,aAAO,EAAE,GAAG,EAAE,KAAK;AAAA,IACvB,CAAC;AACD,UAAM,EAAE,iBAAiB,IAAI,cAAc,GAAG,IAAI;AAClD,UAAM,QAAQ;AAAA,MACV,GAAG,IAAI;AAAA,MACP;AAAA,MACA;AAAA,MACA,QAAQ;AAAA,QACJ,GAAG,IAAI,OAAO;AAAA,QACd;AAAA,MACJ;AAAA,IACJ;AACA,WAAO;AAAA,MACH,GAAG;AAAA,MACH,SAAS;AACL,cAAM,EAAE,OAAO,IAAI;AACnB,cAAM,QAAQ,CAAC,KAAK,KAAK,GAAG,EACvB,IAAI,CAAC,SAAS;AACf,gBAAM,OAAO,OAAO,eAAe,MAAM;AACzC,gBAAM,OAAO,OAAO,eAAe,UAAU;AAC7C,iBAAO,QAAQ,OAAO,GAAG,QAAQ,SAAS;AAAA,QAC9C,CAAC,EACI,KAAK,KAAK;AACf,eAAO;AAAA,UACH,oBAAoB,MAAM;AAAA,UAC1B,mBAAmB,GAAG,OAAO,WAAW,OAAO;AAAA,UAC/C,eAAe,OAAO;AAAA,UACtB,qBAAqB;AAAA,UACrB,yBAAyB,GAAG,OAAO,WAAW,OAAO;AAAA,UACrD,UAAU,OAAO;AAAA,QACrB;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ,CAAC;AACL;;;ACtDO,IAAM,YAAY,CAAC,QAAQ,IAAI,cAAc,iBAAiB,SAAS,MAAM;AACpF,eAAsB,YAAY,MAAM,YAAY;AAEhD,QAAM,EAAE,kBAAkB,SAAS,2BAA2B,0BAA0B,IAAI,WAAW;AACvG,QAAM,SAAS,WAAW,gBAAgB;AAK1C,MAAI;AACJ,MAAI;AACJ,MAAI,SAAS;AAET,aAAS,QAAQ,SAAS;AAC1B,qBAAiB,oBAAoB,MAAM,MAAM;AAAA,EACrD,OACK;AAED,aAAS,OAAO;AAChB,qBAAiB,oBAAoB,MAAM,MAAM;AAAA,EACrD;AAEA,QAAM,UAAU,OAAO,CAAC;AACxB,QAAM,EAAE,QAAQ,UAAU,eAAe,MAAM,IAAI,sBAAsB,OAAO;AAChF,QAAM,WAAW,WAAW,aAAa;AACzC,QAAM,OAAO,EAAE,2BAA2B,cAAc;AACxD,QAAM,OAAO,MAAM,KAAK,EAAE,QAAQ,OAAO,CAAC,EAAE,IAAI,CAAC,GAAG,eAAe;AAC/D,UAAM,QAAQ,SAAS,UAAU;AACjC,UAAM,UAAU,CAAC,QAAQ,eAAe,KAAK,UAAU;AACvD,UAAM,SAAS,IAAI,gBAAgB,SAAS,OAAO,UAAU,OAAO,QAAQ,IAAI;AAChF,WAAO;AAAA,EACX,CAAC;AACD,SAAO,EAAE,MAAM,UAAU,QAAQ;AACrC;;;APnBA,eAAsB,YAAY,QAAQ,OAAO,CAAC,GAAG;AACjD,QAAM,EAAE,SAAS,QAAQ,IAAI;AAE7B,MAAI;AACJ,MAAI,kBAAkB,yBAAS;AAC3B,WAAO;AAAA,EACX,WACS,OAAO,WAAW,UAAU;AACjC,WAAO,UAAM,yBAAQ,QAAQ,OAAO;AAAA,EACxC,OACK;AACD,WAAO,UAAM,0BAAS,MAAM;AAAA,EAChC;AAQA,MAAI,SAAS;AAAA,EAOb;AAMA,QAAM,aAAa,MAAM,KAAK,SAAS,CAAC;AACxC,MAAI,UAAU,UAAU,GAAG;AACvB,WAAO,YAAY,MAAM,UAAU;AAAA,EACvC;AACA,QAAM,IAAI,MAAM,yBAAyB;AAC7C;",
+  "names": ["import_geotiff"]
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export { GeoTIFFLoader } from './geotiff-loader';
-export { loadGeoTiff } from './lib/load-geotiff';
-export { TiffPixelSource } from './lib/tiff-pixel-source';
+export { GeoTIFFLoader } from "./geotiff-loader.js";
+export { loadGeoTiff } from "./lib/load-geotiff.js";
+export { TiffPixelSource } from "./lib/tiff-pixel-source.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,aAAa,EAAC,MAAM,kBAAkB,CAAC;AAE/C,OAAO,EAAC,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAC,eAAe,EAAC,MAAM,yBAAyB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,aAAa,EAAC,4BAAyB;AAE/C,OAAO,EAAC,WAAW,EAAC,8BAA2B;AAC/C,OAAO,EAAC,eAAe,EAAC,mCAAgC"}

package/dist/index.js

@@ -1,4 +1,6 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 export { GeoTIFFLoader } from "./geotiff-loader.js";
 export { loadGeoTiff } from "./lib/load-geotiff.js";
 export { TiffPixelSource } from "./lib/tiff-pixel-source.js";
-//# sourceMappingURL=index.js.map

package/dist/lib/load-geotiff.d.ts

@@ -1,5 +1,5 @@
 import { GeoTIFF } from 'geotiff';
-import type { TiffPixelSource } from './tiff-pixel-source';
+import type { TiffPixelSource } from "./tiff-pixel-source.js";
 /** Options for initializing a tiff pixel source. */
 interface GeoTIFFOptions {
     /** Headers passed to each underlying request. */

package/dist/lib/load-geotiff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-geotiff.d.ts","sourceRoot":"","sources":["../../src/lib/load-geotiff.ts"],"names":[],"mappings":"AAIA,OAAO,EAAoB,OAAO,EAAC,MAAM,SAAS,CAAC;AAUnD,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,qBAAqB,CAAC;AAEzD,oDAAoD;AACpD,UAAU,cAAc;IACtB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,+JAA+J;IAC/J,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gGAAgG;IAChG,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,EAC/B,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,WAAW,CAAC,CA2CtB"}
+{"version":3,"file":"load-geotiff.d.ts","sourceRoot":"","sources":["../../src/lib/load-geotiff.ts"],"names":[],"mappings":"AAIA,OAAO,EAAoB,OAAO,EAAC,MAAM,SAAS,CAAC;AAUnD,OAAO,KAAK,EAAC,eAAe,EAAC,+BAA4B;AAEzD,oDAAoD;AACpD,UAAU,cAAc;IACtB,iDAAiD;IACjD,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAClC,+JAA+J;IAC/J,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,gGAAgG;IAChG,IAAI,CAAC,EAAE,OAAO,CAAC;CAChB;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,eAAe,CAAC,MAAM,EAAE,CAAC,EAAE,CAAC;IAClC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACnC;AAED;;;;;;;;;GASG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,EAC/B,IAAI,GAAE,cAAmB,GACxB,OAAO,CAAC,WAAW,CAAC,CA2CtB"}

package/dist/lib/load-geotiff.js

@@ -1,24 +1,60 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { fromUrl, fromBlob, GeoTIFF } from 'geotiff';
+// import {
+//   // createPoolProxy,
+//   createOffsetsProxy,
+//   checkProxies
+// } from './utils/proxies.ts.disabled';
+// import Pool from './lib/Pool';
 import { loadOmeTiff, isOmeTiff } from "./ome/load-ome-tiff.js";
-export async function loadGeoTiff(source) {
-  let opts = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  const {
-    headers,
-    offsets
-  } = opts;
-  let tiff;
-  if (source instanceof GeoTIFF) {
-    tiff = source;
-  } else if (typeof source === 'string') {
-    tiff = await fromUrl(source, headers);
-  } else {
-    tiff = await fromBlob(source);
-  }
-  if (offsets) {}
-  const firstImage = await tiff.getImage(0);
-  if (isOmeTiff(firstImage)) {
-    return loadOmeTiff(tiff, firstImage);
-  }
-  throw new Error('GeoTIFF not recognized.');
+/**
+ * Opens an OME-TIFF via URL and returns data source and associated metadata for first image.
+ *
+ * @param source url string, File/Blob object, or GeoTIFF object
+ * @param opts options for initializing a tiff pixel source.
+ *  - `opts.headers` are passed to each underlying fetch request.
+ *  - `opts.offsets` are a performance enhancment to index the remote tiff source using pre-computed byte-offsets.
+ *  - `opts.pool` indicates whether a multi-threaded pool of image decoders should be used to decode tiles (default = true).
+ * @return data source and associated OME-Zarr metadata.
+ */
+export async function loadGeoTiff(source, opts = {}) {
+    const { headers, offsets } = opts;
+    // Create tiff source
+    let tiff;
+    if (source instanceof GeoTIFF) {
+        tiff = source;
+    }
+    else if (typeof source === 'string') {
+        tiff = await fromUrl(source, headers);
+    }
+    else {
+        tiff = await fromBlob(source);
+    }
+    // if (pool) {
+    /*
+     * Creates a worker pool to decode tiff tiles. Wraps tiff
+     * in a Proxy that injects 'pool' into `tiff.readRasters`.
+     */
+    // tiff = createPoolProxy(tiff, new Pool());
+    // }
+    if (offsets) {
+        /*
+         * Performance enhancement. If offsets are provided, we
+         * create a proxy that intercepts calls to `tiff.getImage`
+         * and injects the pre-computed offsets.
+         */
+        // tiff = createOffsetsProxy(tiff, offsets);
+    }
+    /*
+     * Inspect tiff source for our performance enhancing proxies.
+     * Prints warnings to console if `offsets` or `pool` are missing.
+     */
+    // checkProxies(tiff);
+    const firstImage = await tiff.getImage(0);
+    if (isOmeTiff(firstImage)) {
+        return loadOmeTiff(tiff, firstImage);
+    }
+    throw new Error('GeoTIFF not recognized.');
 }
-//# sourceMappingURL=load-geotiff.js.map

package/dist/lib/ome/load-ome-tiff.d.ts

@@ -1,5 +1,5 @@
 import type { GeoTIFF, GeoTIFFImage } from 'geotiff';
-import { TiffPixelSource } from '../tiff-pixel-source';
+import { TiffPixelSource } from "../tiff-pixel-source.js";
 export declare const isOmeTiff: (img: GeoTIFFImage) => any;
 export declare function loadOmeTiff(tiff: GeoTIFF, firstImage: GeoTIFFImage): Promise<{
     data: TiffPixelSource<["t", "c", "z"] | ["c", "t", "z"] | ["z", "t", "c"] | ["t", "z", "c"] | ["z", "c", "t"] | ["c", "z", "t"]>[];

package/dist/lib/ome/load-ome-tiff.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"load-ome-tiff.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/load-ome-tiff.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAEnD,OAAO,EAAC,eAAe,EAAC,MAAM,sBAAsB,CAAC;AAMrD,eAAO,MAAM,SAAS,QAAS,YAAY,QAAwD,CAAC;AAEpG,wBAAsB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCxE"}
+{"version":3,"file":"load-ome-tiff.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/load-ome-tiff.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,OAAO,EAAE,YAAY,EAAC,MAAM,SAAS,CAAC;AAEnD,OAAO,EAAC,eAAe,EAAC,gCAA6B;AAMrD,eAAO,MAAM,SAAS,QAAS,YAAY,QAAwD,CAAC;AAEpG,wBAAsB,WAAW,CAAC,IAAI,EAAE,OAAO,EAAE,UAAU,EAAE,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCxE"}

package/dist/lib/ome/load-ome-tiff.js

@@ -1,47 +1,41 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { TiffPixelSource } from "../tiff-pixel-source.js";
 import { getOmeLegacyIndexer, getOmeSubIFDIndexer } from "./ome-indexers.js";
 import { getOmePixelSourceMeta } from "./ome-utils.js";
 import { fromString } from "./omexml.js";
-export const isOmeTiff = img => img.fileDirectory.ImageDescription.includes('<OME');
+export const isOmeTiff = (img) => img.fileDirectory.ImageDescription.includes('<OME');
 export async function loadOmeTiff(tiff, firstImage) {
-  const {
-    ImageDescription,
-    SubIFDs,
-    PhotometricInterpretation: photometricInterpretation
-  } = firstImage.fileDirectory;
-  const omexml = fromString(ImageDescription);
-  let levels;
-  let pyramidIndexer;
-  if (SubIFDs) {
-    levels = SubIFDs.length + 1;
-    pyramidIndexer = getOmeSubIFDIndexer(tiff, omexml);
-  } else {
-    levels = omexml.length;
-    pyramidIndexer = getOmeLegacyIndexer(tiff, omexml);
-  }
-  const imgMeta = omexml[0];
-  const {
-    labels,
-    getShape,
-    physicalSizes,
-    dtype
-  } = getOmePixelSourceMeta(imgMeta);
-  const tileSize = firstImage.getTileWidth();
-  const meta = {
-    photometricInterpretation,
-    physicalSizes
-  };
-  const data = Array.from({
-    length: levels
-  }).map((_, resolution) => {
-    const shape = getShape(resolution);
-    const indexer = sel => pyramidIndexer(sel, resolution);
-    const source = new TiffPixelSource(indexer, dtype, tileSize, shape, labels, meta);
-    return source;
-  });
-  return {
-    data,
-    metadata: imgMeta
-  };
+    // Get first image from tiff and inspect OME-XML metadata
+    const { ImageDescription, SubIFDs, PhotometricInterpretation: photometricInterpretation } = firstImage.fileDirectory;
+    const omexml = fromString(ImageDescription);
+    /*
+     * Image pyramids are stored differently between versions of Bioformats.
+     * Thus we need a different indexer depending on which format we have.
+     */
+    let levels;
+    let pyramidIndexer;
+    if (SubIFDs) {
+        // Image is >= Bioformats 6.0 and resolutions are stored using SubIFDs.
+        levels = SubIFDs.length + 1;
+        pyramidIndexer = getOmeSubIFDIndexer(tiff, omexml);
+    }
+    else {
+        // Image is legacy format; resolutions are stored as separate images.
+        levels = omexml.length;
+        pyramidIndexer = getOmeLegacyIndexer(tiff, omexml);
+    }
+    // TODO: The OmeTIFF loader only works for the _first_ image in the metadata.
+    const imgMeta = omexml[0];
+    const { labels, getShape, physicalSizes, dtype } = getOmePixelSourceMeta(imgMeta);
+    const tileSize = firstImage.getTileWidth();
+    const meta = { photometricInterpretation, physicalSizes };
+    const data = Array.from({ length: levels }).map((_, resolution) => {
+        const shape = getShape(resolution);
+        const indexer = (sel) => pyramidIndexer(sel, resolution);
+        const source = new TiffPixelSource(indexer, dtype, tileSize, shape, labels, meta);
+        return source;
+    });
+    return { data, metadata: imgMeta };
 }
-//# sourceMappingURL=load-ome-tiff.js.map

package/dist/lib/ome/ome-indexers.d.ts

@@ -1,5 +1,5 @@
 import type { GeoTIFFImage, GeoTIFF } from 'geotiff';
-import type { OMEXML } from '../ome/omexml';
+import type { OMEXML } from "../ome/omexml.js";
 export type ImageFileDirectory = any;
 export type OmeTiffSelection = {
     t: number;

package/dist/lib/ome/ome-indexers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ome-indexers.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/ome-indexers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAE,OAAO,EAAC,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,eAAe,CAAC;AAE1C,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAErC,MAAM,MAAM,gBAAgB,GAAG;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AACjE,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAqBzF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAanF;AAgBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAwCnF"}
+{"version":3,"file":"ome-indexers.d.ts","sourceRoot":"","sources":["../../../src/lib/ome/ome-indexers.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,YAAY,EAAE,OAAO,EAAC,MAAM,SAAS,CAAC;AACnD,OAAO,KAAK,EAAC,MAAM,EAAC,yBAAsB;AAE1C,MAAM,MAAM,kBAAkB,GAAG,GAAG,CAAC;AAErC,MAAM,MAAM,gBAAgB,GAAG;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAC,CAAC;AACjE,MAAM,MAAM,cAAc,GAAG,CAAC,GAAG,EAAE,gBAAgB,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,YAAY,CAAC,CAAC;AAqBzF,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAanF;AAgBD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,cAAc,CAwCnF"}