@loaders.gl/terrain 4.2.0-alpha.3 → 4.2.0-alpha.5

package/dist/dist.dev.js

@@ -2,14 +2,19 @@
   if (typeof exports === 'object' && typeof module === 'object')
     module.exports = factory();
   else if (typeof define === 'function' && define.amd) define([], factory);
-        else if (typeof exports === 'object') exports['loader'] = factory();
-  else root['loader'] = factory();})(globalThis, function () {
+        else if (typeof exports === 'object') exports['loaders'] = factory();
+  else root['loaders'] = factory();})(globalThis, function () {
 "use strict";
 var __exports__ = (() => {
+  var __create = Object.create;
   var __defProp = Object.defineProperty;
   var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
   var __getOwnPropNames = Object.getOwnPropertyNames;
+  var __getProtoOf = Object.getPrototypeOf;
   var __hasOwnProp = Object.prototype.hasOwnProperty;
+  var __commonJS = (cb, mod) => function __require() {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  };
   var __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -22,17 +27,34 @@ var __exports__ = (() => {
     }
     return to;
   };
+  var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+  var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+    // If the importer is in node compatibility mode or this is not an ESM
+    // file that has been converted to a CommonJS file using a Babel-
+    // compatible transform (i.e. "__esModule" has not been set), then set
+    // "default" to the CommonJS "module.exports" for node compatibility.
+    isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+    mod
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
+  // external-global-plugin:@loaders.gl/core
+  var require_core = __commonJS({
+    "external-global-plugin:@loaders.gl/core"(exports, module) {
+      module.exports = globalThis.loaders;
+    }
+  });
+
+  // bundle.ts
+  var bundle_exports = {};
+  __export(bundle_exports, {
     QuantizedMeshLoader: () => QuantizedMeshLoader2,
     QuantizedMeshWorkerLoader: () => QuantizedMeshLoader,
     TerrainLoader: () => TerrainLoader2,
     TerrainWorkerLoader: () => TerrainLoader,
     parseTerrain: () => parseTerrain
   });
+  __reExport(bundle_exports, __toESM(require_core(), 1));
 
   // ../loader-utils/src/loader-types.ts
   async function parseFromContext(data, loaders, options, context) {
@@ -44,7 +66,9 @@ var __exports__ = (() => {
     const arrays = typedArrays;
     const TypedArrayConstructor = arrays && arrays.length > 1 && arrays[0].constructor || null;
     if (!TypedArrayConstructor) {
-      throw new Error('"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types');
+      throw new Error(
+        '"concatenateTypedArrays" - incorrect quantity of arguments or arguments have incompatible data types'
+      );
     }
     const sumLength = arrays.reduce((acc, value) => acc + value.length, 0);
     const result = new TypedArrayConstructor(sumLength);
@@ -77,11 +101,27 @@ var __exports__ = (() => {
       maxY = y > maxY ? y : maxY;
       maxZ = z > maxZ ? z : maxZ;
     }
-    return [[minX, minY, minZ], [maxX, maxY, maxZ]];
+    return [
+      [minX, minY, minZ],
+      [maxX, maxY, maxZ]
+    ];
   }
 
   // src/lib/decode-quantized-mesh.ts
-  var QUANTIZED_MESH_HEADER = /* @__PURE__ */ 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]]);
+  var QUANTIZED_MESH_HEADER = /* @__PURE__ */ 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);
   }
@@ -93,10 +133,7 @@ var __exports__ = (() => {
       header[key] = getter.call(dataView, position, true);
       position += bytesCount;
     }
-    return {
-      header,
-      headerEndPosition: position
-    };
+    return { header, headerEndPosition: position };
   }
   function decodeVertexData(dataView, headerEndPosition) {
     let position = headerEndPosition;
@@ -115,16 +152,15 @@ var __exports__ = (() => {
     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));
+      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
-    };
+    return { vertexData, vertexDataEndPosition: position };
   }
   function decodeIndex(buffer, position, indicesCount, bytesPerIndex, encoded = true) {
     let indices;
@@ -157,7 +193,12 @@ var __exports__ = (() => {
     const triangleCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
     const triangleIndicesCount = triangleCount * 3;
-    const triangleIndices = decodeIndex(dataView.buffer, position, triangleIndicesCount, bytesPerIndex);
+    const triangleIndices = decodeIndex(
+      dataView.buffer,
+      position,
+      triangleIndicesCount,
+      bytesPerIndex
+    );
     position += triangleIndicesCount * bytesPerIndex;
     return {
       triangleIndicesEndPosition: position,
@@ -175,7 +216,13 @@ var __exports__ = (() => {
     position += westVertexCount * bytesPerIndex;
     const southVertexCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
-    const southIndices = decodeIndex(dataView.buffer, position, southVertexCount, bytesPerIndex, false);
+    const southIndices = decodeIndex(
+      dataView.buffer,
+      position,
+      southVertexCount,
+      bytesPerIndex,
+      false
+    );
     position += southVertexCount * bytesPerIndex;
     const eastVertexCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
@@ -183,7 +230,13 @@ var __exports__ = (() => {
     position += eastVertexCount * bytesPerIndex;
     const northVertexCount = dataView.getUint32(position, true);
     position += Uint32Array.BYTES_PER_ELEMENT;
-    const northIndices = decodeIndex(dataView.buffer, position, northVertexCount, bytesPerIndex, false);
+    const northIndices = decodeIndex(
+      dataView.buffer,
+      position,
+      northVertexCount,
+      bytesPerIndex,
+      false
+    );
     position += northVertexCount * bytesPerIndex;
     return {
       edgeIndicesEndPosition: position,
@@ -194,18 +247,22 @@ var __exports__ = (() => {
     };
   }
   function decodeVertexNormalsExtension(extensionDataView) {
-    return new Uint8Array(extensionDataView.buffer, extensionDataView.byteOffset, extensionDataView.byteLength);
+    return new Uint8Array(
+      extensionDataView.buffer,
+      extensionDataView.byteOffset,
+      extensionDataView.byteLength
+    );
   }
   function decodeWaterMaskExtension(extensionDataView) {
-    return extensionDataView.buffer.slice(extensionDataView.byteOffset, extensionDataView.byteOffset + extensionDataView.byteLength);
+    return extensionDataView.buffer.slice(
+      extensionDataView.byteOffset,
+      extensionDataView.byteOffset + extensionDataView.byteLength
+    );
   }
   function decodeExtensions(dataView, indicesEndPosition) {
     const extensions = {};
     if (dataView.byteLength <= indicesEndPosition) {
-      return {
-        extensions,
-        extensionsEndPosition: indicesEndPosition
-      };
+      return { extensions, extensionsEndPosition: indicesEndPosition };
     }
     let position = indicesEndPosition;
     while (position < dataView.byteLength) {
@@ -228,10 +285,7 @@ var __exports__ = (() => {
       }
       position += extensionLength;
     }
-    return {
-      extensions,
-      extensionsEndPosition: position
-    };
+    return { extensions, extensionsEndPosition: position };
   }
   var DECODING_STEPS = {
     header: 0,
@@ -246,43 +300,23 @@ var __exports__ = (() => {
   function decode(data, userOptions) {
     const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);
     const view = new DataView(data);
-    const {
-      header,
-      headerEndPosition
-    } = decodeHeader(view);
+    const { header, headerEndPosition } = decodeHeader(view);
     if (options.maxDecodingStep < DECODING_STEPS.vertices) {
-      return {
-        header
-      };
+      return { header };
     }
-    const {
-      vertexData,
-      vertexDataEndPosition
-    } = decodeVertexData(view, headerEndPosition);
+    const { vertexData, vertexDataEndPosition } = decodeVertexData(view, headerEndPosition);
     if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {
-      return {
-        header,
-        vertexData
-      };
+      return { header, vertexData };
     }
-    const {
-      triangleIndices,
-      triangleIndicesEndPosition
-    } = decodeTriangleIndices(view, vertexData, vertexDataEndPosition);
+    const { triangleIndices, triangleIndicesEndPosition } = decodeTriangleIndices(
+      view,
+      vertexData,
+      vertexDataEndPosition
+    );
     if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {
-      return {
-        header,
-        vertexData,
-        triangleIndices
-      };
+      return { header, vertexData, triangleIndices };
     }
-    const {
-      westIndices,
-      southIndices,
-      eastIndices,
-      northIndices,
-      edgeIndicesEndPosition
-    } = decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);
+    const { westIndices, southIndices, eastIndices, northIndices, edgeIndicesEndPosition } = decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);
     if (options.maxDecodingStep < DECODING_STEPS.extensions) {
       return {
         header,
@@ -294,9 +328,7 @@ var __exports__ = (() => {
         southIndices
       };
     }
-    const {
-      extensions
-    } = decodeExtensions(view, edgeIndicesEndPosition);
+    const { extensions } = decodeExtensions(view, edgeIndicesEndPosition);
     return {
       header,
       vertexData,
@@ -381,12 +413,24 @@ var __exports__ = (() => {
     const positionsLength = attributes.POSITION.value.length;
     const vertex1Offset = edgeIndex * 2;
     const vertex2Offset = edgeIndex * 2 + 1;
-    newPosition.set(attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3), vertex1Offset * 3);
+    newPosition.set(
+      attributes.POSITION.value.subarray(edge[0] * 3, edge[0] * 3 + 3),
+      vertex1Offset * 3
+    );
     newPosition[vertex1Offset * 3 + 2] = newPosition[vertex1Offset * 3 + 2] - skirtHeight;
-    newPosition.set(attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3), vertex2Offset * 3);
+    newPosition.set(
+      attributes.POSITION.value.subarray(edge[1] * 3, edge[1] * 3 + 3),
+      vertex2Offset * 3
+    );
     newPosition[vertex2Offset * 3 + 2] = newPosition[vertex2Offset * 3 + 2] - skirtHeight;
-    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);
+    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
+    );
     const triangle1Offset = edgeIndex * 2 * 3;
     newTriangles[triangle1Offset] = edge[0];
     newTriangles[triangle1Offset + 1] = positionsLength / 3 + vertex2Offset;
@@ -398,9 +442,7 @@ var __exports__ = (() => {
 
   // src/lib/parse-quantized-mesh.ts
   function parseQuantizedMesh(arrayBuffer, options = {}) {
-    const {
-      bounds
-    } = options;
+    const { bounds } = options;
     const {
       header,
       vertexData,
@@ -414,41 +456,41 @@ var __exports__ = (() => {
     let attributes = getMeshAttributes(vertexData, header, bounds);
     const boundingBox = getMeshBoundingBox(attributes);
     if (options?.skirtHeight) {
-      const {
-        attributes: newAttributes,
-        triangles: newTriangles
-      } = addSkirt(attributes, triangleIndices, options.skirtHeight, {
-        westIndices,
-        northIndices,
-        eastIndices,
-        southIndices
-      });
+      const { attributes: newAttributes, triangles: newTriangles } = 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
       },
+      // TODO
       schema: void 0,
       topology: "triangle-list",
       mode: 4,
-      indices: {
-        value: triangleIndices,
-        size: 1
-      },
+      // TRIANGLES
+      indices: { value: triangleIndices, size: 1 },
       attributes
     };
   }
   function getMeshAttributes(vertexData, header, bounds) {
-    const {
-      minHeight,
-      maxHeight
-    } = header;
+    const { minHeight, maxHeight } = header;
     const [minX, minY, maxX, maxY] = bounds || [0, 0, 1, 1];
     const xScale = maxX - minX;
     const yScale = maxY - minY;
@@ -467,14 +509,10 @@ var __exports__ = (() => {
       texCoords[2 * i + 1] = y;
     }
     return {
-      POSITION: {
-        value: positions,
-        size: 3
-      },
-      TEXCOORD_0: {
-        value: texCoords,
-        size: 2
-      }
+      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
     };
   }
 
@@ -642,24 +680,30 @@ var __exports__ = (() => {
       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++) {
@@ -667,10 +711,19 @@ var __exports__ = (() => {
         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._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) {
       const minX = Math.min(p0x, p1x, p2x);
       const minY = Math.min(p0y, p1y, p2y);
@@ -738,6 +791,7 @@ var __exports__ = (() => {
       this._rms[t] = rms;
       this._queuePush(t, maxError, rms);
     }
+    // process the next triangle in the queue, splitting it with a new point
     _step() {
       const t = this._queuePop();
       const e0 = t * 3 + 0;
@@ -773,11 +827,13 @@ var __exports__ = (() => {
         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;
       this.triangles[e + 0] = a;
@@ -818,7 +874,16 @@ var __exports__ = (() => {
       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])) {
+      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];
@@ -832,6 +897,7 @@ var __exports__ = (() => {
       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;
@@ -865,6 +931,7 @@ var __exports__ = (() => {
       this._legalize(t2);
       this._legalize(t3);
     }
+    // priority queue methods
     _queuePush(t, error, rms) {
       const i = this._queue.length;
       this._queueIndices[t] = i;
@@ -970,16 +1037,8 @@ var __exports__ = (() => {
 
   // src/lib/parse-terrain.ts
   function makeTerrainMeshFromImage(terrainImage, terrainOptions) {
-    const {
-      meshMaxError,
-      bounds,
-      elevationDecoder
-    } = terrainOptions;
-    const {
-      data,
-      width,
-      height
-    } = terrainImage;
+    const { meshMaxError, bounds, elevationDecoder } = terrainOptions;
+    const { data, width, height } = terrainImage;
     let terrain;
     let mesh;
     switch (terrainOptions.tesselator) {
@@ -1001,23 +1060,21 @@ var __exports__ = (() => {
         }
         break;
     }
-    const {
-      vertices
-    } = mesh;
-    let {
-      triangles
-    } = mesh;
+    const { vertices } = mesh;
+    let { triangles } = mesh;
     let attributes = getMeshAttributes2(vertices, terrain, width, height, bounds);
     const boundingBox = getMeshBoundingBox(attributes);
     if (terrainOptions.skirtHeight) {
-      const {
-        attributes: newAttributes,
-        triangles: newTriangles
-      } = addSkirt(attributes, triangles, terrainOptions.skirtHeight);
+      const { attributes: newAttributes, triangles: newTriangles } = addSkirt(
+        attributes,
+        triangles,
+        terrainOptions.skirtHeight
+      );
       attributes = newAttributes;
       triangles = newTriangles;
     }
     return {
+      // Data return by this loader implementation
       loaderData: {
         header: {}
       },
@@ -1026,10 +1083,8 @@ var __exports__ = (() => {
         boundingBox
       },
       mode: 4,
-      indices: {
-        value: Uint32Array.from(triangles),
-        size: 1
-      },
+      // TRIANGLES
+      indices: { value: Uint32Array.from(triangles), size: 1 },
       attributes
     };
   }
@@ -1037,35 +1092,18 @@ var __exports__ = (() => {
     const gridSize = width + 1;
     const martini = new Martini(gridSize);
     const tile = martini.createTile(terrain);
-    const {
-      vertices,
-      triangles
-    } = tile.getMesh(meshMaxError);
-    return {
-      vertices,
-      triangles
-    };
+    const { vertices, triangles } = tile.getMesh(meshMaxError);
+    return { vertices, triangles };
   }
   function getDelatinTileMesh(meshMaxError, width, height, terrain) {
     const tin = new Delatin(terrain, width + 1, height + 1);
     tin.run(meshMaxError);
-    const {
-      coords,
-      triangles
-    } = tin;
+    const { coords, triangles } = tin;
     const vertices = coords;
-    return {
-      vertices,
-      triangles
-    };
+    return { vertices, triangles };
   }
   function getTerrain(imageData, width, height, elevationDecoder, tesselator) {
-    const {
-      rScaler,
-      bScaler,
-      gScaler,
-      offset
-    } = elevationDecoder;
+    const { rScaler, bScaler, gScaler, offset } = elevationDecoder;
     const terrain = new Float32Array((width + 1) * (height + 1));
     for (let i = 0, y = 0; y < height; y++) {
       for (let x = 0; x < width; x++, i++) {
@@ -1105,19 +1143,14 @@ var __exports__ = (() => {
       texCoords[2 * i + 1] = y / height;
     }
     return {
-      POSITION: {
-        value: positions,
-        size: 3
-      },
-      TEXCOORD_0: {
-        value: texCoords,
-        size: 2
-      }
+      POSITION: { value: positions, size: 3 },
+      TEXCOORD_0: { value: texCoords, size: 2 }
+      // NORMAL: {}, - optional, but creates the high poly look with lighting
     };
   }
 
   // src/lib/utils/version.ts
-  var VERSION = true ? "4.2.0-alpha.3" : "latest";
+  var VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
   // src/terrain-loader.ts
   var TerrainLoader = {
@@ -1170,16 +1203,10 @@ var __exports__ = (() => {
     const loadImageOptions = {
       ...options,
       mimeType: "application/x.image",
-      image: {
-        ...options?.image,
-        type: "data"
-      }
+      image: { ...options?.image, type: "data" }
     };
     const image = await parseFromContext(arrayBuffer, [], loadImageOptions, context);
-    const terrainOptions = {
-      ...TerrainLoader2.options.terrain,
-      ...options?.terrain
-    };
+    const terrainOptions = { ...TerrainLoader2.options.terrain, ...options?.terrain };
     return makeTerrainMeshFromImage(image, terrainOptions);
   }
   var QuantizedMeshLoader2 = {
@@ -1187,7 +1214,7 @@ var __exports__ = (() => {
     parseSync: (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.["quantized-mesh"]),
     parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options?.["quantized-mesh"])
   };
-  return __toCommonJS(src_exports);
+  return __toCommonJS(bundle_exports);
 })();
       return __exports__;
       });