@loaders.gl/i3s 4.0.0-alpha.17 → 4.0.0-alpha.19

package/dist/dist.min.js

@@ -1250,37 +1250,37 @@
   });
 
   // ../worker-utils/src/lib/library-utils/library-utils.ts
-  async function loadLibrary(libraryUrl, moduleName = null, options = {}) {
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
     if (moduleName) {
-      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options);
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
     }
     loadLibraryPromises[libraryUrl] = loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
     return await loadLibraryPromises[libraryUrl];
   }
-  function getLibraryUrl(library, moduleName, options) {
-    if (library.startsWith("http")) {
+  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (!options.useLocalLibraries && library.startsWith("http")) {
       return library;
     }
+    libraryName = libraryName || library;
     const modules = options.modules || {};
-    if (modules[library]) {
-      return modules[library];
+    if (modules[libraryName]) {
+      return modules[libraryName];
     }
     if (!isBrowser2) {
-      return `modules/${moduleName}/dist/libs/${library}`;
+      return `modules/${moduleName}/dist/libs/${libraryName}`;
     }
     if (options.CDN) {
       assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${libraryName}`;
     }
     if (isWorker) {
-      return `../src/libs/${library}`;
+      return `../src/libs/${libraryName}`;
     }
-    return `modules/${moduleName}/src/libs/${library}`;
+    return `modules/${moduleName}/src/libs/${libraryName}`;
   }
   async function loadLibraryFromFile(libraryUrl) {
     if (libraryUrl.endsWith("wasm")) {
-      const response2 = await fetch(libraryUrl);
-      return await response2.arrayBuffer();
+      return await loadAsArrayBuffer(libraryUrl);
     }
     if (!isBrowser2) {
       try {
@@ -1292,8 +1292,7 @@
     if (isWorker) {
       return importScripts(libraryUrl);
     }
-    const response = await fetch(libraryUrl);
-    const scriptSource = await response.text();
+    const scriptSource = await loadAsText(libraryUrl);
     return loadLibraryFromString(scriptSource, libraryUrl);
   }
   function loadLibraryFromString(scriptSource, id) {
@@ -1314,6 +1313,20 @@
     document.body.appendChild(script);
     return null;
   }
+  async function loadAsArrayBuffer(url) {
+    if (!node.readFileAsArrayBuffer || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.arrayBuffer();
+    }
+    return await node.readFileAsArrayBuffer(url);
+  }
+  async function loadAsText(url) {
+    if (!node.readFileAsText || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.text();
+    }
+    return await node.readFileAsText(url);
+  }
   var node, LATEST, VERSION2, loadLibraryPromises;
   var init_library_utils = __esm({
     "../worker-utils/src/lib/library-utils/library-utils.ts"() {
@@ -1965,18 +1978,38 @@
     }
   });
 
+  // (disabled):../core/src/lib/fetch/fetch-file.node
+  var require_fetch_file = __commonJS({
+    "(disabled):../core/src/lib/fetch/fetch-file.node"() {
+    }
+  });
+
   // ../core/src/lib/fetch/fetch-file.ts
+  function isNodePath(url) {
+    return !isRequestURL(url) && !isDataURL(url);
+  }
+  function isRequestURL(url) {
+    return url.startsWith("http:") || url.startsWith("https:");
+  }
+  function isDataURL(url) {
+    return url.startsWith("data:");
+  }
   async function fetchFile(urlOrData, fetchOptions) {
     if (typeof urlOrData === "string") {
       const url = resolvePath(urlOrData);
+      if (isNodePath(url) && node3?.fetchFileNode) {
+        return node3.fetchFileNode(url, fetchOptions);
+      }
       return await fetch(url, fetchOptions);
     }
     return await makeResponse(urlOrData);
   }
+  var node3;
   var init_fetch_file = __esm({
     "../core/src/lib/fetch/fetch-file.ts"() {
       init_src2();
       init_response_utils();
+      node3 = __toModule(require_fetch_file());
     }
   });
 
@@ -2640,6 +2673,7 @@
         mimeType: void 0,
         nothrow: false,
         log: new ConsoleLog(),
+        useLocalLibraries: false,
         CDN: "https://unpkg.com/@loaders.gl",
         worker: true,
         maxConcurrency: 3,
@@ -7709,13 +7743,13 @@
     let wasmBinary;
     switch (options.draco && options.draco.decoderType) {
       case "js":
-        DracoDecoderModule = await loadLibrary(DRACO_JS_DECODER_URL, "draco", options);
+        DracoDecoderModule = await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER);
         break;
       case "wasm":
       default:
         [DracoDecoderModule, wasmBinary] = await Promise.all([
-          await loadLibrary(DRACO_WASM_WRAPPER_URL, "draco", options),
-          await loadLibrary(DRACO_WASM_DECODER_URL, "draco", options)
+          await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER),
+          await loadLibrary(DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM], "draco", options, DRACO_EXTERNAL_LIBRARIES.DECODER_WASM)
         ]);
     }
     DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
@@ -7733,17 +7767,25 @@
       });
     });
   }
-  var DRACO_DECODER_VERSION, DRACO_ENCODER_VERSION, STATIC_DECODER_URL, DRACO_JS_DECODER_URL, DRACO_WASM_WRAPPER_URL, DRACO_WASM_DECODER_URL, DRACO_ENCODER_URL, loadDecoderPromise;
+  var DRACO_DECODER_VERSION, DRACO_ENCODER_VERSION, STATIC_DECODER_URL, DRACO_EXTERNAL_LIBRARIES, DRACO_EXTERNAL_LIBRARY_URLS, loadDecoderPromise;
   var init_draco_module_loader = __esm({
     "../draco/src/lib/draco-module-loader.ts"() {
       init_src();
       DRACO_DECODER_VERSION = "1.5.5";
       DRACO_ENCODER_VERSION = "1.4.1";
       STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
-      DRACO_JS_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.js`;
-      DRACO_WASM_WRAPPER_URL = `${STATIC_DECODER_URL}/draco_wasm_wrapper.js`;
-      DRACO_WASM_DECODER_URL = `${STATIC_DECODER_URL}/draco_decoder.wasm`;
-      DRACO_ENCODER_URL = `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/draco_encoder.js`;
+      DRACO_EXTERNAL_LIBRARIES = {
+        DECODER: "draco_wasm_wrapper.js",
+        DECODER_WASM: "draco_decoder.wasm",
+        FALLBACK_DECODER: "draco_decoder.js",
+        ENCODER: "draco_encoder.js"
+      };
+      DRACO_EXTERNAL_LIBRARY_URLS = {
+        [DRACO_EXTERNAL_LIBRARIES.DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER}`,
+        [DRACO_EXTERNAL_LIBRARIES.DECODER_WASM]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER_WASM}`,
+        [DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER}`,
+        [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
+      };
     }
   });
 
@@ -7779,25 +7821,25 @@
   });
 
   // ../textures/src/lib/parsers/basis-module-loader.ts
-  async function loadBasisTrascoderModule(options) {
+  async function loadBasisTranscoderModule(options) {
     const modules = options.modules || {};
     if (modules.basis) {
       return modules.basis;
     }
-    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTrascoder(options);
+    loadBasisTranscoderPromise = loadBasisTranscoderPromise || loadBasisTranscoder(options);
     return await loadBasisTranscoderPromise;
   }
-  async function loadBasisTrascoder(options) {
+  async function loadBasisTranscoder(options) {
     let BASIS = null;
     let wasmBinary = null;
     [BASIS, wasmBinary] = await Promise.all([
-      await loadLibrary("basis_transcoder.js", "textures", options),
-      await loadLibrary("basis_transcoder.wasm", "textures", options)
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.TRANSCODER_WASM, "textures", options)
     ]);
     BASIS = BASIS || globalThis.BASIS;
-    return await initializeBasisTrascoderModule(BASIS, wasmBinary);
+    return await initializeBasisTranscoderModule(BASIS, wasmBinary);
   }
-  function initializeBasisTrascoderModule(BasisModule, wasmBinary) {
+  function initializeBasisTranscoderModule(BasisModule, wasmBinary) {
     const options = {};
     if (wasmBinary) {
       options.wasmBinary = wasmBinary;
@@ -7822,8 +7864,8 @@
     let BASIS_ENCODER = null;
     let wasmBinary = null;
     [BASIS_ENCODER, wasmBinary] = await Promise.all([
-      await loadLibrary(BASIS_CDN_ENCODER_JS, "textures", options),
-      await loadLibrary(BASIS_CDN_ENCODER_WASM, "textures", options)
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER, "textures", options),
+      await loadLibrary(BASIS_EXTERNAL_LIBRARIES.ENCODER_WASM, "textures", options)
     ]);
     BASIS_ENCODER = BASIS_ENCODER || globalThis.BASIS;
     return await initializeBasisEncoderModule(BASIS_ENCODER, wasmBinary);
@@ -7841,13 +7883,16 @@
       });
     });
   }
-  var VERSION8, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
+  var BASIS_EXTERNAL_LIBRARIES, loadBasisTranscoderPromise, loadBasisEncoderPromise;
   var init_basis_module_loader = __esm({
     "../textures/src/lib/parsers/basis-module-loader.ts"() {
       init_src();
-      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
-      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.wasm`;
-      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION8}/dist/libs/basis_encoder.js`;
+      BASIS_EXTERNAL_LIBRARIES = {
+        TRANSCODER: "basis_transcoder.js",
+        TRANSCODER_WASM: "basis_transcoder.wasm",
+        ENCODER: "basis_encoder.js",
+        ENCODER_WASM: "basis_encoder.wasm"
+      };
     }
   });
 
@@ -8223,7 +8268,7 @@
         const fileConstructors = await loadBasisEncoderModule(options);
         return parseKTX2File(fileConstructors.KTX2File, data, options);
       }
-      const { BasisFile } = await loadBasisTrascoderModule(options);
+      const { BasisFile } = await loadBasisTranscoderModule(options);
       return parseBasisFile(BasisFile, data, options);
     }
     switch (options.basis.module) {
@@ -8238,7 +8283,7 @@
         }
       case "transcoder":
       default:
-        const { BasisFile } = await loadBasisTrascoderModule(options);
+        const { BasisFile } = await loadBasisTranscoderModule(options);
         return parseBasisFile(BasisFile, data, options);
     }
   }
@@ -8830,9 +8875,9 @@
     }
     return attributeUrls;
   }
-  function generateTilesetAttributeUrls(tileset, resource) {
+  function generateTilesetAttributeUrls(tileset, url, resource) {
     const attributeUrls = [];
-    const { attributeStorageInfo, url } = tileset;
+    const { attributeStorageInfo = [] } = tileset;
     for (let index = 0; index < attributeStorageInfo.length; index++) {
       const fileName = attributeStorageInfo[index].key;
       attributeUrls.push(`${url}/nodes/${resource}/attributes/${fileName}/0`);
@@ -8993,20 +9038,20 @@
     }
     return value;
   }
-  var VERSION9, EMPTY_VALUE, REJECTED_STATUS, I3SAttributeLoader;
+  var VERSION8, EMPTY_VALUE, REJECTED_STATUS, I3SAttributeLoader;
   var init_i3s_attribute_loader = __esm({
     "src/i3s-attribute-loader.ts"() {
       init_src3();
       init_parse_i3s_attribute();
       init_url_utils2();
-      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       EMPTY_VALUE = "";
       REJECTED_STATUS = "rejected";
       I3SAttributeLoader = {
         name: "I3S Attribute",
         id: "i3s-attribute",
         module: "i3s",
-        version: VERSION9,
+        version: VERSION8,
         mimeTypes: ["application/binary"],
         parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
         extensions: ["bin"],
@@ -9489,17 +9534,17 @@
     }
     return await parseI3STileContent(data, tileOptions, tilesetOptions, options, context);
   }
-  var VERSION10, I3SContentLoader;
+  var VERSION9, I3SContentLoader;
   var init_i3s_content_loader = __esm({
     "src/i3s-content-loader.ts"() {
       init_parse_i3s_tile_content();
-      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       I3SContentLoader = {
         name: "I3S Content (Indexed Scene Layers)",
         id: "i3s-content",
         module: "i3s",
         worker: true,
-        version: VERSION10,
+        version: VERSION9,
         mimeTypes: ["application/octet-stream"],
         parse: parse3,
         extensions: ["bin"],
@@ -10103,15 +10148,15 @@
   async function parseNodePage(data, options) {
     return JSON.parse(new TextDecoder().decode(data));
   }
-  var VERSION11, I3SNodePageLoader;
+  var VERSION10, I3SNodePageLoader;
   var init_i3s_node_page_loader = __esm({
     "src/i3s-node-page-loader.ts"() {
-      VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       I3SNodePageLoader = {
         name: "I3S Node Page",
         id: "i3s-node-page",
         module: "i3s",
-        version: VERSION11,
+        version: VERSION10,
         mimeTypes: ["application/json"],
         parse: parseNodePage,
         extensions: ["json"],
@@ -10130,12 +10175,13 @@
       init_parse_i3s();
       init_url_utils2();
       I3SNodePagesTiles = class {
-        constructor(tileset, options) {
+        constructor(tileset, url = "", options) {
           this.nodePages = [];
           this.pendingNodePages = [];
           this.textureDefinitionsSelectedFormats = [];
           this.textureLoaderOptions = {};
           this.tileset = { ...tileset };
+          this.url = url;
           this.nodesPerPage = tileset.nodePages?.nodesPerPage || 64;
           this.lodSelectionMetricType = tileset.nodePages?.lodSelectionMetricType;
           this.options = options;
@@ -10145,7 +10191,7 @@
         async getNodeById(id) {
           const pageIndex = Math.floor(id / this.nodesPerPage);
           if (!this.nodePages[pageIndex] && !this.pendingNodePages[pageIndex]) {
-            const nodePageUrl = getUrlWithToken(`${this.tileset.url}/nodepages/${pageIndex}`, this.options.i3s?.token);
+            const nodePageUrl = getUrlWithToken(`${this.url}/nodepages/${pageIndex}`, this.options.i3s?.token);
             this.pendingNodePages[pageIndex] = {
               status: "Pending",
               promise: load(nodePageUrl, I3SNodePageLoader, this.options)
@@ -10161,10 +10207,10 @@
           return this.nodePages[pageIndex].nodes[nodeIndex];
         }
         async formTileFromNodePages(id) {
-          const node3 = await this.getNodeById(id);
+          const node4 = await this.getNodeById(id);
           const children = [];
           const childNodesPromises = [];
-          for (const child of node3.children || []) {
+          for (const child of node4.children || []) {
             childNodesPromises.push(this.getNodeById(child));
           }
           const childNodes = await Promise.all(childNodesPromises);
@@ -10180,25 +10226,25 @@
           let textureFormat = "jpg";
           let attributeUrls = [];
           let isDracoGeometry = false;
-          if (node3 && node3.mesh) {
-            const { url, isDracoGeometry: isDracoGeometryResult } = node3.mesh.geometry && this.getContentUrl(node3.mesh.geometry) || { isDracoGeometry: false };
+          if (node4 && node4.mesh) {
+            const { url, isDracoGeometry: isDracoGeometryResult } = node4.mesh.geometry && this.getContentUrl(node4.mesh.geometry) || { isDracoGeometry: false };
             contentUrl = url;
             isDracoGeometry = isDracoGeometryResult;
-            const { textureData, materialDefinition: nodeMaterialDefinition } = this.getInformationFromMaterial(node3.mesh.material);
+            const { textureData, materialDefinition: nodeMaterialDefinition } = this.getInformationFromMaterial(node4.mesh.material);
             materialDefinition = nodeMaterialDefinition;
             textureFormat = textureData.format || textureFormat;
             if (textureData.name) {
-              textureUrl = `${this.tileset.url}/nodes/${node3.mesh.material.resource}/textures/${textureData.name}`;
+              textureUrl = `${this.url}/nodes/${node4.mesh.material.resource}/textures/${textureData.name}`;
             }
             if (this.tileset.attributeStorageInfo) {
-              attributeUrls = generateTilesetAttributeUrls(this.tileset, node3.mesh.attribute.resource);
+              attributeUrls = generateTilesetAttributeUrls(this.tileset, this.url, node4.mesh.attribute.resource);
             }
           }
-          const lodSelection = this.getLodSelection(node3);
+          const lodSelection = this.getLodSelection(node4);
           return normalizeTileNonUrlData({
             id: id.toString(),
             lodSelection,
-            obb: node3.obb,
+            obb: node4.obb,
             contentUrl,
             textureUrl,
             attributeUrls,
@@ -10222,23 +10268,23 @@
           if (geometryIndex !== -1) {
             const isDracoGeometry = Boolean(geometryDefinition.geometryBuffers[geometryIndex].compressedAttributes);
             result = {
-              url: `${this.tileset.url}/nodes/${meshGeometryData.resource}/geometries/${geometryIndex}`,
+              url: `${this.url}/nodes/${meshGeometryData.resource}/geometries/${geometryIndex}`,
               isDracoGeometry
             };
           }
           return result;
         }
-        getLodSelection(node3) {
+        getLodSelection(node4) {
           const lodSelection = [];
           if (this.lodSelectionMetricType === "maxScreenThresholdSQ") {
             lodSelection.push({
               metricType: "maxScreenThreshold",
-              maxError: Math.sqrt(node3.lodThreshold / (Math.PI * 0.25))
+              maxError: Math.sqrt(node4.lodThreshold / (Math.PI * 0.25))
             });
           }
           lodSelection.push({
             metricType: this.lodSelectionMetricType,
-            maxError: node3.lodThreshold
+            maxError: node4.lodThreshold
           });
           return lodSelection;
         }
@@ -10315,11 +10361,14 @@
     if (tile.attributeData) {
       attributeUrls = generateTileAttributeUrls(url, tile);
     }
+    const children = tile.children || [];
     return normalizeTileNonUrlData({
       ...tile,
+      children,
       url,
       contentUrl,
       textureUrl,
+      textureFormat: "jpg",
       attributeUrls,
       isDracoGeometry: false
     });
@@ -10346,19 +10395,20 @@
     }
     const lodMetricType = tile.lodSelection?.[0].metricType;
     const lodMetricValue = tile.lodSelection?.[0].maxError;
-    const transformMatrix = tile.transform;
     const type = TILE_TYPE.MESH;
     const refine = TILE_REFINEMENT.REPLACE;
-    return { ...tile, mbs, boundingVolume, lodMetricType, lodMetricValue, transformMatrix, type, refine };
+    return { ...tile, mbs, boundingVolume, lodMetricType, lodMetricValue, type, refine };
   }
   async function normalizeTilesetData(tileset, options, context) {
-    tileset.url = context.url;
+    const url = context.url;
+    let nodePagesTile;
+    let root;
     if (tileset.nodePages) {
-      tileset.nodePagesTile = new I3SNodePagesTiles(tileset, options);
-      tileset.root = tileset.nodePagesTile.formTileFromNodePages(0);
+      nodePagesTile = new I3SNodePagesTiles(tileset, url, options);
+      root = await nodePagesTile.formTileFromNodePages(0);
     } else {
       const rootNodeUrl = getUrlWithToken(`${tileset.url}/nodes/root`, options.i3s?.token);
-      tileset.root = await load(rootNodeUrl, tileset.loader, {
+      root = await load(rootNodeUrl, I3SLoader, {
         ...options,
         i3s: {
           ...options.i3s,
@@ -10368,10 +10418,17 @@
         }
       });
     }
-    tileset.basePath = tileset.url;
-    tileset.type = TILESET_TYPE.I3S;
-    tileset.lodMetricType = tileset.root.lodMetricType;
-    tileset.lodMetricValue = tileset.root.lodMetricValue;
+    return {
+      ...tileset,
+      loader: I3SLoader,
+      url,
+      basePath: url,
+      type: TILESET_TYPE.I3S,
+      nodePagesTile,
+      root,
+      lodMetricType: root.lodMetricType,
+      lodMetricValue: root.lodMetricValue
+    };
   }
   var init_parse_i3s = __esm({
     "src/lib/parsers/parse-i3s.ts"() {
@@ -10381,6 +10438,7 @@
       init_src8();
       init_i3s_nodepages_tiles();
       init_url_utils2();
+      init_i3s_loader();
     }
   });
 
@@ -10421,9 +10479,8 @@
     if (tilesetJson?.layerType === POINT_CLOUD) {
       throw new Error("Point Cloud layers currently are not supported by I3SLoader");
     }
-    tilesetJson.loader = I3SLoader;
-    await normalizeTilesetData(tilesetJson, options, context);
-    return tilesetJson;
+    const tilesetPostprocessed = await normalizeTilesetData(tilesetJson, options, context);
+    return tilesetPostprocessed;
   }
   async function parseTile(data, context) {
     data = JSON.parse(new TextDecoder().decode(data));
@@ -10435,14 +10492,14 @@
     }
     return null;
   }
-  var VERSION12, TILESET_REGEX, TILE_HEADER_REGEX, SLPK_HEX, POINT_CLOUD, I3SLoader;
+  var VERSION11, TILESET_REGEX, TILE_HEADER_REGEX, SLPK_HEX, POINT_CLOUD, I3SLoader;
   var init_i3s_loader = __esm({
     "src/i3s-loader.ts"() {
       init_src3();
       init_i3s_content_loader();
       init_parse_i3s();
       init_constants();
-      VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       TILESET_REGEX = /layers\/[0-9]+$/;
       TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
       SLPK_HEX = "504b0304";
@@ -10451,7 +10508,7 @@
         name: "I3S (Indexed Scene Layers)",
         id: "i3s",
         module: "i3s",
-        version: VERSION12,
+        version: VERSION11,
         mimeTypes: ["application/octet-stream"],
         parse: parseI3S,
         extensions: ["bin"],
@@ -11361,7 +11418,7 @@
         var elems = desc.stat_desc.elems;
         var n2, m;
         var max_code = -1;
-        var node3;
+        var node4;
         s2.heap_len = 0;
         s2.heap_max = HEAP_SIZE;
         for (n2 = 0; n2 < elems; n2++) {
@@ -11373,19 +11430,19 @@
           }
         }
         while (s2.heap_len < 2) {
-          node3 = s2.heap[++s2.heap_len] = max_code < 2 ? ++max_code : 0;
-          tree[node3 * 2] = 1;
-          s2.depth[node3] = 0;
+          node4 = s2.heap[++s2.heap_len] = max_code < 2 ? ++max_code : 0;
+          tree[node4 * 2] = 1;
+          s2.depth[node4] = 0;
           s2.opt_len--;
           if (has_stree) {
-            s2.static_len -= stree[node3 * 2 + 1];
+            s2.static_len -= stree[node4 * 2 + 1];
           }
         }
         desc.max_code = max_code;
         for (n2 = s2.heap_len >> 1; n2 >= 1; n2--) {
           pqdownheap(s2, tree, n2);
         }
-        node3 = elems;
+        node4 = elems;
         do {
           n2 = s2.heap[1];
           s2.heap[1] = s2.heap[s2.heap_len--];
@@ -11393,10 +11450,10 @@
           m = s2.heap[1];
           s2.heap[--s2.heap_max] = n2;
           s2.heap[--s2.heap_max] = m;
-          tree[node3 * 2] = tree[n2 * 2] + tree[m * 2];
-          s2.depth[node3] = (s2.depth[n2] >= s2.depth[m] ? s2.depth[n2] : s2.depth[m]) + 1;
-          tree[n2 * 2 + 1] = tree[m * 2 + 1] = node3;
-          s2.heap[1] = node3++;
+          tree[node4 * 2] = tree[n2 * 2] + tree[m * 2];
+          s2.depth[node4] = (s2.depth[n2] >= s2.depth[m] ? s2.depth[n2] : s2.depth[m]) + 1;
+          tree[n2 * 2 + 1] = tree[m * 2 + 1] = node4;
+          s2.heap[1] = node4++;
           pqdownheap(s2, tree, 1);
         } while (s2.heap_len >= 2);
         s2.heap[--s2.heap_max] = s2.heap[1];
@@ -15396,17 +15453,17 @@
   async function parseSLPK2(data, options = {}) {
     return (await parseSLPK(new DataViewFileProvider(new DataView(data)))).getFile(options.slpk?.path ?? "", options.slpk?.pathMode);
   }
-  var VERSION13, SLPKLoader;
+  var VERSION12, SLPKLoader;
   var init_i3s_slpk_loader = __esm({
     "src/i3s-slpk-loader.ts"() {
       init_parse_slpk();
       init_data_view_file_provider();
-      VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       SLPKLoader = {
         name: "I3S SLPK (Scene Layer Package)",
         id: "slpk",
         module: "i3s",
-        version: VERSION13,
+        version: VERSION12,
         mimeTypes: ["application/octet-stream"],
         parse: parseSLPK2,
         extensions: ["slpk"],
@@ -15459,16 +15516,16 @@
     }
     return parseBuildingSceneLayer(data, context.url);
   }
-  var VERSION14, I3SBuildingSceneLayerLoader;
+  var VERSION13, I3SBuildingSceneLayerLoader;
   var init_i3s_building_scene_layer_loader = __esm({
     "src/i3s-building-scene-layer-loader.ts"() {
       init_parse_i3s_building_scene_layer();
-      VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       I3SBuildingSceneLayerLoader = {
         name: "I3S Building Scene Layer",
         id: "i3s-building-scene-layer",
         module: "i3s",
-        version: VERSION14,
+        version: VERSION13,
         mimeTypes: ["application/json"],
         parse: parse4,
         extensions: ["json"],
@@ -15549,16 +15606,16 @@
   async function parse5(data) {
     return parseWebscene(data);
   }
-  var VERSION15, ArcGisWebSceneLoader;
+  var VERSION14, ArcGisWebSceneLoader;
   var init_arcgis_webscene_loader = __esm({
     "src/arcgis-webscene-loader.ts"() {
       init_parse_arcgis_webscene();
-      VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       ArcGisWebSceneLoader = {
         name: "ArcGIS Web Scene Loader",
         id: "arcgis-web-scene",
         module: "i3s",
-        version: VERSION15,
+        version: VERSION14,
         mimeTypes: ["application/json"],
         parse: parse5,
         extensions: ["json"],

package/dist/es5/arcgis-webscene-loader.js

@@ -8,7 +8,7 @@ exports.ArcGisWebSceneLoader = void 0;
 var _regenerator = _interopRequireDefault(require("@babel/runtime/regenerator"));
 var _asyncToGenerator2 = _interopRequireDefault(require("@babel/runtime/helpers/asyncToGenerator"));
 var _parseArcgisWebscene = require("./lib/parsers/parse-arcgis-webscene");
-var VERSION = typeof "4.0.0-alpha.17" !== 'undefined' ? "4.0.0-alpha.17" : 'beta';
+var VERSION = typeof "4.0.0-alpha.19" !== 'undefined' ? "4.0.0-alpha.19" : 'beta';
 var ArcGisWebSceneLoader = {
   name: 'ArcGIS Web Scene Loader',
   id: 'arcgis-web-scene',

package/dist/es5/i3s-attribute-loader.js

@@ -15,7 +15,7 @@ var _parseI3sAttribute = require("./lib/parsers/parse-i3s-attribute");
 var _urlUtils = require("./lib/utils/url-utils");
 function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
-var VERSION = typeof "4.0.0-alpha.17" !== 'undefined' ? "4.0.0-alpha.17" : 'latest';
+var VERSION = typeof "4.0.0-alpha.19" !== 'undefined' ? "4.0.0-alpha.19" : 'latest';
 var EMPTY_VALUE = '';
 var REJECTED_STATUS = 'rejected';
 var I3SAttributeLoader = {