@loaders.gl/i3s 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/lib/helpers/i3s-nodepages-tiles.js

@@ -3,199 +3,245 @@ import { getSupportedGPUTextureFormats, selectSupportedBasisFormat } from '@load
 import { I3SNodePageLoader } from "../../i3s-node-page-loader.js";
 import { normalizeTileNonUrlData } from "../parsers/parse-i3s.js";
 import { getUrlWithToken, generateTilesetAttributeUrls } from "../utils/url-utils.js";
+/**
+ * class I3SNodePagesTiles - loads nodePages and form i3s tiles from them
+ */
 export default class I3SNodePagesTiles {
-  constructor(tileset) {
-    var _tileset$nodePages, _tileset$nodePages2;
-    let url = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : '';
-    let options = arguments.length > 2 ? arguments[2] : undefined;
-    this.tileset = void 0;
-    this.nodePages = [];
-    this.pendingNodePages = [];
-    this.nodesPerPage = void 0;
-    this.options = void 0;
-    this.lodSelectionMetricType = void 0;
-    this.textureDefinitionsSelectedFormats = [];
-    this.nodesInNodePages = void 0;
-    this.url = void 0;
-    this.textureLoaderOptions = {};
-    this.tileset = {
-      ...tileset
-    };
-    this.url = url;
-    this.nodesPerPage = ((_tileset$nodePages = tileset.nodePages) === null || _tileset$nodePages === void 0 ? void 0 : _tileset$nodePages.nodesPerPage) || 64;
-    this.lodSelectionMetricType = (_tileset$nodePages2 = tileset.nodePages) === null || _tileset$nodePages2 === void 0 ? void 0 : _tileset$nodePages2.lodSelectionMetricType;
-    this.options = options;
-    this.nodesInNodePages = 0;
-    this.initSelectedFormatsForTextureDefinitions(tileset);
-  }
-  async getNodeById(id) {
-    const pageIndex = Math.floor(id / this.nodesPerPage);
-    if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
-      var _this$options$i3s;
-      const nodePageUrl = getUrlWithToken(this.url.indexOf('.slpk') !== -1 ? `nodepages/${pageIndex}` : `${this.url}/nodepages/${pageIndex}`, (_this$options$i3s = this.options.i3s) === null || _this$options$i3s === void 0 ? void 0 : _this$options$i3s.token);
-      this.pendingNodePages[pageIndex] = {
-        status: 'Pending',
-        promise: load(nodePageUrl, I3SNodePageLoader, this.options)
-      };
-      this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
-      this.nodesInNodePages += this.nodePages[pageIndex].nodes.length;
-      this.pendingNodePages[pageIndex].status = 'Done';
+    tileset;
+    nodePages = [];
+    pendingNodePages = [];
+    nodesPerPage;
+    options;
+    lodSelectionMetricType;
+    textureDefinitionsSelectedFormats = [];
+    nodesInNodePages;
+    url;
+    textureLoaderOptions = {};
+    /**
+     * @constructs
+     * Create a I3SNodePagesTiles instance.
+     * @param tileset - i3s tileset header ('layers/0')
+     * @param url - tileset url
+     * @param options - i3s loader options
+     */
+    constructor(tileset, url = '', options) {
+        this.tileset = { ...tileset }; // spread the tileset to avoid circular reference
+        this.url = url;
+        this.nodesPerPage = tileset.nodePages?.nodesPerPage || 64;
+        this.lodSelectionMetricType = tileset.nodePages?.lodSelectionMetricType;
+        this.options = options;
+        this.nodesInNodePages = 0;
+        this.initSelectedFormatsForTextureDefinitions(tileset);
     }
-    if (this.pendingNodePages[pageIndex].status === 'Pending') {
-      this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
-    }
-    const nodeIndex = id % this.nodesPerPage;
-    return this.nodePages[pageIndex].nodes[nodeIndex];
-  }
-  async formTileFromNodePages(id) {
-    const node = await this.getNodeById(id);
-    const children = [];
-    const childNodesPromises = [];
-    for (const child of node.children || []) {
-      childNodesPromises.push(this.getNodeById(child));
-    }
-    const childNodes = await Promise.all(childNodesPromises);
-    for (const childNode of childNodes) {
-      children.push({
-        id: childNode.index.toString(),
-        obb: childNode.obb
-      });
-    }
-    let contentUrl;
-    let textureUrl;
-    let materialDefinition;
-    let textureFormat = 'jpg';
-    let attributeUrls = [];
-    let isDracoGeometry = false;
-    if (node && node.mesh) {
-      const {
-        url,
-        isDracoGeometry: isDracoGeometryResult
-      } = node.mesh.geometry && this.getContentUrl(node.mesh.geometry) || {
-        isDracoGeometry: false
-      };
-      contentUrl = url;
-      isDracoGeometry = isDracoGeometryResult;
-      const {
-        textureData,
-        materialDefinition: nodeMaterialDefinition
-      } = this.getInformationFromMaterial(node.mesh.material);
-      materialDefinition = nodeMaterialDefinition;
-      textureFormat = textureData.format || textureFormat;
-      if (textureData.name) {
-        textureUrl = `${this.url}/nodes/${node.mesh.material.resource}/textures/${textureData.name}`;
-      }
-      if (this.tileset.attributeStorageInfo) {
-        attributeUrls = generateTilesetAttributeUrls(this.tileset, this.url, node.mesh.attribute.resource);
-      }
-    }
-    const lodSelection = this.getLodSelection(node);
-    return normalizeTileNonUrlData({
-      id: id.toString(),
-      lodSelection,
-      obb: node.obb,
-      contentUrl,
-      textureUrl,
-      attributeUrls,
-      materialDefinition,
-      textureFormat,
-      textureLoaderOptions: this.textureLoaderOptions,
-      children,
-      isDracoGeometry
-    });
-  }
-  getContentUrl(meshGeometryData) {
-    let result = null;
-    const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
-    let geometryIndex = -1;
-    if (this.options.i3s && this.options.i3s.useDracoGeometry) {
-      geometryIndex = geometryDefinition.geometryBuffers.findIndex(buffer => buffer.compressedAttributes && buffer.compressedAttributes.encoding === 'draco');
+    /**
+     * Loads some nodePage and return a particular node from it
+     * @param id - id of node through all node pages
+     */
+    async getNodeById(id) {
+        const pageIndex = Math.floor(id / this.nodesPerPage);
+        if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
+            const nodePageUrl = getUrlWithToken(`${this.url}/nodepages/${pageIndex}`, 
+            // @ts-expect-error this.options is not properly typed
+            this.options.i3s?.token);
+            this.pendingNodePages[pageIndex] = {
+                status: 'Pending',
+                promise: load(nodePageUrl, I3SNodePageLoader, this.options)
+            };
+            this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
+            this.nodesInNodePages += this.nodePages[pageIndex].nodes.length;
+            this.pendingNodePages[pageIndex].status = 'Done';
+        }
+        if (this.pendingNodePages[pageIndex].status === 'Pending') {
+            this.nodePages[pageIndex] = await this.pendingNodePages[pageIndex].promise;
+        }
+        const nodeIndex = id % this.nodesPerPage;
+        return this.nodePages[pageIndex].nodes[nodeIndex];
     }
-    if (geometryIndex === -1) {
-      geometryIndex = geometryDefinition.geometryBuffers.findIndex(buffer => !buffer.compressedAttributes);
+    /**
+     * Forms tile header using node and tileset data
+     * @param id - id of node through all node pages
+     */
+    // eslint-disable-next-line complexity, max-statements
+    async formTileFromNodePages(id) {
+        const node = await this.getNodeById(id);
+        const children = [];
+        const childNodesPromises = [];
+        for (const child of node.children || []) {
+            childNodesPromises.push(this.getNodeById(child));
+        }
+        const childNodes = await Promise.all(childNodesPromises);
+        for (const childNode of childNodes) {
+            children.push({
+                id: childNode.index.toString(),
+                obb: childNode.obb
+            });
+        }
+        let contentUrl;
+        let textureUrl;
+        let materialDefinition;
+        let textureFormat = 'jpg';
+        let attributeUrls = [];
+        let isDracoGeometry = false;
+        if (node && node.mesh) {
+            // Get geometry resource URL and type (compressed / non-compressed)
+            const { url, isDracoGeometry: isDracoGeometryResult } = (node.mesh.geometry &&
+                this.getContentUrl(node.mesh.geometry)) || { isDracoGeometry: false };
+            contentUrl = url;
+            isDracoGeometry = isDracoGeometryResult;
+            const { textureData, materialDefinition: nodeMaterialDefinition } = this.getInformationFromMaterial(node.mesh.material);
+            materialDefinition = nodeMaterialDefinition;
+            textureFormat = textureData.format || textureFormat;
+            if (textureData.name) {
+                textureUrl = `${this.url}/nodes/${node.mesh.material.resource}/textures/${textureData.name}`;
+            }
+            if (this.tileset.attributeStorageInfo) {
+                attributeUrls = generateTilesetAttributeUrls(this.tileset, this.url, node.mesh.attribute.resource);
+            }
+        }
+        const lodSelection = this.getLodSelection(node);
+        return normalizeTileNonUrlData({
+            id: id.toString(),
+            lodSelection,
+            obb: node.obb,
+            contentUrl,
+            textureUrl,
+            attributeUrls,
+            materialDefinition,
+            textureFormat,
+            textureLoaderOptions: this.textureLoaderOptions,
+            children,
+            isDracoGeometry
+        });
     }
-    if (geometryIndex !== -1) {
-      const isDracoGeometry = Boolean(geometryDefinition.geometryBuffers[geometryIndex].compressedAttributes);
-      result = {
-        url: `${this.url}/nodes/${meshGeometryData.resource}/geometries/${geometryIndex}`,
-        isDracoGeometry
-      };
+    /**
+     * Forms url and type of geometry resource by nodepage's data and `geometryDefinitions` in the tileset
+     * @param - data about the node's mesh from the nodepage
+     * @returns -
+     *   {string} url - url to the geometry resource
+     *   {boolean} isDracoGeometry - whether the geometry resource contain DRACO compressed geometry
+     */
+    getContentUrl(meshGeometryData) {
+        let result = null;
+        // @ts-ignore
+        const geometryDefinition = this.tileset.geometryDefinitions[meshGeometryData.definition];
+        let geometryIndex = -1;
+        // Try to find DRACO geometryDefinition of `useDracoGeometry` option is set
+        // @ts-expect-error this.options is not properly typed
+        if (this.options.i3s && this.options.i3s.useDracoGeometry) {
+            geometryIndex = geometryDefinition.geometryBuffers.findIndex((buffer) => buffer.compressedAttributes && buffer.compressedAttributes.encoding === 'draco');
+        }
+        // If DRACO geometry is not applicable try to select non-compressed geometry
+        if (geometryIndex === -1) {
+            geometryIndex = geometryDefinition.geometryBuffers.findIndex((buffer) => !buffer.compressedAttributes);
+        }
+        if (geometryIndex !== -1) {
+            const isDracoGeometry = Boolean(geometryDefinition.geometryBuffers[geometryIndex].compressedAttributes);
+            result = {
+                url: `${this.url}/nodes/${meshGeometryData.resource}/geometries/${geometryIndex}`,
+                isDracoGeometry
+            };
+        }
+        return result;
     }
-    return result;
-  }
-  getLodSelection(node) {
-    const lodSelection = [];
-    if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
-      lodSelection.push({
-        metricType: 'maxScreenThreshold',
-        maxError: Math.sqrt(node.lodThreshold / (Math.PI * 0.25))
-      });
+    /**
+     * Forms 1.6 compatible LOD selection object from a nodepage's node data
+     * @param node - a node from nodepage
+     * @returns- Array of LodSelection
+     */
+    getLodSelection(node) {
+        const lodSelection = [];
+        if (this.lodSelectionMetricType === 'maxScreenThresholdSQ') {
+            lodSelection.push({
+                metricType: 'maxScreenThreshold',
+                // @ts-ignore
+                maxError: Math.sqrt(node.lodThreshold / (Math.PI * 0.25))
+            });
+        }
+        lodSelection.push({
+            metricType: this.lodSelectionMetricType,
+            // @ts-ignore
+            maxError: node.lodThreshold
+        });
+        return lodSelection;
     }
-    lodSelection.push({
-      metricType: this.lodSelectionMetricType,
-      maxError: node.lodThreshold
-    });
-    return lodSelection;
-  }
-  getInformationFromMaterial(material) {
-    const informationFromMaterial = {
-      textureData: {
-        name: null
-      }
-    };
-    if (material) {
-      var _this$tileset$materia;
-      const materialDefinition = (_this$tileset$materia = this.tileset.materialDefinitions) === null || _this$tileset$materia === void 0 ? void 0 : _this$tileset$materia[material.definition];
-      if (materialDefinition) {
-        var _materialDefinition$p, _materialDefinition$p2;
-        informationFromMaterial.materialDefinition = materialDefinition;
-        const textureSetDefinitionIndex = materialDefinition === null || materialDefinition === void 0 ? void 0 : (_materialDefinition$p = materialDefinition.pbrMetallicRoughness) === null || _materialDefinition$p === void 0 ? void 0 : (_materialDefinition$p2 = _materialDefinition$p.baseColorTexture) === null || _materialDefinition$p2 === void 0 ? void 0 : _materialDefinition$p2.textureSetDefinitionId;
-        if (typeof textureSetDefinitionIndex === 'number') {
-          informationFromMaterial.textureData = this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] || informationFromMaterial.textureData;
+    /**
+     * Returns information about texture and material from `materialDefinitions`
+     * @param material - material data from nodepage
+     * @returns - Couple {textureData, materialDefinition}
+     * {string} textureData.name - path name of the texture
+     * {string} textureData.format - format of the texture
+     * materialDefinition - PBR-like material definition from `materialDefinitions`
+     */
+    getInformationFromMaterial(material) {
+        const informationFromMaterial = { textureData: { name: null } };
+        if (material) {
+            const materialDefinition = this.tileset.materialDefinitions?.[material.definition];
+            if (materialDefinition) {
+                informationFromMaterial.materialDefinition = materialDefinition;
+                const textureSetDefinitionIndex = materialDefinition?.pbrMetallicRoughness?.baseColorTexture?.textureSetDefinitionId;
+                if (typeof textureSetDefinitionIndex === 'number') {
+                    informationFromMaterial.textureData =
+                        this.textureDefinitionsSelectedFormats[textureSetDefinitionIndex] ||
+                            informationFromMaterial.textureData;
+                }
+            }
         }
-      }
+        return informationFromMaterial;
     }
-    return informationFromMaterial;
-  }
-  initSelectedFormatsForTextureDefinitions(tileset) {
-    this.textureDefinitionsSelectedFormats = [];
-    const possibleI3sFormats = this.getSupportedTextureFormats();
-    const textureSetDefinitions = tileset.textureSetDefinitions || [];
-    for (const textureSetDefinition of textureSetDefinitions) {
-      const formats = textureSetDefinition && textureSetDefinition.formats || [];
-      let selectedFormat = null;
-      for (const i3sFormat of possibleI3sFormats) {
-        const format = formats.find(value => value.format === i3sFormat);
-        if (format) {
-          selectedFormat = format;
-          break;
+    /**
+     * Sets preferable and supported format for each textureDefinition of the tileset
+     * @param tileset - I3S layer data
+     * @returns
+     */
+    initSelectedFormatsForTextureDefinitions(tileset) {
+        this.textureDefinitionsSelectedFormats = [];
+        const possibleI3sFormats = this.getSupportedTextureFormats();
+        const textureSetDefinitions = tileset.textureSetDefinitions || [];
+        for (const textureSetDefinition of textureSetDefinitions) {
+            const formats = (textureSetDefinition && textureSetDefinition.formats) || [];
+            let selectedFormat = null;
+            for (const i3sFormat of possibleI3sFormats) {
+                const format = formats.find((value) => value.format === i3sFormat);
+                if (format) {
+                    selectedFormat = format;
+                    break;
+                }
+            }
+            // For I3S 1.8 need to define basis target format to decode
+            if (selectedFormat && selectedFormat.format === 'ktx2') {
+                this.textureLoaderOptions.basis = {
+                    format: selectSupportedBasisFormat(),
+                    containerFormat: 'ktx2',
+                    module: 'encoder'
+                };
+            }
+            this.textureDefinitionsSelectedFormats.push(selectedFormat);
         }
-      }
-      if (selectedFormat && selectedFormat.format === 'ktx2') {
-        this.textureLoaderOptions.basis = {
-          format: selectSupportedBasisFormat(),
-          containerFormat: 'ktx2',
-          module: 'encoder'
-        };
-      }
-      this.textureDefinitionsSelectedFormats.push(selectedFormat);
     }
-  }
-  getSupportedTextureFormats() {
-    const formats = [];
-    if (!this.options.i3s || this.options.i3s.useCompressedTextures) {
-      const supportedCompressedFormats = getSupportedGPUTextureFormats();
-      if (supportedCompressedFormats.has('etc2')) {
-        formats.push('ktx-etc2');
-      }
-      if (supportedCompressedFormats.has('dxt')) {
-        formats.push('dds');
-      }
-      formats.push('ktx2');
+    /**
+     * Returns the array of supported texture format
+     * @returns list of format strings
+     */
+    getSupportedTextureFormats() {
+        const formats = [];
+        // @ts-expect-error this.options is not properly typed
+        if (!this.options.i3s || this.options.i3s.useCompressedTextures) {
+            // I3S 1.7 selection
+            const supportedCompressedFormats = getSupportedGPUTextureFormats();
+            // List of possible in i3s formats:
+            // https://github.com/Esri/i3s-spec/blob/master/docs/1.7/textureSetDefinitionFormat.cmn.md
+            if (supportedCompressedFormats.has('etc2')) {
+                formats.push('ktx-etc2');
+            }
+            if (supportedCompressedFormats.has('dxt')) {
+                formats.push('dds');
+            }
+            // I3S 1.8 selection
+            // ktx2 wraps basis texture which at the edge case can be decoded as uncompressed image
+            formats.push('ktx2');
+        }
+        formats.push('jpg');
+        formats.push('png');
+        return formats;
     }
-    formats.push('jpg');
-    formats.push('png');
-    return formats;
-  }
 }
-//# sourceMappingURL=i3s-nodepages-tiles.js.map

package/dist/lib/parsers/constants.js

@@ -1,56 +1,83 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { GL } from '@loaders.gl/math';
 export function getConstructorForDataFormat(dataType) {
-  switch (dataType) {
-    case 'UInt8':
-      return Uint8Array;
-    case 'UInt16':
-      return Uint16Array;
-    case 'UInt32':
-      return Uint32Array;
-    case 'Float32':
-      return Float32Array;
-    case 'UInt64':
-      return Float64Array;
-    default:
-      throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
-  }
+    switch (dataType) {
+        case 'UInt8':
+            return Uint8Array;
+        case 'UInt16':
+            return Uint16Array;
+        case 'UInt32':
+            return Uint32Array;
+        case 'Float32':
+            return Float32Array;
+        case 'UInt64':
+            return Float64Array;
+        default:
+            throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
+    }
 }
 export const GL_TYPE_MAP = {
-  UInt8: GL.UNSIGNED_BYTE,
-  UInt16: GL.UNSIGNED_SHORT,
-  Float32: GL.FLOAT,
-  UInt32: GL.UNSIGNED_INT,
-  UInt64: GL.DOUBLE
+    UInt8: GL.UNSIGNED_BYTE,
+    UInt16: GL.UNSIGNED_SHORT,
+    Float32: GL.FLOAT,
+    UInt32: GL.UNSIGNED_INT,
+    UInt64: GL.DOUBLE
 };
+/**
+ * Returns how many bytes a type occupies
+ * @param dataType
+ * @returns
+ */
 export function sizeOf(dataType) {
-  switch (dataType) {
-    case 'UInt8':
-      return 1;
-    case 'UInt16':
-    case 'Int16':
-      return 2;
-    case 'UInt32':
-    case 'Int32':
-    case 'Float32':
-      return 4;
-    case 'UInt64':
-    case 'Int64':
-    case 'Float64':
-      return 8;
-    default:
-      throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
-  }
+    switch (dataType) {
+        case 'UInt8':
+            return 1;
+        case 'UInt16':
+        case 'Int16':
+            return 2;
+        case 'UInt32':
+        case 'Int32':
+        case 'Float32':
+            return 4;
+        case 'UInt64':
+        case 'Int64':
+        case 'Float64':
+            return 8;
+        default:
+            throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
+    }
 }
 export const STRING_ATTRIBUTE_TYPE = 'String';
 export const OBJECT_ID_ATTRIBUTE_TYPE = 'Oid32';
 export const FLOAT_64_TYPE = 'Float64';
 export const INT_16_ATTRIBUTE_TYPE = 'Int16';
-export let COORDINATE_SYSTEM = function (COORDINATE_SYSTEM) {
-  COORDINATE_SYSTEM[COORDINATE_SYSTEM["DEFAULT"] = -1] = "DEFAULT";
-  COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT"] = 1] = "LNGLAT";
-  COORDINATE_SYSTEM[COORDINATE_SYSTEM["METER_OFFSETS"] = 2] = "METER_OFFSETS";
-  COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
-  COORDINATE_SYSTEM[COORDINATE_SYSTEM["CARTESIAN"] = 0] = "CARTESIAN";
-  return COORDINATE_SYSTEM;
-}({});
-//# sourceMappingURL=constants.js.map
+// https://github.com/visgl/deck.gl/blob/9548f43cba2234a1f4877b6b17f6c88eb35b2e08/modules/core/src/lib/constants.js#L27
+// Describes the format of positions
+export var COORDINATE_SYSTEM;
+(function (COORDINATE_SYSTEM) {
+    /**
+     * `LNGLAT` if rendering into a geospatial viewport, `CARTESIAN` otherwise
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["DEFAULT"] = -1] = "DEFAULT";
+    /**
+     * Positions are interpreted as [lng, lat, elevation]
+     * lng lat are degrees, elevation is meters. distances as meters.
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT"] = 1] = "LNGLAT";
+    /**
+     * Positions are interpreted as meter offsets, distances as meters
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["METER_OFFSETS"] = 2] = "METER_OFFSETS";
+    /**
+     * Positions are interpreted as lng lat offsets: [deltaLng, deltaLat, elevation]
+     * deltaLng, deltaLat are delta degrees, elevation is meters.
+     * distances as meters.
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
+    /**
+     * Non-geospatial
+     */
+    COORDINATE_SYSTEM[COORDINATE_SYSTEM["CARTESIAN"] = 0] = "CARTESIAN";
+})(COORDINATE_SYSTEM || (COORDINATE_SYSTEM = {}));

package/dist/lib/parsers/parse-arcgis-webscene.d.ts

@@ -1,4 +1,4 @@
-import type { ArcGISWebSceneData } from '../../types';
+import type { ArcGISWebSceneData } from "../../types.js";
 /**
  * Provides additional information in the exception Error object, e.g. unsupported layer types.
  * @param message - message used in the Error object

package/dist/lib/parsers/parse-arcgis-webscene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"parse-arcgis-webscene.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-arcgis-webscene.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,kBAAkB,EAAmB,MAAM,aAAa,CAAC;AA2BtE;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,KAAK;IAG1B,OAAO,EAAE,OAAO;gBADvB,OAAO,EAAE,MAAM,EACR,OAAO,EAAE,OAAO;CAK1B;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAclF"}
+{"version":3,"file":"parse-arcgis-webscene.d.ts","sourceRoot":"","sources":["../../../src/lib/parsers/parse-arcgis-webscene.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAC,kBAAkB,EAAmB,uBAAoB;AA2BtE;;;;;GAKG;AACH,qBAAa,UAAW,SAAQ,KAAK;IAG1B,OAAO,EAAE,OAAO;gBADvB,OAAO,EAAE,MAAM,EACR,OAAO,EAAE,OAAO;CAK1B;AAED;;;GAGG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAclF"}