@loaders.gl/terrain 4.0.0-alpha.5 → 4.0.0-alpha.6

package/dist/index.d.ts

@@ -1,77 +1,35 @@
-import type { LoaderWithParser } from '@loaders.gl/loader-utils';
-import parseQuantizedMesh from './lib/parse-quantized-mesh';
-import loadTerrain from './lib/parse-terrain';
-import { TerrainLoader as TerrainWorkerLoader } from './terrain-loader';
-import { QuantizedMeshLoader as QuantizedMeshWorkerLoader } from './quantized-mesh-loader';
+import type { LoaderContext, LoaderWithParser } from '@loaders.gl/loader-utils';
+import { TerrainLoader as TerrainWorkerLoader, TerrainLoaderOptions } from './terrain-loader';
+import { QuantizedMeshLoader as QuantizedMeshWorkerLoader, QuantizedMeshLoaderOptions } from './quantized-mesh-loader';
 export { TerrainWorkerLoader };
-export declare const TerrainLoader: {
-    parse: typeof loadTerrain;
-    name: string;
-    id: string;
-    module: string;
-    version: any;
-    worker: boolean;
-    extensions: string[];
-    mimeTypes: string[];
-    options: {
-        terrain: {
-            tesselator: string;
-            bounds: null;
-            meshMaxError: number;
-            elevationDecoder: {
-                rScaler: number;
-                gScaler: number;
-                bScaler: number;
-                offset: number;
-            };
-            skirtHeight: null;
+export declare const TerrainLoader: LoaderWithParser<any, never, TerrainLoaderOptions>;
+export declare function parseTerrain(arrayBuffer: ArrayBuffer, options?: TerrainLoaderOptions, context?: LoaderContext): Promise<{
+    loaderData: {
+        header: {};
+    };
+    header: {
+        vertexCount: any;
+        boundingBox: [[number, number, number], [number, number, number]];
+    };
+    mode: number;
+    indices: {
+        value: Uint32Array;
+        size: number;
+    };
+    attributes: {
+        POSITION: {
+            value: Float32Array;
+            size: number;
+        };
+        TEXCOORD_0: {
+            value: Float32Array;
+            size: number;
         };
     };
-};
-export declare const _typecheckTerrainLoader: LoaderWithParser;
+}>;
 export { QuantizedMeshWorkerLoader };
 /**
  * Loader for quantized meshes
  */
-export declare const QuantizedMeshLoader: {
-    parseSync: typeof parseQuantizedMesh;
-    parse: (arrayBuffer: any, options: any) => Promise<{
-        loaderData: {
-            header: {};
-        };
-        header: {
-            vertexCount: any;
-            boundingBox: [[number, number, number], [number, number, number]];
-        };
-        mode: number;
-        indices: {
-            value: any;
-            size: number;
-        };
-        attributes: {
-            POSITION: {
-                value: Float32Array;
-                size: number;
-            };
-            TEXCOORD_0: {
-                value: Float32Array;
-                size: number;
-            };
-        };
-    } | null>;
-    name: string;
-    id: string;
-    module: string;
-    version: any;
-    worker: boolean;
-    extensions: string[];
-    mimeTypes: string[];
-    options: {
-        'quantized-mesh': {
-            bounds: number[];
-            skirtHeight: null;
-        };
-    };
-};
-export declare const _typecheckQuantizedMeshLoader: LoaderWithParser;
+export declare const QuantizedMeshLoader: LoaderWithParser<any, never, QuantizedMeshLoaderOptions>;
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAC/D,OAAO,kBAAkB,MAAM,4BAA4B,CAAC;AAC5D,OAAO,WAAW,MAAM,qBAAqB,CAAC;AAE9C,OAAO,EAAC,aAAa,IAAI,mBAAmB,EAAC,MAAM,kBAAkB,CAAC;AACtE,OAAO,EAAC,mBAAmB,IAAI,yBAAyB,EAAC,MAAM,yBAAyB,CAAC;AAIzF,OAAO,EAAC,mBAAmB,EAAC,CAAC;AAE7B,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;CAGzB,CAAC;AAEF,eAAO,MAAM,uBAAuB,EAAE,gBAAgC,CAAC;AAIvE,OAAO,EAAC,yBAAyB,EAAC,CAAC;AAEnC;;GAEG;AACH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAI/B,CAAC;AAEF,eAAO,MAAM,6BAA6B,EAAE,gBAAsC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAI9E,OAAO,EAAC,aAAa,IAAI,mBAAmB,EAAE,oBAAoB,EAAC,MAAM,kBAAkB,CAAC;AAC5F,OAAO,EACL,mBAAmB,IAAI,yBAAyB,EAChD,0BAA0B,EAC3B,MAAM,yBAAyB,CAAC;AAIjC,OAAO,EAAC,mBAAmB,EAAC,CAAC;AAE7B,eAAO,MAAM,aAAa,EAAE,gBAAgB,CAAC,GAAG,EAAE,KAAK,EAAE,oBAAoB,CAG5E,CAAC;AAEF,wBAAsB,YAAY,CAChC,WAAW,EAAE,WAAW,EACxB,OAAO,CAAC,EAAE,oBAAoB,EAC9B,OAAO,CAAC,EAAE,aAAa;;;;;;;;;;;;;;;;;;;;;;;GAWxB;AAID,OAAO,EAAC,yBAAyB,EAAC,CAAC;AAEnC;;GAEG;AACH,eAAO,MAAM,mBAAmB,EAAE,gBAAgB,CAAC,GAAG,EAAE,KAAK,EAAE,0BAA0B,CAKxF,CAAC"}

package/dist/index.js

@@ -1,16 +1,33 @@
-import parseQuantizedMesh from './lib/parse-quantized-mesh';
-import loadTerrain from './lib/parse-terrain';
-import { TerrainLoader as TerrainWorkerLoader } from './terrain-loader';
-import { QuantizedMeshLoader as QuantizedMeshWorkerLoader } from './quantized-mesh-loader';
-export { TerrainWorkerLoader };
-export const TerrainLoader = { ...TerrainWorkerLoader,
-  parse: loadTerrain
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.QuantizedMeshLoader = exports.QuantizedMeshWorkerLoader = exports.parseTerrain = exports.TerrainLoader = exports.TerrainWorkerLoader = void 0;
+const parse_quantized_mesh_1 = require("./lib/parse-quantized-mesh");
+const parse_terrain_1 = 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: parseTerrain
 };
-export const _typecheckTerrainLoader = TerrainLoader;
-export { QuantizedMeshWorkerLoader };
-export const QuantizedMeshLoader = { ...QuantizedMeshWorkerLoader,
-  parseSync: parseQuantizedMesh,
-  parse: async (arrayBuffer, options) => parseQuantizedMesh(arrayBuffer, options)
+async function parseTerrain(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)
+    const terrainOptions = { ...exports.TerrainLoader.options.terrain, ...options?.terrain };
+    return (0, parse_terrain_1.makeTerrainMeshFromImage)(image, terrainOptions);
+}
+exports.parseTerrain = parseTerrain;
+/**
+ * Loader for quantized meshes
+ */
+exports.QuantizedMeshLoader = {
+    ...quantized_mesh_loader_1.QuantizedMeshLoader,
+    parseSync: (arrayBuffer, options) => (0, parse_quantized_mesh_1.parseQuantizedMesh)(arrayBuffer, options?.['quantized-mesh']),
+    parse: async (arrayBuffer, options) => (0, parse_quantized_mesh_1.parseQuantizedMesh)(arrayBuffer, options?.['quantized-mesh'])
 };
-export const _typecheckQuantizedMeshLoader = QuantizedMeshLoader;
-//# sourceMappingURL=index.js.map

package/dist/lib/decode-quantized-mesh.d.ts

@@ -1,4 +1,4 @@
-declare type Extensions = {
+type Extensions = {
     vertexNormals?: any;
     waterMask?: any;
 };

package/dist/lib/decode-quantized-mesh.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decode-quantized-mesh.d.ts","sourceRoot":"","sources":["../../src/lib/decode-quantized-mesh.ts"],"names":[],"mappings":"AAuNA,aAAK,UAAU,GAAG;IAChB,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,SAAS,CAAC,EAAE,GAAG,CAAC;CACjB,CAAC;AA0CF,eAAO,MAAM,cAAc;;;;;;CAM1B,CAAC;AAMF,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD/C"}
+{"version":3,"file":"decode-quantized-mesh.d.ts","sourceRoot":"","sources":["../../src/lib/decode-quantized-mesh.ts"],"names":[],"mappings":"AAuNA,KAAK,UAAU,GAAG;IAChB,aAAa,CAAC,EAAE,GAAG,CAAC;IACpB,SAAS,CAAC,EAAE,GAAG,CAAC;CACjB,CAAC;AA0CF,eAAO,MAAM,cAAc;;;;;;CAM1B,CAAC;AAMF,MAAM,CAAC,OAAO,UAAU,MAAM,CAAC,IAAI,KAAA,EAAE,WAAW,KAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoD/C"}

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

@@ -1,268 +1,227 @@
-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]]);
-
+"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);
+    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
-  };
+    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
-  };
+    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;
+    let indices;
+    if (bytesPerIndex === 2) {
+        indices = new Uint16Array(buffer, position, indicesCount);
+    }
+    else {
+        indices = new Uint32Array(buffer, position, indicesCount);
     }
-  }
-
-  return indices;
+    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
-  };
+    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
-  };
+    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);
+    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
-    };
-  }
-
-  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;
+    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}`)
+            }
         }
-
-      default:
-        {}
+        position += extensionLength;
     }
-
-    position += extensionLength;
-  }
-
-  return {
-    extensions,
-    extensionsEndPosition: position
-  };
+    return { extensions, extensionsEndPosition: position };
 }
-
-export const DECODING_STEPS = {
-  header: 0,
-  vertices: 1,
-  triangleIndices: 2,
-  edgeIndices: 3,
-  extensions: 4
+exports.DECODING_STEPS = {
+    header: 0,
+    vertices: 1,
+    triangleIndices: 2,
+    edgeIndices: 3,
+    extensions: 4
 };
 const DEFAULT_OPTIONS = {
-  maxDecodingStep: DECODING_STEPS.extensions
+    maxDecodingStep: exports.DECODING_STEPS.extensions
 };
-export default function decode(data, userOptions) {
-  const options = Object.assign({}, DEFAULT_OPTIONS, userOptions);
-  const view = new DataView(data);
-  const {
-    header,
-    headerEndPosition
-  } = decodeHeader(view);
-
-  if (options.maxDecodingStep < DECODING_STEPS.vertices) {
-    return {
-      header
-    };
-  }
-
-  const {
-    vertexData,
-    vertexDataEndPosition
-  } = decodeVertexData(view, headerEndPosition);
-
-  if (options.maxDecodingStep < DECODING_STEPS.triangleIndices) {
-    return {
-      header,
-      vertexData
-    };
-  }
-
-  const {
-    triangleIndices,
-    triangleIndicesEndPosition
-  } = decodeTriangleIndices(view, vertexData, vertexDataEndPosition);
-
-  if (options.maxDecodingStep < DECODING_STEPS.edgeIndices) {
-    return {
-      header,
-      vertexData,
-      triangleIndices
-    };
-  }
-
-  const {
-    westIndices,
-    southIndices,
-    eastIndices,
-    northIndices,
-    edgeIndicesEndPosition
-  } = decodeEdgeIndices(view, vertexData, triangleIndicesEndPosition);
-
-  if (options.maxDecodingStep < 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
+        header,
+        vertexData,
+        triangleIndices,
+        westIndices,
+        northIndices,
+        eastIndices,
+        southIndices,
+        extensions
     };
-  }
-
-  const {
-    extensions
-  } = decodeExtensions(view, edgeIndicesEndPosition);
-  return {
-    header,
-    vertexData,
-    triangleIndices,
-    westIndices,
-    northIndices,
-    eastIndices,
-    southIndices,
-    extensions
-  };
 }
-//# sourceMappingURL=decode-quantized-mesh.js.map
+exports.default = decode;