@gisatcz/deckgl-geolib 1.12.0-dev.5 → 2.0.0

package/dist/esm/index.js

@@ -7,33 +7,6 @@ import { getMeshBoundingBox } from '@loaders.gl/schema';
 import { concatenateTypedArrays } from '@loaders.gl/loader-utils';
 import { SimpleMeshLayer } from '@deck.gl/mesh-layers';
 
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-}
-
 /* eslint-disable no-restricted-globals, no-restricted-syntax */
 /* global SharedArrayBuffer */
 
@@ -163,6 +136,12 @@ uncurryThisGetter(
   SymbolToStringTag
 );
 
+// Uint8Array
+const NativeUint8Array = Uint8Array;
+
+// Uint16Array
+const NativeUint16Array = Uint16Array;
+
 // Uint32Array
 const NativeUint32Array = Uint32Array;
 
@@ -192,7 +171,6 @@ const DataViewPrototypeGetUint16 = uncurryThis(
 // WeakMap
 /**
  * Do not construct with arguments to avoid calling the "set" method
- *
  * @type {{new <K extends {}, V>(): WeakMap<K, V>}}
  */
 const NativeWeakMap = WeakMap;
@@ -222,7 +200,6 @@ const SafeIteratorPrototype = ObjectCreate(null, {
 
 /**
  * Wrap the Array around the SafeIterator If Array.prototype [@@iterator] has been modified
- *
  * @type {<T>(array: T[]) => Iterable<T>}
  */
 function safeIfNeeded(array) {
@@ -263,21 +240,20 @@ for (const key of ReflectOwnKeys(ArrayIteratorPrototype)) {
   ObjectDefineProperty(DummyArrayIteratorPrototype, key, ReflectGetOwnPropertyDescriptor(ArrayIteratorPrototype, key));
 }
 
-// algorithm: http://fox-toolkit.org/ftp/fasthalffloatconversion.pdf
-
+// base algorithm: http://fox-toolkit.org/ftp/fasthalffloatconversion.pdf
 
 const buffer = new NativeArrayBuffer(4);
 const floatView = new NativeFloat32Array(buffer);
 const uint32View = new NativeUint32Array(buffer);
 
-const baseTable = new NativeUint32Array(512);
-const shiftTable = new NativeUint32Array(512);
+const baseTable = new NativeUint16Array(512);
+const shiftTable = new NativeUint8Array(512);
 
 for (let i = 0; i < 256; ++i) {
   const e = i - 127;
 
   // very small number (0, -0)
-  if (e < -27) {
+  if (e < -24) {
     baseTable[i]         = 0x0000;
     baseTable[i | 0x100] = 0x8000;
     shiftTable[i]         = 24;
@@ -314,21 +290,18 @@ for (let i = 0; i < 256; ++i) {
 }
 
 const mantissaTable = new NativeUint32Array(2048);
-const exponentTable = new NativeUint32Array(64);
-const offsetTable = new NativeUint32Array(64);
-
 for (let i = 1; i < 1024; ++i) {
-  let m = i << 13;    // zero pad mantissa bits
-  let e = 0;          // zero exponent
+  let m = i << 13; // zero pad mantissa bits
+  let e = 0; // zero exponent
 
   // normalized
-  while((m & 0x00800000) === 0) {
+  while ((m & 0x00800000) === 0) {
     m <<= 1;
-    e -= 0x00800000;  // decrement exponent
+    e -= 0x00800000; // decrement exponent
   }
 
-  m &= ~0x00800000;   // clear leading 1 bit
-  e += 0x38800000;    // adjust bias
+  m &= ~0x00800000; // clear leading 1 bit
+  e += 0x38800000; // adjust bias
 
   mantissaTable[i] = m | e;
 }
@@ -336,6 +309,7 @@ for (let i = 1024; i < 2048; ++i) {
   mantissaTable[i] = 0x38000000 + ((i - 1024) << 13);
 }
 
+const exponentTable = new NativeUint32Array(64);
 for (let i = 1; i < 31; ++i) {
   exponentTable[i] = i << 23;
 }
@@ -346,6 +320,7 @@ for (let i = 33; i < 63; ++i) {
 }
 exponentTable[63] = 0xc7800000;
 
+const offsetTable = new NativeUint16Array(64);
 for (let i = 1; i < 64; ++i) {
   if (i !== 32) {
     offsetTable[i] = 1024;
@@ -354,19 +329,17 @@ for (let i = 1; i < 64; ++i) {
 
 /**
  * convert a half float number bits to a number
- *
  * @param {number} float16bits - half float number bits
  * @returns {number} double float
  */
 function convertToNumber(float16bits) {
-  const m = float16bits >> 10;
-  uint32View[0] = mantissaTable[offsetTable[m] + (float16bits & 0x3ff)] + exponentTable[m];
+  const i = float16bits >> 10;
+  uint32View[0] = mantissaTable[offsetTable[i] + (float16bits & 0x3ff)] + exponentTable[i];
   return floatView[0];
 }
 
 /**
  * returns an unsigned 16-bit float at the specified byte offset from the start of the DataView
- *
  * @param {DataView} dataView
  * @param {number} byteOffset
  * @param {[boolean]} opts
@@ -2636,6 +2609,8 @@ class QuickLRU extends Map {
 		} else {
 			this._set(key, {value, expiry});
 		}
+
+		return this;
 	}
 
 	has(key) {
@@ -4434,6 +4409,29 @@ class Tile {
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
+/**
+ * Get geometry edges that located on a border of the mesh
+ * @param {object} indices - edge indices from quantized mesh data
+ * @param {TypedArray} position - position attribute geometry data
+ * @returns {number[][]} - outside edges data
+ */
+function getOutsideEdgesFromIndices(indices, position) {
+    // Sort skirt indices to create adjacent triangles
+    indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);
+    // Reverse (b - a) to match triangle winding
+    indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);
+    indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);
+    // Reverse (b - a) to match triangle winding
+    indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);
+    const edges = [];
+    for (const index in indices) {
+        const indexGroup = indices[index];
+        for (let i = 0; i < indexGroup.length - 1; i++) {
+            edges.push([indexGroup[i], indexGroup[i + 1]]);
+        }
+    }
+    return edges;
+}
 /**
  * Add skirt to existing mesh
  * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
@@ -4479,7 +4477,6 @@ function addSkirt(attributes, triangles, skirtHeight, outsideIndices) {
  * @returns {number[][]} - outside edges data
  */
 function getOutsideEdgesFromTriangles(triangles) {
-    var _a, _b;
     const edges = [];
     for (let i = 0; i < triangles.length; i += 3) {
         edges.push([triangles[i], triangles[i + 1]]);
@@ -4490,7 +4487,7 @@ function getOutsideEdgesFromTriangles(triangles) {
     const outsideEdges = [];
     let index = 0;
     while (index < edges.length) {
-        if (edges[index][0] === ((_a = edges[index + 1]) === null || _a === void 0 ? void 0 : _a[1]) && edges[index][1] === ((_b = edges[index + 1]) === null || _b === void 0 ? void 0 : _b[0])) {
+        if (edges[index][0] === edges[index + 1]?.[1] && edges[index][1] === edges[index + 1]?.[0]) {
             index += 2;
         }
         else {
@@ -4500,29 +4497,6 @@ function getOutsideEdgesFromTriangles(triangles) {
     }
     return outsideEdges;
 }
-/**
- * Get geometry edges that located on a border of the mesh
- * @param {object} indices - edge indices from quantized mesh data
- * @param {TypedArray} position - position attribute geometry data
- * @returns {number[][]} - outside edges data
- */
-function getOutsideEdgesFromIndices(indices, position) {
-    // Sort skirt indices to create adjacent triangles
-    indices.westIndices.sort((a, b) => position[3 * a + 1] - position[3 * b + 1]);
-    // Reverse (b - a) to match triangle winding
-    indices.eastIndices.sort((a, b) => position[3 * b + 1] - position[3 * a + 1]);
-    indices.southIndices.sort((a, b) => position[3 * b] - position[3 * a]);
-    // Reverse (b - a) to match triangle winding
-    indices.northIndices.sort((a, b) => position[3 * a] - position[3 * b]);
-    const edges = [];
-    for (const index in indices) {
-        const indexGroup = indices[index];
-        for (let i = 0; i < indexGroup.length - 1; i++) {
-            edges.push([indexGroup[i], indexGroup[i + 1]]);
-        }
-    }
-    return edges;
-}
 /**
  * Get geometry edges that located on a border of the mesh
  * @param {object} args
@@ -4563,7 +4537,12 @@ function updateAttributesForNewEdge({ edge, edgeIndex, attributes, skirtHeight,
 // Copyright (c) vis.gl contributors
 // ISC License
 // Copyright(c) 2019, Michael Fogleman, Vladimir Agafonkin
+/* eslint-disable @typescript-eslint/ban-ts-comment */
 // @ts-nocheck
+/* eslint-enable @typescript-eslint/ban-ts-comment */
+function orient(ax, ay, bx, by, cx, cy) {
+    return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);
+}
 /* eslint-disable complexity, max-params, max-statements, max-depth, no-constant-condition */
 class Delatin {
     constructor(data, width, height = width) {
@@ -4951,9 +4930,6 @@ class Delatin {
         return i > i0;
     }
 }
-function orient(ax, ay, bx, by, cx, cy) {
-    return (bx - cx) * (ay - cy) - (by - cy) * (ax - cx);
-}
 function inCircle(ax, ay, bx, by, cx, cy, px, py) {
     const dx = ax - px;
     const dy = ay - py;
@@ -4967,7 +4943,7 @@ function inCircle(ax, ay, bx, by, cx, cy, px, py) {
     return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
 }
 
-/* eslint 'max-len': [1, { code: 105, comments: 999, ignoreStrings: true, ignoreUrls: true }] */
+// import { ExtentsLeftBottomRightTop } from '@deck.gl/core/utils/positions';
 // FIXME - tesselator as a parameter
 const tesselator = 'martini';
 const DefaultGeoImageOptions = {
@@ -5002,279 +4978,264 @@ const DefaultGeoImageOptions = {
     planarConfig: undefined,
 };
 class GeoImage {
-    constructor() {
-        this.scale = (num, inMin, inMax, outMin, outMax) => ((num - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;
-    }
-    setUrl(url) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO - not tested
-            const response = yield fetch(url);
-            const arrayBuffer = yield response.arrayBuffer();
-            const tiff = yield fromArrayBuffer(arrayBuffer);
-            const data = yield tiff.getImage(0);
-            this.data = data;
-        });
-    }
-    getMap(input, options, meshMaxError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const mergedOptions = Object.assign(Object.assign({}, DefaultGeoImageOptions), options);
-            switch (mergedOptions.type) {
-                case 'image':
-                    return this.getBitmap(input, mergedOptions);
-                case 'terrain':
-                    return this.getHeightmap(input, mergedOptions, meshMaxError);
-                default:
-                    return null;
-            }
-        });
+    data;
+    scale = (num, inMin, inMax, outMin, outMax) => ((num - inMin) * (outMax - outMin)) / (inMax - inMin) + outMin;
+    async setUrl(url) {
+        // TODO - not tested
+        const response = await fetch(url);
+        const arrayBuffer = await response.arrayBuffer();
+        const tiff = await fromArrayBuffer(arrayBuffer);
+        const data = await tiff.getImage(0);
+        this.data = data;
+    }
+    async getMap(input, options, meshMaxError) {
+        const mergedOptions = { ...DefaultGeoImageOptions, ...options };
+        switch (mergedOptions.type) {
+            case 'image':
+                return this.getBitmap(input, mergedOptions);
+            case 'terrain':
+                return this.getHeightmap(input, mergedOptions, meshMaxError);
+            default:
+                return null;
+        }
     }
     // GetHeightmap uses only "useChannel" and "multiplier" options
-    getHeightmap(input, options, meshMaxError) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            let rasters = [];
-            let width;
-            let height;
-            if (typeof (input) === 'string') {
-                // TODO not tested
-                // input is type of object
-                yield this.setUrl(input);
-                rasters = (yield this.data.readRasters());
-                width = this.data.getWidth();
-                height = this.data.getHeight();
-            }
-            else {
-                rasters = input.rasters;
-                width = input.width;
-                height = input.height;
+    async getHeightmap(input, options, meshMaxError) {
+        let rasters = [];
+        let width;
+        let height;
+        if (typeof (input) === 'string') {
+            // TODO not tested
+            // input is type of object
+            await this.setUrl(input);
+            rasters = (await this.data.readRasters());
+            width = this.data.getWidth();
+            height = this.data.getHeight();
+        }
+        else {
+            rasters = input.rasters;
+            width = input.width;
+            height = input.height;
+        }
+        const optionsLocal = { ...options };
+        let channel = rasters[0];
+        optionsLocal.useChannelIndex ??= optionsLocal.useChannel == null ? null : optionsLocal.useChannel - 1;
+        if (options.useChannelIndex != null) {
+            if (rasters[optionsLocal.useChannelIndex]) {
+                channel = rasters[optionsLocal.useChannelIndex];
             }
-            const optionsLocal = Object.assign({}, options);
-            let channel = rasters[0];
-            (_a = optionsLocal.useChannelIndex) !== null && _a !== void 0 ? _a : (optionsLocal.useChannelIndex = optionsLocal.useChannel == null ? null : optionsLocal.useChannel - 1);
-            if (options.useChannelIndex != null) {
-                if (rasters[optionsLocal.useChannelIndex]) {
-                    channel = rasters[optionsLocal.useChannelIndex];
-                }
+        }
+        const terrain = new Float32Array((width + 1) * (height + 1));
+        const numOfChannels = channel.length / (width * height);
+        let pixel = options.useChannelIndex === null ? 0 : options.useChannelIndex;
+        for (let i = 0, y = 0; y < height; y++) {
+            for (let x = 0; x < width; x++, i++) {
+                const elevationValue = (options.noDataValue && channel[pixel] === options.noDataValue) ? options.terrainMinValue : channel[pixel] * options.multiplier;
+                terrain[i + y] = elevationValue;
+                pixel += numOfChannels;
             }
-            const terrain = new Float32Array((width + 1) * (height + 1));
-            const numOfChannels = channel.length / (width * height);
-            let pixel = options.useChannelIndex === null ? 0 : options.useChannelIndex;
-            for (let i = 0, y = 0; y < height; y++) {
-                for (let x = 0; x < width; x++, i++) {
-                    const elevationValue = (options.noDataValue && channel[pixel] === options.noDataValue) ? options.terrainMinValue : channel[pixel] * options.multiplier;
-                    terrain[i + y] = elevationValue;
-                    pixel += numOfChannels;
-                }
+        }
+        {
+            // backfill bottom border
+            for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
+                terrain[i] = terrain[i - width - 1];
             }
-            {
-                // backfill bottom border
-                for (let i = (width + 1) * width, x = 0; x < width; x++, i++) {
-                    terrain[i] = terrain[i - width - 1];
-                }
-                // backfill right border
-                for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
-                    terrain[i] = terrain[i - 1];
-                }
+            // backfill right border
+            for (let i = height, y = 0; y < height + 1; y++, i += height + 1) {
+                terrain[i] = terrain[i - 1];
             }
-            // getMesh
-            const { terrainSkirtHeight } = options;
-            let mesh;
-            switch (tesselator) {
-                case 'martini':
+        }
+        // getMesh
+        const { terrainSkirtHeight } = options;
+        let mesh;
+        switch (tesselator) {
+            case 'martini':
+                mesh = getMartiniTileMesh(meshMaxError, width, terrain);
+                break;
+            case 'delatin':
+                mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
+                break;
+            default:
+                if (width === height && !(height && (width - 1))) {
+                    // fixme get terrain to separate method
+                    // terrain = getTerrain(data, width, height, elevationDecoder, 'martini');
                     mesh = getMartiniTileMesh(meshMaxError, width, terrain);
-                    break;
-                case 'delatin':
+                }
+                else {
+                    // fixme get terrain to separate method
+                    // terrain = getTerrain(data, width, height, elevationDecoder, 'delatin');
                     mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
-                    break;
-                default:
-                    if (width === height && !(height && (width - 1))) {
-                        // fixme get terrain to separate method
-                        // terrain = getTerrain(data, width, height, elevationDecoder, 'martini');
-                        mesh = getMartiniTileMesh(meshMaxError, width, terrain);
-                    }
-                    else {
-                        // fixme get terrain to separate method
-                        // terrain = getTerrain(data, width, height, elevationDecoder, 'delatin');
-                        mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
-                    }
-                    break;
-            }
-            // Martini
-            // Martini
-            // Delatin
-            // Delatin
-            const { vertices } = mesh;
-            let { triangles } = mesh;
-            let attributes = getMeshAttributes(vertices, terrain, width, height, input.bounds);
-            // Compute bounding box before adding skirt so that z values are not skewed
-            const boundingBox = getMeshBoundingBox(attributes);
-            if (terrainSkirtHeight) {
-                const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangles, terrainSkirtHeight);
-                attributes = newAttributes;
-                triangles = newTriangles;
-            }
-            return {
-                // Data return by this loader implementation
-                loaderData: {
-                    header: {},
-                },
-                header: {
-                    vertexCount: triangles.length,
-                    boundingBox,
-                },
-                mode: 4,
-                indices: { value: Uint32Array.from(triangles), size: 1 },
-                attributes,
-            };
-        });
-    }
-    getBitmap(input, options) {
-        var _a;
-        return __awaiter(this, void 0, void 0, function* () {
-            // console.time('bitmap-generated-in');
-            // const optionsLocal = { ...options };
-            const optionsLocal = Object.assign({}, options);
-            let rasters = [];
-            let channels;
-            let width;
-            let height;
-            if (typeof (input) === 'string') {
-                // TODO not tested
-                // input is type of object
-                yield this.setUrl(input);
-                rasters = (yield this.data.readRasters());
-                channels = rasters.length;
-                width = this.data.getWidth();
-                height = this.data.getHeight();
-            }
-            else {
-                rasters = input.rasters;
-                channels = rasters.length;
-                width = input.width;
-                height = input.height;
-            }
-            const canvas = document.createElement('canvas');
-            canvas.width = width;
-            canvas.height = height;
-            const c = canvas.getContext('2d');
-            const imageData = c.createImageData(width, height);
-            let r;
-            let g;
-            let b;
-            let a;
-            const size = width * height * 4;
-            // const size = width * height;
-            // if (!options.noDataValue) {
-            //   console.log('Missing noData value. Raster might be displayed incorrectly.');
-            // }
-            optionsLocal.unidentifiedColor = this.getColorFromChromaType(optionsLocal.unidentifiedColor);
-            optionsLocal.nullColor = this.getColorFromChromaType(optionsLocal.nullColor);
-            optionsLocal.clippedColor = this.getColorFromChromaType(optionsLocal.clippedColor);
-            optionsLocal.color = this.getColorFromChromaType(optionsLocal.color);
-            (_a = optionsLocal.useChannelIndex) !== null && _a !== void 0 ? _a : (optionsLocal.useChannelIndex = options.useChannel === null ? null : options.useChannel - 1);
-            // console.log(rasters[0])
-            /* console.log("raster 0 length: " + rasters[0].length)
-            console.log("image width: " + width)
-            console.log("channels: " + channels)
-            console.log("format: " + rasters[0].length / (width * height))
-            */
-            if (optionsLocal.useChannelIndex == null) {
-                if (channels === 1) {
-                    if (rasters[0].length / (width * height) === 1) {
-                        const channel = rasters[0];
-                        // AUTO RANGE
-                        if (optionsLocal.useAutoRange) {
-                            optionsLocal.colorScaleValueRange = this.getMinMax(channel, optionsLocal);
-                            // console.log('data min: ' + optionsLocal.rangeMin + ', max: ' + optionsLocal.rangeMax);
-                        }
-                        // SINGLE CHANNEL
-                        const colorData = this.getColorValue(channel, optionsLocal, size);
-                        colorData.forEach((value, index) => {
-                            imageData.data[index] = value;
-                        });
-                    }
-                    // RGB values in one channel
-                    if (rasters[0].length / (width * height) === 3) {
-                        // console.log("geoImage: " + "RGB 1 array of length: " + rasters[0].length);
-                        let pixel = 0;
-                        for (let idx = 0; idx < size; idx += 4) {
-                            const rgbColor = [rasters[0][pixel], rasters[0][pixel + 1], rasters[0][pixel + 2]];
-                            const rgbaColor = this.hasPixelsNoData(rgbColor, optionsLocal.noDataValue)
-                                ? optionsLocal.nullColor
-                                : [...rgbColor, Math.floor(optionsLocal.alpha * 2.55)];
-                            // eslint-disable-next-line max-len
-                            [imageData.data[idx], imageData.data[idx + 1], imageData.data[idx + 2], imageData.data[idx + 3]] = rgbaColor;
-                            pixel += 3;
-                        }
-                    }
-                    if (rasters[0].length / (width * height) === 4) {
-                        // console.log("geoImage: " + "RGBA 1 array");
-                        rasters[0].forEach((value, index) => {
-                            imageData.data[index] = value;
-                        });
-                    }
                 }
-                if (channels === 3) {
-                    // RGB
-                    let pixel = 0;
-                    for (let i = 0; i < size; i += 4) {
-                        r = rasters[0][pixel];
-                        g = rasters[1][pixel];
-                        b = rasters[2][pixel];
-                        a = Math.floor(optionsLocal.alpha * 2.55);
-                        imageData.data[i] = r;
-                        imageData.data[i + 1] = g;
-                        imageData.data[i + 2] = b;
-                        imageData.data[i + 3] = a;
-                        pixel += 1;
+                break;
+        }
+        const { vertices } = mesh;
+        let { triangles } = mesh;
+        let attributes = getMeshAttributes(vertices, terrain, width, height, input.bounds);
+        // Compute bounding box before adding skirt so that z values are not skewed
+        const boundingBox = getMeshBoundingBox(attributes);
+        if (terrainSkirtHeight) {
+            const { attributes: newAttributes, triangles: newTriangles } = addSkirt(attributes, triangles, terrainSkirtHeight);
+            attributes = newAttributes;
+            triangles = newTriangles;
+        }
+        return {
+            // Data return by this loader implementation
+            loaderData: {
+                header: {},
+            },
+            header: {
+                vertexCount: triangles.length,
+                boundingBox,
+            },
+            mode: 4, // TRIANGLES
+            indices: { value: Uint32Array.from(triangles), size: 1 },
+            attributes,
+        };
+    }
+    async getBitmap(input, options) {
+        // console.time('bitmap-generated-in');
+        // const optionsLocal = { ...options };
+        const optionsLocal = { ...options };
+        let rasters = [];
+        let channels;
+        let width;
+        let height;
+        if (typeof (input) === 'string') {
+            // TODO not tested
+            // input is type of object
+            await this.setUrl(input);
+            rasters = (await this.data.readRasters());
+            channels = rasters.length;
+            width = this.data.getWidth();
+            height = this.data.getHeight();
+        }
+        else {
+            rasters = input.rasters;
+            channels = rasters.length;
+            width = input.width;
+            height = input.height;
+        }
+        const canvas = document.createElement('canvas');
+        canvas.width = width;
+        canvas.height = height;
+        const c = canvas.getContext('2d');
+        const imageData = c.createImageData(width, height);
+        let r;
+        let g;
+        let b;
+        let a;
+        const size = width * height * 4;
+        // const size = width * height;
+        // if (!options.noDataValue) {
+        //   console.log('Missing noData value. Raster might be displayed incorrectly.');
+        // }
+        optionsLocal.unidentifiedColor = this.getColorFromChromaType(optionsLocal.unidentifiedColor);
+        optionsLocal.nullColor = this.getColorFromChromaType(optionsLocal.nullColor);
+        optionsLocal.clippedColor = this.getColorFromChromaType(optionsLocal.clippedColor);
+        optionsLocal.color = this.getColorFromChromaType(optionsLocal.color);
+        optionsLocal.useChannelIndex ??= options.useChannel === null ? null : options.useChannel - 1;
+        // console.log(rasters[0])
+        /* console.log("raster 0 length: " + rasters[0].length)
+        console.log("image width: " + width)
+        console.log("channels: " + channels)
+        console.log("format: " + rasters[0].length / (width * height))
+        */
+        if (optionsLocal.useChannelIndex == null) {
+            if (channels === 1) {
+                if (rasters[0].length / (width * height) === 1) {
+                    const channel = rasters[0];
+                    // AUTO RANGE
+                    if (optionsLocal.useAutoRange) {
+                        optionsLocal.colorScaleValueRange = this.getMinMax(channel, optionsLocal);
+                        // console.log('data min: ' + optionsLocal.rangeMin + ', max: ' + optionsLocal.rangeMax);
                     }
+                    // SINGLE CHANNEL
+                    const colorData = this.getColorValue(channel, optionsLocal, size);
+                    colorData.forEach((value, index) => {
+                        imageData.data[index] = value;
+                    });
                 }
-                if (channels === 4) {
-                    // RGBA
+                // RGB values in one channel
+                if (rasters[0].length / (width * height) === 3) {
+                    // console.log("geoImage: " + "RGB 1 array of length: " + rasters[0].length);
                     let pixel = 0;
-                    for (let i = 0; i < size; i += 4) {
-                        r = rasters[0][pixel];
-                        g = rasters[1][pixel];
-                        b = rasters[2][pixel];
-                        a = Math.floor(optionsLocal.alpha * 2.55);
-                        imageData.data[i] = r;
-                        imageData.data[i + 1] = g;
-                        imageData.data[i + 2] = b;
-                        imageData.data[i + 3] = a;
-                        pixel += 1;
+                    for (let idx = 0; idx < size; idx += 4) {
+                        const rgbColor = [rasters[0][pixel], rasters[0][pixel + 1], rasters[0][pixel + 2]];
+                        const rgbaColor = this.hasPixelsNoData(rgbColor, optionsLocal.noDataValue)
+                            ? optionsLocal.nullColor
+                            : [...rgbColor, Math.floor(optionsLocal.alpha * 2.55)];
+                        // eslint-disable-next-line max-len
+                        [imageData.data[idx], imageData.data[idx + 1], imageData.data[idx + 2], imageData.data[idx + 3]] = rgbaColor;
+                        pixel += 3;
                     }
                 }
+                if (rasters[0].length / (width * height) === 4) {
+                    // console.log("geoImage: " + "RGBA 1 array");
+                    rasters[0].forEach((value, index) => {
+                        imageData.data[index] = value;
+                    });
+                }
             }
-            else if (optionsLocal.useChannelIndex < optionsLocal.numOfChannels && optionsLocal.useChannelIndex >= 0) {
-                let channel = rasters[0];
-                if (rasters[optionsLocal.useChannelIndex]) {
-                    channel = rasters[optionsLocal.useChannelIndex];
+            if (channels === 3) {
+                // RGB
+                let pixel = 0;
+                for (let i = 0; i < size; i += 4) {
+                    r = rasters[0][pixel];
+                    g = rasters[1][pixel];
+                    b = rasters[2][pixel];
+                    a = Math.floor(optionsLocal.alpha * 2.55);
+                    imageData.data[i] = r;
+                    imageData.data[i + 1] = g;
+                    imageData.data[i + 2] = b;
+                    imageData.data[i + 3] = a;
+                    pixel += 1;
                 }
-                // AUTO RANGE
-                if (optionsLocal.useAutoRange) {
-                    optionsLocal.colorScaleValueRange = this.getMinMax(channel, optionsLocal);
-                    // console.log('data min: ' + optionsLocal.rangeMin + ', max: ' + optionsLocal.rangeMax);
+            }
+            if (channels === 4) {
+                // RGBA
+                let pixel = 0;
+                for (let i = 0; i < size; i += 4) {
+                    r = rasters[0][pixel];
+                    g = rasters[1][pixel];
+                    b = rasters[2][pixel];
+                    a = Math.floor(optionsLocal.alpha * 2.55);
+                    imageData.data[i] = r;
+                    imageData.data[i + 1] = g;
+                    imageData.data[i + 2] = b;
+                    imageData.data[i + 3] = a;
+                    pixel += 1;
                 }
-                // const numOfChannels = channel.length / (width * height);
-                const colorData = this.getColorValue(channel, optionsLocal, size, optionsLocal.numOfChannels);
-                colorData.forEach((value, index) => {
-                    imageData.data[index] = value;
-                });
             }
-            else {
-                // if user defined channel does not exist
-                console.log(`Defined channel(${options.useChannel}) or channel index(${options.useChannelIndex}) does not exist, choose a different channel or set the useChannel property to null if you want to visualize RGB(A) imagery`);
-                const defaultColorData = this.getDefaultColor(size, optionsLocal.nullColor);
-                defaultColorData.forEach((value, index) => {
-                    imageData.data[index] = value;
-                });
+        }
+        else if (optionsLocal.useChannelIndex < optionsLocal.numOfChannels && optionsLocal.useChannelIndex >= 0) {
+            let channel = rasters[0];
+            if (rasters[optionsLocal.useChannelIndex]) {
+                channel = rasters[optionsLocal.useChannelIndex];
             }
-            // console.timeEnd('bitmap-generated-in');
-            c.putImageData(imageData, 0, 0);
-            const imageUrl = canvas.toDataURL('image/png');
-            // console.log('Bitmap generated.');
-            return imageUrl;
-        });
+            // AUTO RANGE
+            if (optionsLocal.useAutoRange) {
+                optionsLocal.colorScaleValueRange = this.getMinMax(channel, optionsLocal);
+                // console.log('data min: ' + optionsLocal.rangeMin + ', max: ' + optionsLocal.rangeMax);
+            }
+            // const numOfChannels = channel.length / (width * height);
+            const colorData = this.getColorValue(channel, optionsLocal, size, optionsLocal.numOfChannels);
+            colorData.forEach((value, index) => {
+                imageData.data[index] = value;
+            });
+        }
+        else {
+            // if user defined channel does not exist
+            console.log(`Defined channel(${options.useChannel}) or channel index(${options.useChannelIndex}) does not exist, choose a different channel or set the useChannel property to null if you want to visualize RGB(A) imagery`);
+            const defaultColorData = this.getDefaultColor(size, optionsLocal.nullColor);
+            defaultColorData.forEach((value, index) => {
+                imageData.data[index] = value;
+            });
+        }
+        // console.timeEnd('bitmap-generated-in');
+        c.putImageData(imageData, 0, 0);
+        const imageUrl = canvas.toDataURL('image/png');
+        // console.log('Bitmap generated.');
+        return imageUrl;
     }
     getMinMax(array, options) {
         let maxValue = options.maxValue ? options.maxValue : Number.MIN_VALUE;
@@ -5353,7 +5314,7 @@ class GeoImage {
             }
             // FIXME
             // eslint-disable-next-line
-            [colorsArray[i], colorsArray[i + 1], colorsArray[i + 2], colorsArray[i + 3]] = pixelColor;
+            ([colorsArray[i], colorsArray[i + 1], colorsArray[i + 2], colorsArray[i + 3]] = pixelColor);
             pixel += numOfChannels;
         }
         return colorsArray;
@@ -5443,7 +5404,7 @@ function getMeshAttributes(vertices, terrain, width, height, bounds) {
 function getDelatinTileMesh(meshMaxError, width, height, terrain) {
     const tin = new Delatin(terrain, width + 1, height + 1);
     tin.run(meshMaxError);
-    // @ts-expect-error
+    // @ts-expect-error: Delatin instance properties 'coords' and 'triangles' are not explicitly typed in the library port
     const { coords, triangles } = tin;
     const vertices = coords;
     return { vertices, triangles };
@@ -5457,31 +5418,30 @@ const CogTilesGeoImageOptionsDefaults = {
     blurredTexture: true,
 };
 class CogTiles {
+    cog;
+    cogZoomLookup = [0];
+    cogResolutionLookup = [0];
+    cogOrigin = [0, 0];
+    zoomRange = [0, 0];
+    tileSize;
+    bounds;
+    geo = new GeoImage();
+    options;
     constructor(options) {
-        this.cogZoomLookup = [0];
-        this.cogResolutionLookup = [0];
-        this.cogOrigin = [0, 0];
-        this.zoomRange = [0, 0];
-        this.loaded = false;
-        this.geo = new GeoImage();
-        this.options = Object.assign(Object.assign({}, CogTilesGeoImageOptionsDefaults), options);
-    }
-    initializeCog(url) {
-        var _a, _b;
-        var _c, _d;
-        return __awaiter(this, void 0, void 0, function* () {
-            this.cog = yield fromUrl(url);
-            const image = yield this.cog.getImage(); // by default, the first image is read.
-            this.cogOrigin = image.getOrigin();
-            (_a = (_c = this.options).noDataValue) !== null && _a !== void 0 ? _a : (_c.noDataValue = this.getNoDataValue(image));
-            (_b = (_d = this.options).format) !== null && _b !== void 0 ? _b : (_d.format = this.getDataTypeFromTags(image));
-            this.options.numOfChannels = this.getNumberOfChannels(image);
-            this.options.planarConfig = this.getPlanarConfiguration(image);
-            [this.cogZoomLookup, this.cogResolutionLookup] = yield this.buildCogZoomResolutionLookup(this.cog);
-            this.tileSize = image.getTileWidth();
-            this.zoomRange = this.calculateZoomRange(image, yield this.cog.getImageCount());
-            this.bounds = this.calculateBoundsAsLatLon(image);
-        });
+        this.options = { ...CogTilesGeoImageOptionsDefaults, ...options };
+    }
+    async initializeCog(url) {
+        this.cog = await fromUrl(url);
+        const image = await this.cog.getImage(); // by default, the first image is read.
+        this.cogOrigin = image.getOrigin();
+        this.options.noDataValue ??= this.getNoDataValue(image);
+        this.options.format ??= this.getDataTypeFromTags(image);
+        this.options.numOfChannels = this.getNumberOfChannels(image);
+        this.options.planarConfig = this.getPlanarConfiguration(image);
+        [this.cogZoomLookup, this.cogResolutionLookup] = await this.buildCogZoomResolutionLookup(this.cog);
+        this.tileSize = image.getTileWidth();
+        this.zoomRange = this.calculateZoomRange(image, await this.cog.getImageCount());
+        this.bounds = this.calculateBoundsAsLatLon(image);
     }
     getZoomRange() {
         return this.zoomRange;
@@ -5533,33 +5493,31 @@ class CogTiles {
      *   - The first array (`zoomLookup`) maps each image index to its computed zoom level.
      *   - The second array (`resolutionLookup`) maps each image index to its estimated resolution (m/pixel).
      */
-    buildCogZoomResolutionLookup(cog) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // Retrieve the total number of images (overviews) in the COG.
-            const imageCount = yield cog.getImageCount();
-            // Use the first image as the base reference.
-            const baseImage = yield cog.getImage(0);
-            const baseResolution = baseImage.getResolution()[0]; // Resolution (m/pixel) of the base image.
-            const baseWidth = baseImage.getWidth();
-            // Initialize arrays to store the zoom level and resolution for each image.
-            const zoomLookup = [];
-            const resolutionLookup = [];
-            // Iterate over each image (overview) in the COG.
-            for (let idx = 0; idx < imageCount; idx++) {
-                const image = yield cog.getImage(idx);
-                const width = image.getWidth();
-                // Calculate the scale factor relative to the base image.
-                const scaleFactor = baseWidth / width;
-                const estimatedResolution = baseResolution * scaleFactor;
-                // Calculate the zoom level using the Web Mercator resolution standard:
-                // webMercatorRes0 is the resolution at zoom level 0; each zoom level halves the resolution.
-                const zoomLevel = Math.round(Math.log2(webMercatorRes0 / estimatedResolution));
-                // console.log(`buildCogZoomResolutionLookup: Image index ${idx}: Estimated Resolution = ${estimatedResolution} m/pixel, Zoom Level = ${zoomLevel}`);
-                zoomLookup[idx] = zoomLevel;
-                resolutionLookup[idx] = estimatedResolution;
-            }
-            return [zoomLookup, resolutionLookup];
-        });
+    async buildCogZoomResolutionLookup(cog) {
+        // Retrieve the total number of images (overviews) in the COG.
+        const imageCount = await cog.getImageCount();
+        // Use the first image as the base reference.
+        const baseImage = await cog.getImage(0);
+        const baseResolution = baseImage.getResolution()[0]; // Resolution (m/pixel) of the base image.
+        const baseWidth = baseImage.getWidth();
+        // Initialize arrays to store the zoom level and resolution for each image.
+        const zoomLookup = [];
+        const resolutionLookup = [];
+        // Iterate over each image (overview) in the COG.
+        for (let idx = 0; idx < imageCount; idx++) {
+            const image = await cog.getImage(idx);
+            const width = image.getWidth();
+            // Calculate the scale factor relative to the base image.
+            const scaleFactor = baseWidth / width;
+            const estimatedResolution = baseResolution * scaleFactor;
+            // Calculate the zoom level using the Web Mercator resolution standard:
+            // webMercatorRes0 is the resolution at zoom level 0; each zoom level halves the resolution.
+            const zoomLevel = Math.round(Math.log2(webMercatorRes0 / estimatedResolution));
+            // console.log(`buildCogZoomResolutionLookup: Image index ${idx}: Estimated Resolution = ${estimatedResolution} m/pixel, Zoom Level = ${zoomLevel}`);
+            zoomLookup[idx] = zoomLevel;
+            resolutionLookup[idx] = estimatedResolution;
+        }
+        return [zoomLookup, resolutionLookup];
     }
     /**
      * Determines the appropriate image index from the Cloud Optimized GeoTIFF (COG)
@@ -5588,93 +5546,138 @@ class CogTiles {
         }
         return exactMatchIndex;
     }
-    getTileFromImage(tileX, tileY, zoom) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const imageIndex = this.getImageIndexForZoomLevel(zoom);
-            const targetImage = yield this.cog.getImage(imageIndex);
-            // Ensure the image is tiled
-            const tileWidth = targetImage.getTileWidth();
-            const tileHeight = targetImage.getTileHeight();
-            if (!tileWidth || !tileHeight) {
-                throw new Error('The image is not tiled.');
-            }
-            // Calculate the map offset between the global Web Mercator origin and the COG's origin.
-            // (Difference in map units.)
-            // if X offset is large and positive (COG is far to the right of global origin)
-            // if Y offset is large and positive (COG is far below global origin — expected)
-            const offsetXMap = this.cogOrigin[0] - webMercatorOrigin[0];
-            const offsetYMap = webMercatorOrigin[1] - this.cogOrigin[1];
-            const tileResolution = (EARTH_CIRCUMFERENCE / tileWidth) / Math.pow(2, zoom);
-            this.cogResolutionLookup[imageIndex];
-            // Convert map offsets into pixel offsets.
-            const offsetXPixel = Math.floor(offsetXMap / tileResolution);
-            const offsetYPixel = Math.floor(offsetYMap / tileResolution);
-            const imageHeight = targetImage.getHeight();
-            const imageWidth = targetImage.getWidth();
-            // approach by comparing bboxes of tile and cog image
-            const tilePixelBbox = [
-                tileX * tileWidth,
-                tileY * tileHeight,
-                (tileX + 1) * tileWidth,
-                (tileY + 1) * tileHeight,
-            ];
-            const cogPixelBBox = [
-                offsetXPixel,
-                offsetYPixel,
-                offsetXPixel + imageWidth,
-                offsetYPixel + imageHeight,
-            ];
-            const intersecion = this.getIntersectionBBox(tilePixelBbox, cogPixelBBox, offsetXPixel, offsetYPixel, tileWidth);
-            const [validWidth, validHeight, window, missingLeft, missingTop] = intersecion;
-            // Read the raster data for the tile window with shifted origin.
-            if (missingLeft > 0 || missingTop > 0 || validWidth < tileWidth || validHeight < tileHeight) {
-                // Prepare the final tile buffer and fill it with noDataValue.
-                const tileBuffer = this.createTileBuffer(this.options.format, tileWidth);
-                tileBuffer.fill(this.options.noDataValue);
-                // if the valid window is smaller than tile size, it gets the image size width and height, thus validRasterData.width must be used as below
-                const validRasterData = yield targetImage.readRasters({ window });
-                // FOR MULTI-BAND - the result is one array with sequentially typed bands, firstly all data for the band 0, then for band 1
-                // I think this is less practical then the commented solution above, but I do it so it works with the code in geoimage.ts in deck.gl-geoimage in function getColorValue.
-                const validImageData = Array(validRasterData.length * validRasterData[0].length);
-                validImageData.fill(this.options.noDataValue);
-                // Place the valid pixel data into the tile buffer.
-                for (let band = 0; band < validRasterData.length; band++) {
-                    for (let row = 0; row < validHeight; row++) {
-                        for (let col = 0; col < validWidth; col++) {
-                            // Compute the destination position in the tile buffer.
-                            // We shift by the number of missing pixels (if any) at the top/left.
-                            const destRow = missingTop + row;
-                            const destCol = missingLeft + col;
-                            if (destRow < tileWidth && destCol < tileHeight) {
-                                tileBuffer[destRow * tileWidth + destCol] = validRasterData[band][row * validRasterData.width + col];
-                            }
-                            else {
-                                console.log('error in assigning data to tile buffer');
-                            }
+    async getTileFromImage(tileX, tileY, zoom) {
+        const imageIndex = this.getImageIndexForZoomLevel(zoom);
+        const targetImage = await this.cog.getImage(imageIndex);
+        // 1. Validation: Ensure the image is tiled
+        const tileWidth = targetImage.getTileWidth();
+        const tileHeight = targetImage.getTileHeight();
+        if (!tileWidth || !tileHeight) {
+            throw new Error('GeoTIFF Error: The provided image is not tiled. '
+                + 'Please use "rio cogeo create --web-optimized" to fix this.');
+        }
+        // --- STEP 1: CALCULATE BOUNDS IN METERS ---
+        // 2. Get COG Metadata (image = COG)
+        const imageResolution = this.cogResolutionLookup[imageIndex];
+        const imageHeight = targetImage.getHeight();
+        const imageWidth = targetImage.getWidth();
+        const [imgOriginX, imgOriginY] = this.cogOrigin;
+        // 3. Define Web Mercator Constants
+        // We use the class property tileSize (usually 256) as the ground truth for grid calculations
+        const TILE_SIZE = this.tileSize;
+        const ORIGIN_X = webMercatorOrigin[0];
+        const ORIGIN_Y = webMercatorOrigin[1];
+        // 4. Calculate Tile BBox in World Meters
+        // This defines where the map expects the tile to be physically located
+        const tileGridResolution = (EARTH_CIRCUMFERENCE / TILE_SIZE) / (2 ** zoom);
+        const tileMinXMeters = ORIGIN_X + (tileX * TILE_SIZE * tileGridResolution);
+        const tileMaxYMeters = ORIGIN_Y - (tileY * TILE_SIZE * tileGridResolution);
+        // Note: We don't strictly need MaxX/MinY meters for the start calculation,
+        // but they are useful if debugging the full meter footprint.
+        // --- STEP 2: CONVERT TO PIXEL COORDINATES ---
+        // 5. Calculate precise floating-point start position relative to the image
+        const windowMinX = (tileMinXMeters - imgOriginX) / imageResolution;
+        const windowMinY = (imgOriginY - tileMaxYMeters) / imageResolution;
+        // 6. Snap to Integer Grid (The "Force 256" Fix)
+        // We round the start position to align with the nearest pixel.
+        // Crucially, we calculate endX/endY by adding tileSize to startX/startY.
+        // This guarantees the window is exactly 256x256, preventing "off-by-one" (257px) errors.
+        const startX = Math.round(windowMinX);
+        const startY = Math.round(windowMinY);
+        const endX = startX + TILE_SIZE;
+        const endY = startY + TILE_SIZE;
+        // --- STEP 3: CALCULATE INTERSECTION ---
+        // 7. Clamp the read window to the actual image dimensions
+        // This defines the "Safe" area we can actually read from the file.
+        const validReadX = Math.max(0, startX);
+        const validReadY = Math.max(0, startY);
+        const validReadMaxX = Math.min(imageWidth, endX);
+        const validReadMaxY = Math.min(imageHeight, endY);
+        const readWidth = validReadMaxX - validReadX;
+        const readHeight = validReadMaxY - validReadY;
+        // CHECK: If no overlap, return empty
+        if (readWidth <= 0 || readHeight <= 0) {
+            return [this.createEmptyTile()];
+        }
+        // 8. Calculate Offsets (Padding)
+        // "missingLeft" is how many blank pixels we need to insert before the image data starts.
+        // Logic: If we wanted to read from -50 (startX), but clamped to 0 (validReadX),
+        // we are missing the first 50 pixels.
+        const missingLeft = validReadX - startX;
+        const missingTop = validReadY - startY;
+        const window = [validReadX, validReadY, validReadMaxX, validReadMaxY];
+        // --- STEP 4: READ AND COMPOSITE ---
+        // Case A: Partial Overlap (Padding or Cropping required)
+        // If the tile is hanging off the edge, we need to manually reconstruct it.
+        if (missingLeft > 0 || missingTop > 0 || readWidth < tileWidth || readHeight < tileHeight) {
+            /// Initialize a temporary buffer for a single band (filled with NoData)
+            // We will reuse this buffer for each band to save memory allocations.
+            const tileBuffer = this.createTileBuffer(this.options.format, tileWidth);
+            tileBuffer.fill(this.options.noDataValue);
+            // if the valid window is smaller than the tile size, it gets the image size width and height, thus validRasterData.width must be used as below
+            const validRasterData = await targetImage.readRasters({ window });
+            // FOR MULTI-BAND - the result is one array with sequentially typed bands, firstly all data for the band 0, then for band 1
+            // I think this is less practical then the commented solution above, but I do it so it works with the code in GeoImage.ts in deck.gl-geoimage in function getColorValue.
+            const validImageData = Array(validRasterData.length * validRasterData[0].length);
+            validImageData.fill(this.options.noDataValue);
+            // Place the valid pixel data into the tile buffer.
+            for (let band = 0; band < validRasterData.length; band += 1) {
+                for (let row = 0; row < readHeight; row += 1) {
+                    const destRow = missingTop + row;
+                    const destRowOffset = destRow * TILE_SIZE;
+                    const srcRowOffset = row * validRasterData.width;
+                    for (let col = 0; col < readWidth; col += 1) {
+                        // Compute the destination position in the tile buffer.
+                        // We shift by the number of missing pixels (if any) at the top/left.
+                        const destCol = missingLeft + col;
+                        // Bounds Check: Ensure we don't write outside the 256x256 buffer
+                        if (destRow < tileWidth && destCol < tileHeight) {
+                            tileBuffer[destRowOffset + destCol] = validRasterData[band][srcRowOffset + col];
+                        }
+                        else {
+                            console.log('error in assigning data to tile buffer');
                         }
                     }
-                    tileBuffer.forEach((rasterValue, index) => {
-                        validImageData[index * this.options.numOfChannels + band] = rasterValue;
-                    });
                 }
-                return [validImageData];
+                for (let i = 0; i < tileBuffer.length; i += 1) {
+                    validImageData[i * this.options.numOfChannels + band] = tileBuffer[i];
+                }
             }
-            // Read the raster data for the non shifted tile window.
-            const tileData = yield targetImage.readRasters({ window, interleave: true });
-            // console.log(`data that starts at the left top corner of the tile ${tileX}, ${tileY}`);
-            return [tileData];
-        });
+            return [validImageData];
+        }
+        // Case B: Perfect Match (Optimization)
+        // If the read window is exactly 256x256 and aligned, we can read directly interleaved.
+        // console.log("Perfect aligned read");
+        const tileData = await targetImage.readRasters({ window, interleave: true });
+        // console.log(`data that starts at the left top corner of the tile ${tileX}, ${tileY}`);
+        return [tileData];
     }
-    getTile(x, y, z, bounds, meshMaxError) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const tileData = yield this.getTileFromImage(x, y, z);
-            return this.geo.getMap({
-                rasters: [tileData[0]],
-                width: this.tileSize,
-                height: this.tileSize,
-                bounds,
-            }, this.options, meshMaxError);
-        });
+    /**
+     * Creates a blank tile buffer filled with the "No Data" value.
+     */
+    createEmptyTile() {
+        // 1. Determine the size
+        // Default to 1 channel (grayscale) if not specified
+        const channels = this.options.numOfChannels || 1;
+        const size = this.tileSize * this.tileSize * channels;
+        // 2. Create the array
+        // Float32 is standard for GeoTIFF data handling in browsers
+        const tileData = new Float32Array(size);
+        // 3. Fill with "No Data" value
+        // If noDataValue is undefined, it defaults to 0
+        if (this.options.noDataValue !== undefined) {
+            tileData.fill(this.options.noDataValue);
+        }
+        return tileData;
+    }
+    async getTile(x, y, z, bounds, meshMaxError) {
+        const tileData = await this.getTileFromImage(x, y, z);
+        return this.geo.getMap({
+            rasters: [tileData[0]],
+            width: this.tileSize,
+            height: this.tileSize,
+            bounds,
+        }, this.options, meshMaxError);
     }
     /**
      * Determines the data type (e.g., "Int32", "Float64") of a GeoTIFF image
@@ -5757,53 +5760,6 @@ class CogTiles {
     getNumberOfChannels(image) {
         return image.getSamplesPerPixel();
     }
-    /**
-     * Calculates the intersection between a tile bounding box and a COG bounding box,
-     * returning the intersection window in image pixel space (relative to COG offsets),
-     * along with how much blank space (nodata) appears on the left and top of the tile.
-     *
-     * @param {number[]} tileBbox - Tile bounding box: [minX, minY, maxX, maxY]
-     * @param {number[]} cogBbox - COG bounding box: [minX, minY, maxX, maxY]
-     * @param {number} offsetXPixel - X offset of the COG origin in pixel space
-     * @param {number} offsetYPixel - Y offset of the COG origin in pixel space
-     * @param {number} tileSize - Size of the tile in pixels (default: 256)
-     * @returns {[number, number, number[] | null, number, number]}
-     *   An array containing:
-     *   - width of the intersection
-     *   - height of the intersection
-     *   - pixel-space window: [startX, startY, endX, endY] or null if no overlap
-     *   - missingLeft: padding pixels on the left
-     *   - missingTop: padding pixels on the top
-     */
-    getIntersectionBBox(tileBbox, cogBbox, offsetXPixel = 0, offsetYPixel = 0, tileSize = 256) {
-        const interLeft = Math.max(tileBbox[0], cogBbox[0]);
-        const interTop = Math.max(tileBbox[1], cogBbox[1]);
-        const interRight = Math.min(tileBbox[2], cogBbox[2]);
-        const interBottom = Math.min(tileBbox[3], cogBbox[3]);
-        const width = Math.max(0, interRight - interLeft);
-        const height = Math.max(0, interBottom - interTop);
-        let window = null;
-        let missingLeft = 0;
-        let missingTop = 0;
-        if (width > 0 && height > 0) {
-            window = [
-                interLeft - offsetXPixel,
-                interTop - offsetYPixel,
-                interRight - offsetXPixel,
-                interBottom - offsetYPixel,
-            ];
-            // Padding from the tile origin to valid data start
-            missingLeft = interLeft - tileBbox[0];
-            missingTop = interTop - tileBbox[1];
-        }
-        return [
-            width,
-            height,
-            window,
-            missingLeft,
-            missingTop,
-        ];
-    }
     /**
      * Retrieves the PlanarConfiguration value from a GeoTIFF image.
      *
@@ -5876,7 +5832,8 @@ const urlType$1 = {
         return true;
     },
 };
-const defaultProps$1 = Object.assign(Object.assign({}, TileLayer.defaultProps), { 
+const defaultProps$1 = {
+    ...TileLayer.defaultProps,
     // Image url that encodes height data
     // elevationData: urlType,
     // Image url to use as texture
@@ -5886,10 +5843,9 @@ const defaultProps$1 = Object.assign(Object.assign({}, TileLayer.defaultProps),
     // Bounding box of the terrain image, [minX, minY, maxX, maxY] in world coordinates
     bounds: {
         type: 'array', value: null, optional: true, compare: true,
-    }, rasterData: urlType$1, 
-    // Color to use if texture is unavailable
-    // color: { type: 'color', value: [255, 255, 255] },
-    blurredTexture: true, opacity: 1, clampToTerrain: false, 
+    },
+    rasterData: urlType$1,
+    clampToTerrain: false,
     // Object to decode height data, from (r, g, b) to height in meters
     // elevationDecoder: {
     //   type: 'object',
@@ -5901,40 +5857,31 @@ const defaultProps$1 = Object.assign(Object.assign({}, TileLayer.defaultProps),
     //   },
     // },
     // Supply url to local terrain worker bundle. Only required if running offline and cannot access CDN.
-    workerUrl: '' });
+    workerUrl: '',
+    // Same as SimpleMeshLayer wireframe
+    // wireframe: false,
+    // material: true,
+    // loaders: [TerrainLoader],
+};
 /** Render bitmap texture from cog raster images. */
 class CogBitmapLayer extends CompositeLayer {
-    // private _isLoaded: boolean;
-    // id = '';
-    // url: string;
-    // static displayName: string;
-    // cogTiles: CogTiles;
-    //
-    // tileSize: number;
-    //
-    initializeState(context) {
-        const _super = Object.create(null, {
-            initializeState: { get: () => super.initializeState }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            _super.initializeState.call(this, context);
-            this.setState({
-                bitmapCogTiles: new CogTiles(this.props.cogBitmapOptions),
-                initialized: false,
-            });
-            yield this.init();
+    static defaultProps = defaultProps$1;
+    static layerName = 'CogBitmapLayer';
+    async initializeState(context) {
+        super.initializeState(context);
+        this.setState({
+            bitmapCogTiles: new CogTiles(this.props.cogBitmapOptions),
+            initialized: false,
         });
+        await this.init();
     }
-    init() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.state.bitmapCogTiles.initializeCog(this.props.rasterData);
-            const zoomRange = this.state.bitmapCogTiles.getZoomRange();
-            const [minZoom, maxZoom] = zoomRange;
-            this.setState({ initialized: true, minZoom, maxZoom });
-        });
+    async init() {
+        await this.state.bitmapCogTiles.initializeCog(this.props.rasterData);
+        const zoomRange = this.state.bitmapCogTiles.getZoomRange();
+        const [minZoom, maxZoom] = zoomRange;
+        this.setState({ initialized: true, minZoom, maxZoom });
     }
     updateState({ props, oldProps }) {
-        var _a, _b, _c;
         const rasterDataChanged = props.rasterData !== oldProps.rasterData;
         if (rasterDataChanged) {
             const { rasterData } = props;
@@ -5954,45 +5901,47 @@ class CogBitmapLayer extends CompositeLayer {
         // object in this way is not ideal and may need refactoring in the future to follow a more
         // declarative state management approach. Consider revisiting this if additional properties
         // need to be synchronized or if the state structure changes.
-        if (((_a = props === null || props === void 0 ? void 0 : props.cogBitmapOptions) === null || _a === void 0 ? void 0 : _a.useChannel) && (((_b = props.cogBitmapOptions) === null || _b === void 0 ? void 0 : _b.useChannel) !== ((_c = oldProps.cogBitmapOptions) === null || _c === void 0 ? void 0 : _c.useChannel))) {
+        if (props?.cogBitmapOptions?.useChannel && (props.cogBitmapOptions?.useChannel !== oldProps.cogBitmapOptions?.useChannel)) {
             this.state.bitmapCogTiles.options.useChannel = props.cogBitmapOptions.useChannel;
         }
-        // TODO - remove in v9
-        // @ts-ignore
         if (props.workerUrl) {
             log.removed('workerUrl', 'loadOptions.terrain.workerUrl')();
         }
     }
-    getTiledBitmapData(tile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            // TODO - pass signal to getTile
-            // abort request if signal is aborted
-            const tileData = yield this.state.bitmapCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z);
-            return tileData;
-        });
+    async getTiledBitmapData(tile) {
+        // TODO - pass signal to getTile
+        // abort request if signal is aborted
+        const tileData = await this.state.bitmapCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z);
+        return tileData;
     }
     renderSubLayers(props) {
         const SubLayerClass = this.getSubLayerClass('image', BitmapLayer);
         const { blurredTexture } = this.state.bitmapCogTiles.options;
-        const { opacity, clampToTerrain } = this.props;
+        const { clampToTerrain } = this.props;
+        const hasDrawMode = typeof clampToTerrain === 'object' && clampToTerrain !== null && 'terrainDrawMode' in clampToTerrain;
         const { data } = props;
         if (!data) {
             return null;
         }
         const { bbox: { west, south, east, north, }, } = props.tile;
-        return new SubLayerClass(Object.assign(Object.assign({}, props), { tileSize: this.state.bitmapCogTiles.tileSize }), Object.assign({ data: null, image: data, _instanced: false, bounds: [west, south, east, north], opacity, textureParameters: {
+        return new SubLayerClass({ ...props, tileSize: this.state.bitmapCogTiles.tileSize }, {
+            data: null,
+            image: data,
+            _instanced: false,
+            bounds: [west, south, east, north],
+            textureParameters: {
                 minFilter: blurredTexture ? 'linear' : 'nearest',
                 magFilter: blurredTexture ? 'linear' : 'nearest',
-            }, 
+            },
             //  TODO check if works!!!
-            extensions: clampToTerrain ? [new _TerrainExtension()] : [] }, ((clampToTerrain === null || clampToTerrain === void 0 ? void 0 : clampToTerrain.terrainDrawMode)
-            ? { terrainDrawMode: clampToTerrain.terrainDrawMode }
-            : {})));
+            extensions: clampToTerrain ? [new _TerrainExtension()] : [],
+            ...(hasDrawMode
+                ? { terrainDrawMode: clampToTerrain.terrainDrawMode }
+                : {}),
+        });
     }
     renderLayers() {
-        const { rasterData, blurredTexture, opacity, clampToTerrain, 
-        // tileSize,
-        maxRequests, onTileLoad, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy, cogBitmapOptions, } = this.props;
+        const { clampToTerrain, maxRequests, onTileLoad, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy, cogBitmapOptions, } = this.props;
         if (this.state.isTiled && this.state.initialized) {
             const { tileSize } = this.state.bitmapCogTiles;
             return new TileLayer(this.getSubLayerProps({
@@ -6027,28 +5976,7 @@ class CogBitmapLayer extends CompositeLayer {
         return null;
     }
 }
-CogBitmapLayer.defaultProps = defaultProps$1;
-CogBitmapLayer.layerName = 'CogBitmapLayer';
 
-// Copyright (c) 2015 - 2017 Uber Technologies, Inc.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
 const urlType = {
     type: 'object',
     value: null,
@@ -6075,19 +6003,20 @@ const urlType = {
     },
 };
 const DUMMY_DATA = [1];
-const defaultProps = Object.assign(Object.assign({}, TileLayer.defaultProps), { 
+const defaultProps = {
+    ...TileLayer.defaultProps,
     // Image url that encodes height data
-    elevationData: urlType, 
+    elevationData: urlType,
     // Image url to use as texture
-    texture: Object.assign(Object.assign({}, urlType), { optional: true }), 
+    texture: { ...urlType, optional: true },
     // Martini error tolerance in meters, smaller number -> more detailed mesh
-    meshMaxError: { type: 'number', value: 4.0 }, 
+    meshMaxError: { type: 'number', value: 4.0 },
     // Bounding box of the terrain image, [minX, minY, maxX, maxY] in world coordinates
     bounds: {
         type: 'array', value: null, optional: true, compare: true,
-    }, 
+    },
     // Color to use if texture is unavailable
-    color: { type: 'color', value: [255, 255, 255] }, 
+    color: { type: 'color', value: [255, 255, 255] },
     // Object to decode height data, from (r, g, b) to height in meters
     elevationDecoder: {
         type: 'object',
@@ -6097,11 +6026,14 @@ const defaultProps = Object.assign(Object.assign({}, TileLayer.defaultProps), {
             bScaler: 0,
             offset: 0,
         },
-    }, 
+    },
     // Supply url to local terrain worker bundle. Only required if running offline and cannot access CDN.
-    workerUrl: '', 
+    workerUrl: '',
     // Same as SimpleMeshLayer wireframe
-    wireframe: false, material: true });
+    wireframe: false,
+    material: true,
+    // loaders: [TerrainLoader],
+};
 // Turns array of templates into a single string to work around shallow change
 function urlTemplateToUpdateTrigger(template) {
     if (Array.isArray(template)) {
@@ -6113,28 +6045,25 @@ function urlTemplateToUpdateTrigger(template) {
 // TODO use meshMaxError
 // TODO - pass signal to getTile
 /** Render mesh surfaces from height map images. */
-class TerrainLayer extends CompositeLayer {
-    initializeState(context) {
-        const _super = Object.create(null, {
-            initializeState: { get: () => super.initializeState }
-        });
-        return __awaiter(this, void 0, void 0, function* () {
-            _super.initializeState.call(this, context);
-            this.setState({
-                terrainCogTiles: new CogTiles(this.props.terrainOptions),
-                initialized: false,
-            });
-            yield this.init(this.terrainUrl);
+class CogTerrainLayer extends CompositeLayer {
+    static defaultProps = defaultProps;
+    static layerName = 'CogTerrainLayer';
+    // terrainCogTiles: CogTiles;
+    terrainUrl;
+    async initializeState(context) {
+        super.initializeState(context);
+        this.setState({
+            terrainCogTiles: new CogTiles(this.props.terrainOptions),
+            initialized: false,
         });
+        await this.init(this.terrainUrl);
     }
-    init(terrainUrl) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.state.terrainCogTiles.initializeCog(this.props.elevationData);
-            // this.tileSize = this.terrainCogTiles.getTileSize(cog);
-            const zoomRange = this.state.terrainCogTiles.getZoomRange();
-            const [minZoom, maxZoom] = zoomRange;
-            this.setState({ initialized: true, minZoom, maxZoom });
-        });
+    async init() {
+        await this.state.terrainCogTiles.initializeCog(this.props.elevationData);
+        // this.tileSize = this.terrainCogTiles.getTileSize(cog);
+        const zoomRange = this.state.terrainCogTiles.getZoomRange();
+        const [minZoom, maxZoom] = zoomRange;
+        this.setState({ initialized: true, minZoom, maxZoom });
     }
     updateState({ props, oldProps }) {
         const elevationDataChanged = props.elevationData !== oldProps.elevationData;
@@ -6151,8 +6080,6 @@ class TerrainLayer extends CompositeLayer {
             || props.elevationDecoder !== oldProps.elevationDecoder
             || props.bounds !== oldProps.bounds;
         if (!this.state.isTiled && shouldReload) ;
-        // TODO - remove in v9
-        // @ts-ignore
         if (props.workerUrl) {
             log.removed('workerUrl', 'loadOptions.terrain.workerUrl')();
         }
@@ -6162,36 +6089,47 @@ class TerrainLayer extends CompositeLayer {
             return null;
         }
         let loadOptions = this.getLoadOptions();
-        loadOptions = Object.assign(Object.assign({}, loadOptions), { _workerType: 'test', terrain: Object.assign(Object.assign({ skirtHeight: this.state.isTiled ? meshMaxError * 2 : 0 }, loadOptions === null || loadOptions === void 0 ? void 0 : loadOptions.terrain), { bounds,
+        loadOptions = {
+            ...loadOptions,
+            _workerType: 'test',
+            terrain: {
+                skirtHeight: this.state.isTiled ? meshMaxError * 2 : 0,
+                ...loadOptions?.terrain,
+                bounds,
                 meshMaxError,
-                elevationDecoder }) });
+                elevationDecoder,
+            },
+        };
         const { fetch } = this.props;
         return fetch(elevationData, {
             propName: 'elevationData', layer: this, loadOptions, signal, loaders: [],
         });
     }
-    getTiledTerrainData(tile) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.props;
-            const { viewport } = this.context;
-            let bottomLeft = [0, 0];
-            let topRight = [0, 0];
-            if (viewport.isGeospatial) {
-                const bbox = tile.bbox;
-                bottomLeft = viewport.projectFlat([bbox.west, bbox.south]);
-                topRight = viewport.projectFlat([bbox.east, bbox.north]);
-            }
-            else {
-                const bbox = tile.bbox;
-                bottomLeft = [bbox.left, bbox.bottom];
-                topRight = [bbox.right, bbox.top];
-            }
-            const bounds = [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]];
-            // TODO - pass signal to getTile
-            // abort request if signal is aborted
-            const terrain = yield this.state.terrainCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z, bounds, this.props.meshMaxError);
-            return Promise.all([terrain]);
-        });
+    async getTiledTerrainData(tile) {
+        // const {
+        //   elevationData, fetch, texture, elevationDecoder, meshMaxError,
+        // } = this.props;
+        const { viewport } = this.context;
+        // const dataUrl = getURLFromTemplate(elevationData, tile);
+        // const textureUrl = texture && getURLFromTemplate(texture, tile);
+        // const { signal } = tile;
+        let bottomLeft = [0, 0];
+        let topRight = [0, 0];
+        if (viewport.isGeospatial) {
+            const bbox = tile.bbox;
+            bottomLeft = viewport.projectFlat([bbox.west, bbox.south]);
+            topRight = viewport.projectFlat([bbox.east, bbox.north]);
+        }
+        else {
+            const bbox = tile.bbox;
+            bottomLeft = [bbox.left, bbox.bottom];
+            topRight = [bbox.right, bbox.top];
+        }
+        const bounds = [bottomLeft[0], bottomLeft[1], topRight[0], topRight[1]];
+        // TODO - pass signal to getTile
+        // abort request if signal is aborted
+        const terrain = await this.state.terrainCogTiles.getTile(tile.index.x, tile.index.y, tile.index.z, bounds, this.props.meshMaxError);
+        return Promise.all([terrain, null]);
     }
     renderSubLayers(props) {
         const SubLayerClass = this.getSubLayerClass('mesh', SimpleMeshLayer);
@@ -6202,13 +6140,13 @@ class TerrainLayer extends CompositeLayer {
         }
         // const [mesh, texture] = data;
         const [mesh] = data;
-        return new SubLayerClass(Object.assign(Object.assign({}, props), { tileSize: 256 }), {
+        return new SubLayerClass({ ...props, tileSize: 256 }, {
             data: DUMMY_DATA,
             mesh,
             // texture,
             _instanced: false,
             coordinateSystem: COORDINATE_SYSTEM.CARTESIAN,
-            getPosition: (d) => [0, 0, 0],
+            // getPosition: (d) => [0, 0, 0],
             getColor: color,
             wireframe,
             material,
@@ -6224,10 +6162,9 @@ class TerrainLayer extends CompositeLayer {
             .map((tile) => tile.content)
             .filter((x) => x && x[0])
             .map((arr) => {
-            var _a, _b;
-            // @ts-ignore
-            const bounds = (_b = (_a = arr[0]) === null || _a === void 0 ? void 0 : _a.header) === null || _b === void 0 ? void 0 : _b.boundingBox;
-            return bounds === null || bounds === void 0 ? void 0 : bounds.map((bound) => bound[2]);
+            // @ts-expect-error: Tile content structure is not fully typed in the source layer
+            const bounds = arr[0]?.header?.boundingBox;
+            return bounds?.map((bound) => bound[2]);
         });
         if (ranges.length === 0) {
             return;
@@ -6239,7 +6176,13 @@ class TerrainLayer extends CompositeLayer {
         }
     }
     renderLayers() {
-        const { color, material, elevationData, texture, wireframe, meshMaxError, elevationDecoder, tileSize, extent, maxRequests, onTileLoad, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy, } = this.props;
+        const { 
+        // color,
+        // material,
+        elevationData, 
+        // texture,
+        // wireframe,
+        meshMaxError, elevationDecoder, tileSize, extent, maxRequests, onTileLoad, onTileUnload, onTileError, maxCacheSize, maxCacheByteSize, refinementStrategy, } = this.props;
         if (this.state.isTiled && this.state.initialized) {
             return new TileLayer(this.getSubLayerProps({
                 id: 'tiles',
@@ -6290,15 +6233,6 @@ class TerrainLayer extends CompositeLayer {
         // );
     }
 }
-TerrainLayer.defaultProps = defaultProps;
-TerrainLayer.layerName = 'TerrainLayer';
-
-var index = {
-    CogBitmapLayer,
-    CogTerrainLayer: TerrainLayer,
-    cogtiles: CogTiles,
-    GeoImage,
-};
 
 class RawDecoder extends BaseDecoder {
   decodeBlock(buffer) {
@@ -6307,8 +6241,8 @@ class RawDecoder extends BaseDecoder {
 }
 
 var raw = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: RawDecoder
+  __proto__: null,
+  default: RawDecoder
 });
 
 const MIN_BITS = 9;
@@ -6442,8 +6376,8 @@ class LZWDecoder extends BaseDecoder {
 }
 
 var lzw = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: LZWDecoder
+  __proto__: null,
+  default: LZWDecoder
 });
 
 /* -*- tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- /
@@ -7341,8 +7275,8 @@ class JpegDecoder extends BaseDecoder {
 }
 
 var jpeg = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: JpegDecoder
+  __proto__: null,
+  default: JpegDecoder
 });
 
 /*! pako 2.1.0 https://github.com/nodeca/pako @license (MIT AND Zlib) */
@@ -14113,8 +14047,8 @@ class DeflateDecoder extends BaseDecoder {
 }
 
 var deflate = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: DeflateDecoder
+  __proto__: null,
+  default: DeflateDecoder
 });
 
 class PackbitsDecoder extends BaseDecoder {
@@ -14143,8 +14077,8 @@ class PackbitsDecoder extends BaseDecoder {
 }
 
 var packbits = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: PackbitsDecoder
+  __proto__: null,
+  default: PackbitsDecoder
 });
 
 var LercDecode = {exports: {}};
@@ -16587,9 +16521,9 @@ class LercDecoder extends BaseDecoder {
 }
 
 var lerc = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: LercDecoder,
-    zstd: zstd
+  __proto__: null,
+  default: LercDecoder,
+  zstd: zstd
 });
 
 /**
@@ -16632,9 +16566,9 @@ class WebImageDecoder extends BaseDecoder {
 }
 
 var webimage = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    default: WebImageDecoder
+  __proto__: null,
+  default: WebImageDecoder
 });
 
-export { index as default };
+export { CogBitmapLayer, CogTerrainLayer, CogTiles, GeoImage };
 //# sourceMappingURL=index.js.map