@loaders.gl/terrain 3.4.11 → 3.4.12

package/dist/es5/lib/utils/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VERSION = void 0;
-var VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+var VERSION = typeof "3.4.12" !== 'undefined' ? "3.4.12" : 'latest';
 exports.VERSION = VERSION;
 //# sourceMappingURL=version.js.map

package/dist/esm/lib/utils/version.js

@@ -1,2 +1,2 @@
-export const VERSION = typeof "3.4.11" !== 'undefined' ? "3.4.11" : 'latest';
+export const VERSION = typeof "3.4.12" !== 'undefined' ? "3.4.12" : 'latest';
 //# sourceMappingURL=version.js.map

package/dist/quantized-mesh-worker.js

@@ -1193,7 +1193,7 @@
   }
 
   // src/lib/utils/version.ts
-  var VERSION = true ? "3.4.11" : "latest";
+  var VERSION = true ? "3.4.12" : "latest";
 
   // src/terrain-loader.ts
   var TerrainLoader = {

package/dist/terrain-worker.js

@@ -1193,7 +1193,7 @@
   }
 
   // src/lib/utils/version.ts
-  var VERSION = true ? "3.4.11" : "latest";
+  var VERSION = true ? "3.4.12" : "latest";
 
   // src/terrain-loader.ts
   var TerrainLoader = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/terrain",
-  "version": "3.4.11",
+  "version": "3.4.12",
   "description": "Framework-independent loader for terrain raster formats",
   "license": "MIT",
   "publishConfig": {
@@ -35,10 +35,10 @@
   },
   "dependencies": {
     "@babel/runtime": "^7.3.1",
-    "@loaders.gl/images": "3.4.11",
-    "@loaders.gl/loader-utils": "3.4.11",
-    "@loaders.gl/schema": "3.4.11",
+    "@loaders.gl/images": "3.4.12",
+    "@loaders.gl/loader-utils": "3.4.12",
+    "@loaders.gl/schema": "3.4.12",
     "@mapbox/martini": "^0.2.0"
   },
-  "gitHead": "2b8d490d2372e70dd89eef8f6b215a5205c16621"
+  "gitHead": "85254762ae3082f608a863291deef09f2b40c6cf"
 }

package/dist/bundle.js

@@ -1,5 +0,0 @@
-"use strict";
-// @ts-nocheck
-const moduleExports = require('./index');
-globalThis.loaders = globalThis.loaders || {};
-module.exports = Object.assign(globalThis.loaders, moduleExports);

package/dist/index.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader = exports.QuantizedMeshWorkerLoader = exports._typecheckTerrainLoader = exports.TerrainLoader = exports.TerrainWorkerLoader = void 0;
-const parse_quantized_mesh_1 = __importDefault(require("./lib/parse-quantized-mesh"));
-const parse_terrain_1 = __importDefault(require("./lib/parse-terrain"));
-const terrain_loader_1 = require("./terrain-loader");
-Object.defineProperty(exports, "TerrainWorkerLoader", { enumerable: true, get: function () { return terrain_loader_1.TerrainLoader; } });
-const quantized_mesh_loader_1 = require("./quantized-mesh-loader");
-Object.defineProperty(exports, "QuantizedMeshWorkerLoader", { enumerable: true, get: function () { return quantized_mesh_loader_1.QuantizedMeshLoader; } });
-exports.TerrainLoader = {
-    ...terrain_loader_1.TerrainLoader,
-    parse: parse_terrain_1.default
-};
-exports._typecheckTerrainLoader = exports.TerrainLoader; // eslint-disable-line
-/**
- * Loader for quantized meshes
- */
-exports.QuantizedMeshLoader = {
-    ...quantized_mesh_loader_1.QuantizedMeshLoader,
-    parseSync: parse_quantized_mesh_1.default,
-    parse: async (arrayBuffer, options) => (0, parse_quantized_mesh_1.default)(arrayBuffer, options)
-};
-exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader;

package/dist/lib/decode-quantized-mesh.js

@@ -1,227 +0,0 @@
-"use strict";
-// Copyright (C) 2018-2019 HERE Europe B.V.
-//
-// 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.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DECODING_STEPS = void 0;
-const QUANTIZED_MESH_HEADER = new Map([
-    ['centerX', Float64Array.BYTES_PER_ELEMENT],
-    ['centerY', Float64Array.BYTES_PER_ELEMENT],
-    ['centerZ', Float64Array.BYTES_PER_ELEMENT],
-    ['minHeight', Float32Array.BYTES_PER_ELEMENT],
-    ['maxHeight', Float32Array.BYTES_PER_ELEMENT],
-    ['boundingSphereCenterX', Float64Array.BYTES_PER_ELEMENT],
-    ['boundingSphereCenterY', Float64Array.BYTES_PER_ELEMENT],
-    ['boundingSphereCenterZ', Float64Array.BYTES_PER_ELEMENT],
-    ['boundingSphereRadius', Float64Array.BYTES_PER_ELEMENT],
-    ['horizonOcclusionPointX', Float64Array.BYTES_PER_ELEMENT],
-    ['horizonOcclusionPointY', Float64Array.BYTES_PER_ELEMENT],
-    ['horizonOcclusionPointZ', Float64Array.BYTES_PER_ELEMENT]
-]);
-function decodeZigZag(value) {
-    return (value >> 1) ^ -(value & 1);
-}
-function decodeHeader(dataView) {
-    let position = 0;
-    const header = {};
-    for (const [key, bytesCount] of QUANTIZED_MESH_HEADER) {
-        const getter = bytesCount === 8 ? dataView.getFloat64 : dataView.getFloat32;
-        header[key] = getter.call(dataView, position, true);
-        position += bytesCount;
-    }
-    return { header, headerEndPosition: position };
-}
-function decodeVertexData(dataView, headerEndPosition) {
-    let position = headerEndPosition;
-    const elementsPerVertex = 3;
-    const vertexCount = dataView.getUint32(position, true);
-    const vertexData = new Uint16Array(vertexCount * elementsPerVertex);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    const bytesPerArrayElement = Uint16Array.BYTES_PER_ELEMENT;
-    const elementArrayLength = vertexCount * bytesPerArrayElement;
-    const uArrayStartPosition = position;
-    const vArrayStartPosition = uArrayStartPosition + elementArrayLength;
-    const heightArrayStartPosition = vArrayStartPosition + elementArrayLength;
-    let u = 0;
-    let v = 0;
-    let height = 0;
-    for (let i = 0; i < vertexCount; i++) {
-        u += decodeZigZag(dataView.getUint16(uArrayStartPosition + bytesPerArrayElement * i, true));
-        v += decodeZigZag(dataView.getUint16(vArrayStartPosition + bytesPerArrayElement * i, true));
-        height += decodeZigZag(dataView.getUint16(heightArrayStartPosition + bytesPerArrayElement * i, true));
-        vertexData[i] = u;
-        vertexData[i + vertexCount] = v;
-        vertexData[i + vertexCount * 2] = height;
-    }
-    position += elementArrayLength * 3;
-    return { vertexData, vertexDataEndPosition: position };
-}
-function decodeIndex(buffer, position, indicesCount, bytesPerIndex, encoded = true) {
-    let indices;
-    if (bytesPerIndex === 2) {
-        indices = new Uint16Array(buffer, position, indicesCount);
-    }
-    else {
-        indices = new Uint32Array(buffer, position, indicesCount);
-    }
-    if (!encoded) {
-        return indices;
-    }
-    let highest = 0;
-    for (let i = 0; i < indices.length; ++i) {
-        const code = indices[i];
-        indices[i] = highest - code;
-        if (code === 0) {
-            ++highest;
-        }
-    }
-    return indices;
-}
-function decodeTriangleIndices(dataView, vertexData, vertexDataEndPosition) {
-    let position = vertexDataEndPosition;
-    const elementsPerVertex = 3;
-    const vertexCount = vertexData.length / elementsPerVertex;
-    const bytesPerIndex = vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
-    if (position % bytesPerIndex !== 0) {
-        position += bytesPerIndex - (position % bytesPerIndex);
-    }
-    const triangleCount = dataView.getUint32(position, true);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    const triangleIndicesCount = triangleCount * 3;
-    const triangleIndices = decodeIndex(dataView.buffer, position, triangleIndicesCount, bytesPerIndex);
-    position += triangleIndicesCount * bytesPerIndex;
-    return {
-        triangleIndicesEndPosition: position,
-        triangleIndices
-    };
-}
-function decodeEdgeIndices(dataView, vertexData, triangleIndicesEndPosition) {
-    let position = triangleIndicesEndPosition;
-    const elementsPerVertex = 3;
-    const vertexCount = vertexData.length / elementsPerVertex;
-    const bytesPerIndex = vertexCount > 65536 ? Uint32Array.BYTES_PER_ELEMENT : Uint16Array.BYTES_PER_ELEMENT;
-    const westVertexCount = dataView.getUint32(position, true);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    const westIndices = decodeIndex(dataView.buffer, position, westVertexCount, bytesPerIndex, false);
-    position += westVertexCount * bytesPerIndex;
-    const southVertexCount = dataView.getUint32(position, true);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    const southIndices = decodeIndex(dataView.buffer, position, southVertexCount, bytesPerIndex, false);
-    position += southVertexCount * bytesPerIndex;
-    const eastVertexCount = dataView.getUint32(position, true);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    const eastIndices = decodeIndex(dataView.buffer, position, eastVertexCount, bytesPerIndex, false);
-    position += eastVertexCount * bytesPerIndex;
-    const northVertexCount = dataView.getUint32(position, true);
-    position += Uint32Array.BYTES_PER_ELEMENT;
-    const northIndices = decodeIndex(dataView.buffer, position, northVertexCount, bytesPerIndex, false);
-    position += northVertexCount * bytesPerIndex;
-    return {
-        edgeIndicesEndPosition: position,
-        westIndices,
-        southIndices,
-        eastIndices,
-        northIndices
-    };
-}
-function decodeVertexNormalsExtension(extensionDataView) {
-    return new Uint8Array(extensionDataView.buffer, extensionDataView.byteOffset, extensionDataView.byteLength);
-}
-function decodeWaterMaskExtension(extensionDataView) {
-    return extensionDataView.buffer.slice(extensionDataView.byteOffset, extensionDataView.byteOffset + extensionDataView.byteLength);
-}
-function decodeExtensions(dataView, indicesEndPosition) {
-    const extensions = {};
-    if (dataView.byteLength <= indicesEndPosition) {
-        return { extensions, extensionsEndPosition: indicesEndPosition };
-    }
-    let position = indicesEndPosition;
-    while (position < dataView.byteLength) {
-        const extensionId = dataView.getUint8(position, true);
-        position += Uint8Array.BYTES_PER_ELEMENT;
-        const extensionLength = dataView.getUint32(position, true);
-        position += Uint32Array.BYTES_PER_ELEMENT;
-        const extensionView = new DataView(dataView.buffer, position, extensionLength);
-        switch (extensionId) {
-            case 1: {
-                extensions.vertexNormals = decodeVertexNormalsExtension(extensionView);
-                break;
-            }
-            case 2: {
-                extensions.waterMask = decodeWaterMaskExtension(extensionView);
-                break;
-            }
-            default: {
-                // console.warn(`Unknown extension with id ${extensionId}`)
-            }
-        }
-        position += extensionLength;
-    }
-    return { extensions, extensionsEndPosition: position };
-}
-exports.DECODING_STEPS = {
-    header: 0,
-    vertices: 1,
-    triangleIndices: 2,
-    edgeIndices: 3,
-    extensions: 4
-};
-const DEFAULT_OPTIONS = {
-    maxDecodingStep: exports.DECODING_STEPS.extensions
-};
-function decode(data, userOptions) {
-    const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);
-    const view = new DataView(data);
-    const { header, headerEndPosition } = decodeHeader(view);
-    if (options.maxDecodingStep < exports.DECODING_STEPS.vertices) {
-        return { header };
-    }
-    const { vertexData, vertexDataEndPosition } = decodeVertexData(view, headerEndPosition);
-    if (options.maxDecodingStep < exports.DECODING_STEPS.triangleIndices) {
-        return { header, vertexData };
-    }
-    const { triangleIndices, triangleIndicesEndPosition } = decodeTriangleIndices(view, vertexData, vertexDataEndPosition);
-    if (options.maxDecodingStep < exports.DECODING_STEPS.edgeIndices) {
-        return { header, vertexData, triangleIndices };
-    }
-    const { westIndices, southIndices, eastIndices, northIndices, edgeIndicesEndPosition } = decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);
-    if (options.maxDecodingStep < exports.DECODING_STEPS.extensions) {
-        return {
-            header,
-            vertexData,
-            triangleIndices,
-            westIndices,
-            northIndices,
-            eastIndices,
-            southIndices
-        };
-    }
-    const { extensions } = decodeExtensions(view, edgeIndicesEndPosition);
-    return {
-        header,
-        vertexData,
-        triangleIndices,
-        westIndices,
-        northIndices,
-        eastIndices,
-        southIndices,
-        extensions
-    };
-}
-exports.default = decode;

package/dist/lib/delatin/index.js

@@ -1,418 +0,0 @@
-"use strict";
-// ISC License
-Object.defineProperty(exports, "__esModule", { value: true });
-// Copyright(c) 2019, Michael Fogleman, Vladimir Agafonkin
-// Permission to use, copy, modify, and / or distribute this software for any purpose
-// with or without fee is hereby granted, provided that the above copyright notice
-// and this permission notice appear in all copies.
-// 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.
-// @ts-nocheck
-/* eslint-disable complexity, max-params, max-statements, max-depth, no-constant-condition */
-class Delatin {
-    constructor(data, width, height = width) {
-        this.data = data; // height data
-        this.width = width;
-        this.height = height;
-        this.coords = []; // vertex coordinates (x, y)
-        this.triangles = []; // mesh triangle indices
-        // additional triangle data
-        this._halfedges = [];
-        this._candidates = [];
-        this._queueIndices = [];
-        this._queue = []; // queue of added triangles
-        this._errors = [];
-        this._rms = [];
-        this._pending = []; // triangles pending addition to queue
-        this._pendingLen = 0;
-        this._rmsSum = 0;
-        const x1 = width - 1;
-        const y1 = height - 1;
-        const p0 = this._addPoint(0, 0);
-        const p1 = this._addPoint(x1, 0);
-        const p2 = this._addPoint(0, y1);
-        const p3 = this._addPoint(x1, y1);
-        // add initial two triangles
-        const t0 = this._addTriangle(p3, p0, p2, -1, -1, -1);
-        this._addTriangle(p0, p3, p1, t0, -1, -1);
-        this._flush();
-    }
-    // refine the mesh until its maximum error gets below the given one
-    run(maxError = 1) {
-        while (this.getMaxError() > maxError) {
-            this.refine();
-        }
-    }
-    // refine the mesh with a single point
-    refine() {
-        this._step();
-        this._flush();
-    }
-    // max error of the current mesh
-    getMaxError() {
-        return this._errors[0];
-    }
-    // root-mean-square deviation of the current mesh
-    getRMSD() {
-        return this._rmsSum > 0 ? Math.sqrt(this._rmsSum / (this.width * this.height)) : 0;
-    }
-    // height value at a given position
-    heightAt(x, y) {
-        return this.data[this.width * y + x];
-    }
-    // rasterize and queue all triangles that got added or updated in _step
-    _flush() {
-        const coords = this.coords;
-        for (let i = 0; i < this._pendingLen; i++) {
-            const t = this._pending[i];
-            // rasterize triangle to find maximum pixel error
-            const a = 2 * this.triangles[t * 3 + 0];
-            const b = 2 * this.triangles[t * 3 + 1];
-            const c = 2 * this.triangles[t * 3 + 2];
-            this._findCandidate(coords[a], coords[a + 1], coords[b], coords[b + 1], coords[c], coords[c + 1], t);
-        }
-        this._pendingLen = 0;
-    }
-    // rasterize a triangle, find its max error, and queue it for processing
-    _findCandidate(p0x, p0y, p1x, p1y, p2x, p2y, t) {
-        // triangle bounding box
-        const minX = Math.min(p0x, p1x, p2x);
-        const minY = Math.min(p0y, p1y, p2y);
-        const maxX = Math.max(p0x, p1x, p2x);
-        const maxY = Math.max(p0y, p1y, p2y);
-        // forward differencing variables
-        let w00 = orient(p1x, p1y, p2x, p2y, minX, minY);
-        let w01 = orient(p2x, p2y, p0x, p0y, minX, minY);
-        let w02 = orient(p0x, p0y, p1x, p1y, minX, minY);
-        const a01 = p1y - p0y;
-        const b01 = p0x - p1x;
-        const a12 = p2y - p1y;
-        const b12 = p1x - p2x;
-        const a20 = p0y - p2y;
-        const b20 = p2x - p0x;
-        // pre-multiplied z values at vertices
-        const a = orient(p0x, p0y, p1x, p1y, p2x, p2y);
-        const z0 = this.heightAt(p0x, p0y) / a;
-        const z1 = this.heightAt(p1x, p1y) / a;
-        const z2 = this.heightAt(p2x, p2y) / a;
-        // iterate over pixels in bounding box
-        let maxError = 0;
-        let mx = 0;
-        let my = 0;
-        let rms = 0;
-        for (let y = minY; y <= maxY; y++) {
-            // compute starting offset
-            let dx = 0;
-            if (w00 < 0 && a12 !== 0) {
-                dx = Math.max(dx, Math.floor(-w00 / a12));
-            }
-            if (w01 < 0 && a20 !== 0) {
-                dx = Math.max(dx, Math.floor(-w01 / a20));
-            }
-            if (w02 < 0 && a01 !== 0) {
-                dx = Math.max(dx, Math.floor(-w02 / a01));
-            }
-            let w0 = w00 + a12 * dx;
-            let w1 = w01 + a20 * dx;
-            let w2 = w02 + a01 * dx;
-            let wasInside = false;
-            for (let x = minX + dx; x <= maxX; x++) {
-                // check if inside triangle
-                if (w0 >= 0 && w1 >= 0 && w2 >= 0) {
-                    wasInside = true;
-                    // compute z using barycentric coordinates
-                    const z = z0 * w0 + z1 * w1 + z2 * w2;
-                    const dz = Math.abs(z - this.heightAt(x, y));
-                    rms += dz * dz;
-                    if (dz > maxError) {
-                        maxError = dz;
-                        mx = x;
-                        my = y;
-                    }
-                }
-                else if (wasInside) {
-                    break;
-                }
-                w0 += a12;
-                w1 += a20;
-                w2 += a01;
-            }
-            w00 += b12;
-            w01 += b20;
-            w02 += b01;
-        }
-        if ((mx === p0x && my === p0y) || (mx === p1x && my === p1y) || (mx === p2x && my === p2y)) {
-            maxError = 0;
-        }
-        // update triangle metadata
-        this._candidates[2 * t] = mx;
-        this._candidates[2 * t + 1] = my;
-        this._rms[t] = rms;
-        // add triangle to priority queue
-        this._queuePush(t, maxError, rms);
-    }
-    // process the next triangle in the queue, splitting it with a new point
-    _step() {
-        // pop triangle with highest error from priority queue
-        const t = this._queuePop();
-        const e0 = t * 3 + 0;
-        const e1 = t * 3 + 1;
-        const e2 = t * 3 + 2;
-        const p0 = this.triangles[e0];
-        const p1 = this.triangles[e1];
-        const p2 = this.triangles[e2];
-        const ax = this.coords[2 * p0];
-        const ay = this.coords[2 * p0 + 1];
-        const bx = this.coords[2 * p1];
-        const by = this.coords[2 * p1 + 1];
-        const cx = this.coords[2 * p2];
-        const cy = this.coords[2 * p2 + 1];
-        const px = this._candidates[2 * t];
-        const py = this._candidates[2 * t + 1];
-        const pn = this._addPoint(px, py);
-        if (orient(ax, ay, bx, by, px, py) === 0) {
-            this._handleCollinear(pn, e0);
-        }
-        else if (orient(bx, by, cx, cy, px, py) === 0) {
-            this._handleCollinear(pn, e1);
-        }
-        else if (orient(cx, cy, ax, ay, px, py) === 0) {
-            this._handleCollinear(pn, e2);
-        }
-        else {
-            const h0 = this._halfedges[e0];
-            const h1 = this._halfedges[e1];
-            const h2 = this._halfedges[e2];
-            const t0 = this._addTriangle(p0, p1, pn, h0, -1, -1, e0);
-            const t1 = this._addTriangle(p1, p2, pn, h1, -1, t0 + 1);
-            const t2 = this._addTriangle(p2, p0, pn, h2, t0 + 2, t1 + 1);
-            this._legalize(t0);
-            this._legalize(t1);
-            this._legalize(t2);
-        }
-    }
-    // add coordinates for a new vertex
-    _addPoint(x, y) {
-        const i = this.coords.length >> 1;
-        this.coords.push(x, y);
-        return i;
-    }
-    // add or update a triangle in the mesh
-    _addTriangle(a, b, c, ab, bc, ca, e = this.triangles.length) {
-        const t = e / 3; // new triangle index
-        // add triangle vertices
-        this.triangles[e + 0] = a;
-        this.triangles[e + 1] = b;
-        this.triangles[e + 2] = c;
-        // add triangle halfedges
-        this._halfedges[e + 0] = ab;
-        this._halfedges[e + 1] = bc;
-        this._halfedges[e + 2] = ca;
-        // link neighboring halfedges
-        if (ab >= 0) {
-            this._halfedges[ab] = e + 0;
-        }
-        if (bc >= 0) {
-            this._halfedges[bc] = e + 1;
-        }
-        if (ca >= 0) {
-            this._halfedges[ca] = e + 2;
-        }
-        // init triangle metadata
-        this._candidates[2 * t + 0] = 0;
-        this._candidates[2 * t + 1] = 0;
-        this._queueIndices[t] = -1;
-        this._rms[t] = 0;
-        // add triangle to pending queue for later rasterization
-        this._pending[this._pendingLen++] = t;
-        // return first halfedge index
-        return e;
-    }
-    _legalize(a) {
-        // if the pair of triangles doesn't satisfy the Delaunay condition
-        // (p1 is inside the circumcircle of [p0, pl, pr]), flip them,
-        // then do the same check/flip recursively for the new pair of triangles
-        //
-        //           pl                    pl
-        //          /||\                  /  \
-        //       al/ || \bl            al/    \a
-        //        /  ||  \              /      \
-        //       /  a||b  \    flip    /___ar___\
-        //     p0\   ||   /p1   =>   p0\---bl---/p1
-        //        \  ||  /              \      /
-        //       ar\ || /br             b\    /br
-        //          \||/                  \  /
-        //           pr                    pr
-        const b = this._halfedges[a];
-        if (b < 0) {
-            return;
-        }
-        const a0 = a - (a % 3);
-        const b0 = b - (b % 3);
-        const al = a0 + ((a + 1) % 3);
-        const ar = a0 + ((a + 2) % 3);
-        const bl = b0 + ((b + 2) % 3);
-        const br = b0 + ((b + 1) % 3);
-        const p0 = this.triangles[ar];
-        const pr = this.triangles[a];
-        const pl = this.triangles[al];
-        const p1 = this.triangles[bl];
-        const coords = this.coords;
-        if (!inCircle(coords[2 * p0], coords[2 * p0 + 1], coords[2 * pr], coords[2 * pr + 1], coords[2 * pl], coords[2 * pl + 1], coords[2 * p1], coords[2 * p1 + 1])) {
-            return;
-        }
-        const hal = this._halfedges[al];
-        const har = this._halfedges[ar];
-        const hbl = this._halfedges[bl];
-        const hbr = this._halfedges[br];
-        this._queueRemove(a0 / 3);
-        this._queueRemove(b0 / 3);
-        const t0 = this._addTriangle(p0, p1, pl, -1, hbl, hal, a0);
-        const t1 = this._addTriangle(p1, p0, pr, t0, har, hbr, b0);
-        this._legalize(t0 + 1);
-        this._legalize(t1 + 2);
-    }
-    // handle a case where new vertex is on the edge of a triangle
-    _handleCollinear(pn, a) {
-        const a0 = a - (a % 3);
-        const al = a0 + ((a + 1) % 3);
-        const ar = a0 + ((a + 2) % 3);
-        const p0 = this.triangles[ar];
-        const pr = this.triangles[a];
-        const pl = this.triangles[al];
-        const hal = this._halfedges[al];
-        const har = this._halfedges[ar];
-        const b = this._halfedges[a];
-        if (b < 0) {
-            const t0 = this._addTriangle(pn, p0, pr, -1, har, -1, a0);
-            const t1 = this._addTriangle(p0, pn, pl, t0, -1, hal);
-            this._legalize(t0 + 1);
-            this._legalize(t1 + 2);
-            return;
-        }
-        const b0 = b - (b % 3);
-        const bl = b0 + ((b + 2) % 3);
-        const br = b0 + ((b + 1) % 3);
-        const p1 = this.triangles[bl];
-        const hbl = this._halfedges[bl];
-        const hbr = this._halfedges[br];
-        this._queueRemove(b0 / 3);
-        const t0 = this._addTriangle(p0, pr, pn, har, -1, -1, a0);
-        const t1 = this._addTriangle(pr, p1, pn, hbr, -1, t0 + 1, b0);
-        const t2 = this._addTriangle(p1, pl, pn, hbl, -1, t1 + 1);
-        const t3 = this._addTriangle(pl, p0, pn, hal, t0 + 2, t2 + 1);
-        this._legalize(t0);
-        this._legalize(t1);
-        this._legalize(t2);
-        this._legalize(t3);
-    }
-    // priority queue methods
-    _queuePush(t, error, rms) {
-        const i = this._queue.length;
-        this._queueIndices[t] = i;
-        this._queue.push(t);
-        this._errors.push(error);
-        this._rmsSum += rms;
-        this._queueUp(i);
-    }
-    _queuePop() {
-        const n = this._queue.length - 1;
-        this._queueSwap(0, n);
-        this._queueDown(0, n);
-        return this._queuePopBack();
-    }
-    _queuePopBack() {
-        const t = this._queue.pop();
-        this._errors.pop();
-        this._rmsSum -= this._rms[t];
-        this._queueIndices[t] = -1;
-        return t;
-    }
-    _queueRemove(t) {
-        const i = this._queueIndices[t];
-        if (i < 0) {
-            const it = this._pending.indexOf(t);
-            if (it !== -1) {
-                this._pending[it] = this._pending[--this._pendingLen];
-            }
-            else {
-                throw new Error('Broken triangulation (something went wrong).');
-            }
-            return;
-        }
-        const n = this._queue.length - 1;
-        if (n !== i) {
-            this._queueSwap(i, n);
-            if (!this._queueDown(i, n)) {
-                this._queueUp(i);
-            }
-        }
-        this._queuePopBack();
-    }
-    _queueLess(i, j) {
-        return this._errors[i] > this._errors[j];
-    }
-    _queueSwap(i, j) {
-        const pi = this._queue[i];
-        const pj = this._queue[j];
-        this._queue[i] = pj;
-        this._queue[j] = pi;
-        this._queueIndices[pi] = j;
-        this._queueIndices[pj] = i;
-        const e = this._errors[i];
-        this._errors[i] = this._errors[j];
-        this._errors[j] = e;
-    }
-    _queueUp(j0) {
-        let j = j0;
-        while (true) {
-            const i = (j - 1) >> 1;
-            if (i === j || !this._queueLess(j, i)) {
-                break;
-            }
-            this._queueSwap(i, j);
-            j = i;
-        }
-    }
-    _queueDown(i0, n) {
-        let i = i0;
-        while (true) {
-            const j1 = 2 * i + 1;
-            if (j1 >= n || j1 < 0) {
-                break;
-            }
-            const j2 = j1 + 1;
-            let j = j1;
-            if (j2 < n && this._queueLess(j2, j1)) {
-                j = j2;
-            }
-            if (!this._queueLess(j, i)) {
-                break;
-            }
-            this._queueSwap(i, j);
-            i = j;
-        }
-        return i > i0;
-    }
-}
-exports.default = Delatin;
-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;
-    const ex = bx - px;
-    const ey = by - py;
-    const fx = cx - px;
-    const fy = cy - py;
-    const ap = dx * dx + dy * dy;
-    const bp = ex * ex + ey * ey;
-    const cp = fx * fx + fy * fy;
-    return dx * (ey * cp - bp * fy) - dy * (ex * cp - bp * fx) + ap * (ex * fy - ey * fx) < 0;
-}

package/dist/lib/helpers/skirt.js

@@ -1,127 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.addSkirt = void 0;
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-/**
- * Add skirt to existing mesh
- * @param {object} attributes - POSITION and TEXCOOD_0 attributes data
- * @param {any} triangles - indices array of the mesh geometry
- * @param skirtHeight - height of the skirt geometry
- * @param outsideIndices - edge indices from quantized mesh data
- * @returns - geometry data with added skirt
- */
-function addSkirt(attributes, triangles, skirtHeight, outsideIndices) {
-    const outsideEdges = outsideIndices
-        ? getOutsideEdgesFromIndices(outsideIndices, attributes.POSITION.value)
-        : getOutsideEdgesFromTriangles(triangles);
-    // 2 new vertices for each outside edge
-    const newPosition = new attributes.POSITION.value.constructor(outsideEdges.length * 6);
-    const newTexcoord0 = new attributes.TEXCOORD_0.value.constructor(outsideEdges.length * 4);
-    // 2 new triangles for each outside edge
-    const newTriangles = new triangles.constructor(outsideEdges.length * 6);
-    for (let i = 0; i < outsideEdges.length; i++) {
-        const edge = outsideEdges[i];
-        updateAttributesForNewEdge({
-            edge,
-            edgeIndex: i,
-            attributes,
-            skirtHeight,
-            newPosition,
-            newTexcoord0,
-            newTriangles
-        });
-    }
-    attributes.POSITION.value = (0, loader_utils_1.concatenateTypedArrays)(attributes.POSITION.value, newPosition);
-    attributes.TEXCOORD_0.value = (0, loader_utils_1.concatenateTypedArrays)(attributes.TEXCOORD_0.value, newTexcoord0);
-    const resultTriangles = triangles instanceof Array
-        ? triangles.concat(newTriangles)
-        : (0, loader_utils_1.concatenateTypedArrays)(triangles, newTriangles);
-    return {
-        attributes,
-        triangles: resultTriangles
-    };
-}
-exports.addSkirt = addSkirt;
-/**
- * Get geometry edges that located on a border of the mesh
- * @param {any} triangles - indices array of the mesh geometry
- * @returns {number[][]} - outside edges data
- */
-function getOutsideEdgesFromTriangles(triangles) {
-    const edges = [];
-    for (let i = 0; i < triangles.length; i += 3) {
-        edges.push([triangles[i], triangles[i + 1]]);
-        edges.push([triangles[i + 1], triangles[i + 2]]);
-        edges.push([triangles[i + 2], triangles[i]]);
-    }
-    edges.sort((a, b) => Math.min(...a) - Math.min(...b) || Math.max(...a) - Math.max(...b));
-    const outsideEdges = [];
-    let index = 0;
-    while (index < edges.length) {
-        if (edges[index][0] === edges[index + 1]?.[1] && edges[index][1] === edges[index + 1]?.[0]) {
-            index += 2;
-        }
-        else {
-            outsideEdges.push(edges[index]);
-            index++;
-        }
-    }
-    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
- * @param {number[]} args.edge - edge indices in geometry
- * @param {number} args.edgeIndex - edge index in outsideEdges array
- * @param {object} args.attributes - POSITION and TEXCOORD_0 attributes
- * @param {number} args.skirtHeight - height of the skirt geometry
- * @param {TypedArray} args.newPosition - POSITION array for skirt data
- * @param {TypedArray} args.newTexcoord0 - TEXCOORD_0 array for skirt data
- * @param {TypedArray | Array} args.newTriangles - trinagle indices array for skirt data
- * @returns {void}
- */
-function updateAttributesForNewEdge({ edge, edgeIndex, attributes, skirtHeight, newPosition, newTexcoord0, newTriangles }) {
-    const positionsLength = attributes.POSITION.value.length;
-    const vertex1Offset = edgeIndex * 2;
-    const vertex2Offset = edgeIndex * 2 + 1;
-    // Define POSITION for new 1st vertex
-    newPosition.set(attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3), vertex1Offset * 3);
-    newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
-    // Define POSITION for new 2nd vertex
-    newPosition.set(attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3), vertex2Offset * 3);
-    newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight; // put down elevation on the skirt height
-    // Use same TEXCOORDS for skirt vertices
-    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[0] * 2, edge[0] * 2 + 2), vertex1Offset * 2);
-    newTexcoord0.set(attributes.TEXCOORD_0.value.subarray(edge[1] * 2, edge[1] * 2 + 2), vertex2Offset * 2);
-    // Define new triangles
-    const triangle1Offset = edgeIndex * 2 * 3;
-    newTriangles[triangle1Offset] = edge[0];
-    newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
-    newTriangles[triangle1Offset + 2] = edge[1];
-    newTriangles[triangle1Offset + 3] = positionsLength / 3 + vertex2Offset;
-    newTriangles[triangle1Offset + 4] = edge[0];
-    newTriangles[triangle1Offset + 5] = positionsLength / 3 + vertex1Offset;
-}

package/dist/lib/parse-quantized-mesh.js

@@ -1,99 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("@loaders.gl/schema");
-const decode_quantized_mesh_1 = __importStar(require("./decode-quantized-mesh"));
-const skirt_1 = require("./helpers/skirt");
-function getMeshAttributes(vertexData, header, bounds) {
-    const { minHeight, maxHeight } = header;
-    const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
-    const xScale = maxX - minX;
-    const yScale = maxY - minY;
-    const zScale = maxHeight - minHeight;
-    const nCoords = vertexData.length / 3;
-    // vec3. x, y defined by bounds, z in meters
-    const positions = new Float32Array(nCoords * 3);
-    // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
-    const texCoords = new Float32Array(nCoords * 2);
-    // Data is not interleaved; all u, then all v, then all heights
-    for (let i = 0; i < nCoords; i++) {
-        const x = vertexData[i] / 32767;
-        const y = vertexData[i + nCoords] / 32767;
-        const z = vertexData[i + nCoords * 2] / 32767;
-        positions[3 * i + 0] = x * xScale + minX;
-        positions[3 * i + 1] = y * yScale + minY;
-        positions[3 * i + 2] = z * zScale + minHeight;
-        texCoords[2 * i + 0] = x;
-        texCoords[2 * i + 1] = y;
-    }
-    return {
-        POSITION: { value: positions, size: 3 },
-        TEXCOORD_0: { value: texCoords, size: 2 }
-        // TODO: Parse normals if they exist in the file
-        // NORMAL: {}, - optional, but creates the high poly look with lighting
-    };
-}
-function getTileMesh(arrayBuffer, options) {
-    if (!arrayBuffer) {
-        return null;
-    }
-    const { bounds } = options;
-    // Don't parse edge indices or format extensions
-    const { header, vertexData, triangleIndices: originalTriangleIndices, westIndices, northIndices, eastIndices, southIndices } = (0, decode_quantized_mesh_1.default)(arrayBuffer, decode_quantized_mesh_1.DECODING_STEPS.triangleIndices);
-    let triangleIndices = originalTriangleIndices;
-    let attributes = getMeshAttributes(vertexData, header, bounds);
-    // Compute bounding box before adding skirt so that z values are not skewed
-    // TODO: Find bounding box from header, instead of doing extra pass over
-    // vertices.
-    const boundingBox = (0, schema_1.getMeshBoundingBox)(attributes);
-    if (options.skirtHeight) {
-        const { attributes: newAttributes, triangles: newTriangles } = (0, skirt_1.addSkirt)(attributes, triangleIndices, options.skirtHeight, {
-            westIndices,
-            northIndices,
-            eastIndices,
-            southIndices
-        });
-        attributes = newAttributes;
-        triangleIndices = newTriangles;
-    }
-    return {
-        // Data return by this loader implementation
-        loaderData: {
-            header: {}
-        },
-        header: {
-            // @ts-ignore
-            vertexCount: triangleIndices.length,
-            boundingBox
-        },
-        mode: 4,
-        indices: { value: triangleIndices, size: 1 },
-        attributes
-    };
-}
-function loadQuantizedMesh(arrayBuffer, options) {
-    return getTileMesh(arrayBuffer, options['quantized-mesh']);
-}
-exports.default = loadQuantizedMesh;

package/dist/lib/parse-terrain.js

@@ -1,165 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const schema_1 = require("@loaders.gl/schema");
-const martini_1 = __importDefault(require("@mapbox/martini"));
-const delatin_1 = __importDefault(require("./delatin"));
-const skirt_1 = require("./helpers/skirt");
-function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
-    const { rScaler, bScaler, gScaler, offset } = elevationDecoder;
-    // From Martini demo
-    // https://observablehq.com/@mourner/martin-real-time-rtin-terrain-mesh
-    const terrain = new Float32Array((width + 1) * (height + 1));
-    // decode terrain values
-    for (let i = 0, y = 0; y < height; y++) {
-        for (let x = 0; x < width; x++, i++) {
-            const k = i * 4;
-            const r = imageData[k + 0];
-            const g = imageData[k + 1];
-            const b = imageData[k + 2];
-            terrain[i + y] = r * rScaler + g * gScaler + b * bScaler + offset;
-        }
-    }
-    if (tesselator === 'martini') {
-        // 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];
-        }
-    }
-    return terrain;
-}
-function getMeshAttributes(vertices, terrain, width, height, bounds) {
-    const gridSize = width + 1;
-    const numOfVerticies = vertices.length / 2;
-    // vec3. x, y in pixels, z in meters
-    const positions = new Float32Array(numOfVerticies * 3);
-    // vec2. 1 to 1 relationship with position. represents the uv on the texture image. 0,0 to 1,1.
-    const texCoords = new Float32Array(numOfVerticies * 2);
-    const [minX, minY, maxX, maxY] = bounds || [0, 0, width, height];
-    const xScale = (maxX - minX) / width;
-    const yScale = (maxY - minY) / height;
-    for (let i = 0; i < numOfVerticies; i++) {
-        const x = vertices[i * 2];
-        const y = vertices[i * 2 + 1];
-        const pixelIdx = y * gridSize + x;
-        positions[3 * i + 0] = x * xScale + minX;
-        positions[3 * i + 1] = -y * yScale + maxY;
-        positions[3 * i + 2] = terrain[pixelIdx];
-        texCoords[2 * i + 0] = x / width;
-        texCoords[2 * i + 1] = y / height;
-    }
-    return {
-        POSITION: { value: positions, size: 3 },
-        TEXCOORD_0: { value: texCoords, size: 2 }
-        // NORMAL: {}, - optional, but creates the high poly look with lighting
-    };
-}
-/**
- * Returns generated mesh object from image data
- *
- * @param {object} terrainImage terrain image data
- * @param {object} terrainOptions terrain options
- * @returns mesh object
- */
-function getMesh(terrainImage, terrainOptions) {
-    if (terrainImage === null) {
-        return null;
-    }
-    const { meshMaxError, bounds, elevationDecoder } = terrainOptions;
-    const { data, width, height } = terrainImage;
-    let terrain;
-    let mesh;
-    switch (terrainOptions.tesselator) {
-        case 'martini':
-            terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);
-            mesh = getMartiniTileMesh(meshMaxError, width, terrain);
-            break;
-        case 'delatin':
-            terrain = getTerrain(data, width, height, elevationDecoder, terrainOptions.tesselator);
-            mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
-            break;
-        // auto
-        default:
-            if (width === height && !(height & (width - 1))) {
-                terrain = getTerrain(data, width, height, elevationDecoder, 'martini');
-                mesh = getMartiniTileMesh(meshMaxError, width, terrain);
-            }
-            else {
-                terrain = getTerrain(data, width, height, elevationDecoder, 'delatin');
-                mesh = getDelatinTileMesh(meshMaxError, width, height, terrain);
-            }
-            break;
-    }
-    const { vertices } = mesh;
-    let { triangles } = mesh;
-    let attributes = getMeshAttributes(vertices, terrain, width, height, bounds);
-    // Compute bounding box before adding skirt so that z values are not skewed
-    const boundingBox = (0, schema_1.getMeshBoundingBox)(attributes);
-    if (terrainOptions.skirtHeight) {
-        const { attributes: newAttributes, triangles: newTriangles } = (0, skirt_1.addSkirt)(attributes, triangles, terrainOptions.skirtHeight);
-        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
-    };
-}
-/**
- * Get Martini generated vertices and triangles
- *
- * @param {number} meshMaxError threshold for simplifying mesh
- * @param {number} width width of the input data
- * @param {number[] | Float32Array} terrain elevation data
- * @returns {{vertices: Uint16Array, triangles: Uint32Array}} vertices and triangles data
- */
-function getMartiniTileMesh(meshMaxError, width, terrain) {
-    const gridSize = width + 1;
-    const martini = new martini_1.default(gridSize);
-    const tile = martini.createTile(terrain);
-    const { vertices, triangles } = tile.getMesh(meshMaxError);
-    return { vertices, triangles };
-}
-/**
- * Get Delatin generated vertices and triangles
- *
- * @param {number} meshMaxError threshold for simplifying mesh
- * @param {number} width width of the input data array
- * @param {number} height height of the input data array
- * @param {number[] | Float32Array} terrain elevation data
- * @returns {{vertices: number[], triangles: number[]}} vertices and triangles data
- */
-function getDelatinTileMesh(meshMaxError, width, height, terrain) {
-    const tin = new delatin_1.default(terrain, width + 1, height + 1);
-    tin.run(meshMaxError);
-    // @ts-expect-error
-    const { coords, triangles } = tin;
-    const vertices = coords;
-    return { vertices, triangles };
-}
-async function loadTerrain(arrayBuffer, options, context) {
-    const loadImageOptions = {
-        ...options,
-        mimeType: 'application/x.image',
-        image: { ...options.image, type: 'data' }
-    };
-    const image = await context.parse(arrayBuffer, loadImageOptions);
-    // Extend function to support additional mesh generation options (square grid or delatin)
-    return getMesh(image, options.terrain);
-}
-exports.default = loadTerrain;

package/dist/lib/utils/version.js

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.VERSION = void 0;
-// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
-// __VERSION__ is injected by babel-plugin-version-inline
-// @ts-ignore TS2304: Cannot find name '__VERSION__'.
-exports.VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';

package/dist/quantized-mesh-loader.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader = void 0;
-const version_1 = require("./lib/utils/version");
-/**
- * Worker loader for quantized meshes
- */
-exports.QuantizedMeshLoader = {
-    name: 'Quantized Mesh',
-    id: 'quantized-mesh',
-    module: 'terrain',
-    version: version_1.VERSION,
-    worker: true,
-    extensions: ['terrain'],
-    mimeTypes: ['application/vnd.quantized-mesh'],
-    options: {
-        'quantized-mesh': {
-            bounds: [0, 0, 1, 1],
-            skirtHeight: null
-        }
-    }
-};
-exports._typecheckQuantizedMeshLoader = exports.QuantizedMeshLoader;

package/dist/terrain-loader.js

@@ -1,34 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports._typecheckTerrainWorkerLoader = exports.TerrainLoader = void 0;
-const version_1 = require("./lib/utils/version");
-/**
- * Worker loader for color-encoded images
- */
-exports.TerrainLoader = {
-    name: 'Terrain',
-    id: 'terrain',
-    module: 'terrain',
-    version: version_1.VERSION,
-    worker: true,
-    extensions: ['png', 'pngraw', 'jpg', 'jpeg', 'gif', 'webp', 'bmp'],
-    mimeTypes: ['image/png', 'image/jpeg', 'image/gif', 'image/webp', 'image/bmp'],
-    options: {
-        terrain: {
-            tesselator: 'auto',
-            bounds: null,
-            meshMaxError: 10,
-            elevationDecoder: {
-                rScaler: 1,
-                gScaler: 0,
-                bScaler: 0,
-                offset: 0
-            },
-            skirtHeight: null
-        }
-    }
-};
-/**
- * Loader for color-encoded images
- */
-exports._typecheckTerrainWorkerLoader = exports.TerrainLoader;

package/dist/workers/quantized-mesh-worker.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const index_1 = require("../index");
-(0, loader_utils_1.createLoaderWorker)(index_1.QuantizedMeshLoader);

package/dist/workers/terrain-worker.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const loader_utils_1 = require("@loaders.gl/loader-utils");
-const index_1 = require("../index");
-(0, loader_utils_1.createLoaderWorker)(index_1.TerrainLoader);