@loaders.gl/i3s 4.0.0-alpha.6 → 4.0.0-alpha.8

package/dist/dist.min.js

@@ -941,6 +941,22 @@
     }
     return false;
   }
+  function getTransferListForWriter(object) {
+    if (object === null) {
+      return {};
+    }
+    const clone3 = Object.assign({}, object);
+    Object.keys(clone3).forEach((key) => {
+      if (typeof object[key] === "object" && !ArrayBuffer.isView(object[key]) && !(object[key] instanceof Array)) {
+        clone3[key] = getTransferListForWriter(object[key]);
+      } else if (typeof clone3[key] === "function" || clone3[key] instanceof RegExp) {
+        clone3[key] = {};
+      } else {
+        clone3[key] = object[key];
+      }
+    });
+    return clone3;
+  }
   var init_get_transfer_list = __esm({
     "../worker-utils/src/lib/worker-utils/get-transfer-list.ts"() {
     }
@@ -1088,9 +1104,9 @@
             this.onDebug = props.onDebug;
           }
         }
-        async startJob(name, onMessage2 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
+        async startJob(name, onMessage3 = (job, type, data) => job.done(data), onError = (job, error) => job.error(error)) {
           const startPromise = new Promise((onStart) => {
-            this.jobQueue.push({ name, onMessage: onMessage2, onError, onStart });
+            this.jobQueue.push({ name, onMessage: onMessage3, onError, onStart });
             return this;
           });
           this._startQueuedJob();
@@ -1124,7 +1140,7 @@
           }
         }
         returnWorkerToQueue(worker) {
-          const shouldDestroyWorker = this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
+          const shouldDestroyWorker = !isBrowser2 || this.isDestroyed || !this.reuseWorkers || this.count > this._getMaxConcurrency();
           if (shouldDestroyWorker) {
             worker.destroy();
             this.count--;
@@ -1220,9 +1236,13 @@
   });
 
   // ../worker-utils/src/lib/worker-api/get-worker-url.ts
+  function getWorkerName(worker) {
+    const warning = worker.version !== VERSION2 ? ` (worker-utils@${VERSION2})` : "";
+    return `${worker.name}@${worker.version}${warning}`;
+  }
   function getWorkerURL(worker, options = {}) {
     const workerOptions = options[worker.id] || {};
-    const workerFile = `${worker.id}-worker.js`;
+    const workerFile = isBrowser2 ? `${worker.id}-worker.js` : `${worker.id}-worker-node.js`;
     let url = workerOptions.workerUrl;
     if (!url && worker.id === "compression") {
       url = options.workerUrl;
@@ -1241,11 +1261,65 @@
     assert2(url);
     return url;
   }
-  var NPM_TAG;
+  var NPM_TAG, VERSION2;
   var init_get_worker_url = __esm({
     "../worker-utils/src/lib/worker-api/get-worker-url.ts"() {
       init_assert2();
+      init_globals2();
+      init_version();
       NPM_TAG = "beta";
+      VERSION2 = typeof VERSION !== "undefined" ? VERSION : NPM_TAG;
+    }
+  });
+
+  // ../worker-utils/src/lib/worker-api/process-on-worker.ts
+  async function processOnWorker(worker, data, options = {}, context = {}) {
+    const name = getWorkerName(worker);
+    const workerFarm = WorkerFarm.getWorkerFarm(options);
+    const { source } = options;
+    const workerPoolProps = { name, source };
+    if (!source) {
+      workerPoolProps.url = getWorkerURL(worker, options);
+    }
+    const workerPool = workerFarm.getWorkerPool(workerPoolProps);
+    const jobName = options.jobName || worker.name;
+    const job = await workerPool.startJob(jobName, onMessage.bind(null, context));
+    const transferableOptions = getTransferListForWriter(options);
+    job.postMessage("process", { input: data, options: transferableOptions });
+    const result = await job.result;
+    return result.result;
+  }
+  async function onMessage(context, job, type, payload) {
+    switch (type) {
+      case "done":
+        job.done(payload);
+        break;
+      case "error":
+        job.error(new Error(payload.error));
+        break;
+      case "process":
+        const { id, input, options } = payload;
+        try {
+          if (!context.process) {
+            job.postMessage("error", { id, error: "Worker not set up to process on main thread" });
+            return;
+          }
+          const result = await context.process(input, options);
+          job.postMessage("done", { id, result });
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unknown error";
+          job.postMessage("error", { id, error: message });
+        }
+        break;
+      default:
+        console.warn(`process-on-worker: unknown message ${type}`);
+    }
+  }
+  var init_process_on_worker = __esm({
+    "../worker-utils/src/lib/worker-api/process-on-worker.ts"() {
+      init_worker_farm();
+      init_get_worker_url();
+      init_get_transfer_list();
     }
   });
 
@@ -1292,7 +1366,7 @@
     }
     if (options.CDN) {
       assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION2}/dist/libs/${library}`;
+      return `${options.CDN}/${moduleName}@${VERSION3}/dist/libs/${library}`;
     }
     if (isWorker) {
       return `../src/libs/${library}`;
@@ -1336,7 +1410,7 @@
     document.body.appendChild(script);
     return null;
   }
-  var node, LATEST, VERSION2, loadLibraryPromises;
+  var node, LATEST, VERSION3, loadLibraryPromises;
   var init_library_utils = __esm({
     "../worker-utils/src/lib/library-utils/library-utils.ts"() {
       init_globals2();
@@ -1344,7 +1418,7 @@
       init_assert2();
       init_version();
       LATEST = "beta";
-      VERSION2 = typeof VERSION !== "undefined" ? VERSION : LATEST;
+      VERSION3 = typeof VERSION !== "undefined" ? VERSION : LATEST;
       loadLibraryPromises = {};
     }
   });
@@ -1355,6 +1429,7 @@
       init_assert2();
       init_globals2();
       init_worker_farm();
+      init_process_on_worker();
       init_get_worker_url();
       init_validate_worker_version();
       init_library_utils();
@@ -1378,7 +1453,7 @@
     const workerPool = workerFarm.getWorkerPool({ name, url });
     options = JSON.parse(JSON.stringify(options));
     context = JSON.parse(JSON.stringify(context || {}));
-    const job = await workerPool.startJob("process-on-worker", onMessage.bind(null, parseOnMainThread));
+    const job = await workerPool.startJob("process-on-worker", onMessage2.bind(null, parseOnMainThread));
     job.postMessage("process", {
       input: data,
       options,
@@ -1387,7 +1462,7 @@
     const result = await job.result;
     return await result.result;
   }
-  async function onMessage(parseOnMainThread, job, type, payload) {
+  async function onMessage2(parseOnMainThread, job, type, payload) {
     switch (type) {
       case "done":
         job.done(payload);
@@ -1552,15 +1627,15 @@
   function parseTextSync(text) {
     return JSON.parse(text);
   }
-  var VERSION3, JSONLoader;
+  var VERSION4, JSONLoader;
   var init_json_loader = __esm({
     "../loader-utils/src/json-loader.ts"() {
-      VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       JSONLoader = {
         name: "JSON",
         id: "json",
         module: "json",
-        version: VERSION3,
+        version: VERSION4,
         extensions: ["json", "geojson"],
         mimeTypes: ["application/json"],
         category: "json",
@@ -1822,39 +1897,60 @@
     }
   });
 
+  // ../core/src/lib/utils/url-utils.ts
+  function extractQueryString(url) {
+    const matches3 = url.match(QUERY_STRING_PATTERN);
+    return matches3 && matches3[0];
+  }
+  function stripQueryString(url) {
+    return url.replace(QUERY_STRING_PATTERN, "");
+  }
+  var QUERY_STRING_PATTERN;
+  var init_url_utils = __esm({
+    "../core/src/lib/utils/url-utils.ts"() {
+      QUERY_STRING_PATTERN = /\?.*/;
+    }
+  });
+
   // ../core/src/lib/utils/resource-utils.ts
-  function getResourceUrlAndType(resource) {
+  function getResourceUrl(resource) {
     if (isResponse(resource)) {
-      const url = stripQueryString(resource.url || "");
-      const contentTypeHeader = resource.headers.get("content-type") || "";
-      return {
-        url,
-        type: parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(url)
-      };
+      const response = resource;
+      return response.url;
     }
     if (isBlob(resource)) {
-      return {
-        url: stripQueryString(resource.name || ""),
-        type: resource.type || ""
-      };
+      const blob = resource;
+      return blob.name || "";
     }
     if (typeof resource === "string") {
-      return {
-        url: stripQueryString(resource),
-        type: parseMIMETypeFromURL(resource)
-      };
+      return resource;
     }
-    return {
-      url: "",
-      type: ""
-    };
+    return "";
+  }
+  function getResourceMIMEType(resource) {
+    if (isResponse(resource)) {
+      const response = resource;
+      const contentTypeHeader = response.headers.get("content-type") || "";
+      const noQueryUrl = stripQueryString(response.url);
+      return parseMIMEType(contentTypeHeader) || parseMIMETypeFromURL(noQueryUrl);
+    }
+    if (isBlob(resource)) {
+      const blob = resource;
+      return blob.type || "";
+    }
+    if (typeof resource === "string") {
+      return parseMIMETypeFromURL(resource);
+    }
+    return "";
   }
   function getResourceContentLength(resource) {
     if (isResponse(resource)) {
-      return resource.headers["content-length"] || -1;
+      const response = resource;
+      return response.headers["content-length"] || -1;
     }
     if (isBlob(resource)) {
-      return resource.size;
+      const blob = resource;
+      return blob.size;
     }
     if (typeof resource === "string") {
       return resource.length;
@@ -1867,15 +1963,11 @@
     }
     return -1;
   }
-  function stripQueryString(url) {
-    return url.replace(QUERY_STRING_PATTERN, "");
-  }
-  var QUERY_STRING_PATTERN;
   var init_resource_utils = __esm({
     "../core/src/lib/utils/resource-utils.ts"() {
       init_is_type();
       init_mime_type_utils();
-      QUERY_STRING_PATTERN = /\?.*/;
+      init_url_utils();
     }
   });
 
@@ -1889,7 +1981,8 @@
     if (contentLength >= 0) {
       headers["content-length"] = String(contentLength);
     }
-    const { url, type } = getResourceUrlAndType(resource);
+    const url = getResourceUrl(resource);
+    const type = getResourceMIMEType(resource);
     if (type) {
       headers["content-type"] = type;
     }
@@ -1978,7 +2071,7 @@
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/lib/is-electron.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js
   function isElectron(mockUserAgent) {
     if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
       return true;
@@ -1994,25 +2087,25 @@
     return false;
   }
   var init_is_electron = __esm({
-    "../../node_modules/@probe.gl/env/dist/lib/is-electron.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-electron.js"() {
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/lib/is-browser.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js
   function isBrowser3() {
     const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
     return !isNode || isElectron();
   }
   var init_is_browser = __esm({
-    "../../node_modules/@probe.gl/env/dist/lib/is-browser.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/is-browser.js"() {
       init_is_electron();
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/lib/globals.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js
   var self_3, window_3, document_3, process_, console_, navigator_;
   var init_globals3 = __esm({
-    "../../node_modules/@probe.gl/env/dist/lib/globals.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/lib/globals.js"() {
       self_3 = globalThis.self || globalThis.window || globalThis.global;
       window_3 = globalThis.window || globalThis.self || globalThis.global;
       document_3 = globalThis.document || {};
@@ -2022,19 +2115,19 @@
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/utils/globals.js
-  var VERSION4, isBrowser4;
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js
+  var VERSION5, isBrowser4;
   var init_globals4 = __esm({
-    "../../node_modules/@probe.gl/env/dist/utils/globals.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/utils/globals.js"() {
       init_is_browser();
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
       isBrowser4 = isBrowser3();
     }
   });
 
-  // ../../node_modules/@probe.gl/env/dist/index.js
+  // ../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/index.js
   var init_dist = __esm({
-    "../../node_modules/@probe.gl/env/dist/index.js"() {
+    "../../node_modules/@probe.gl/log/node_modules/@probe.gl/env/dist/index.js"() {
       init_globals4();
       init_globals3();
       init_is_browser();
@@ -2364,7 +2457,7 @@
             id: ""
           };
           _defineProperty(this, "id", void 0);
-          _defineProperty(this, "VERSION", VERSION4);
+          _defineProperty(this, "VERSION", VERSION5);
           _defineProperty(this, "_startTs", getHiResTimestamp());
           _defineProperty(this, "_deltaTs", getHiResTimestamp());
           _defineProperty(this, "_storage", void 0);
@@ -2567,7 +2660,7 @@
           return noop;
         }
       };
-      _defineProperty(Log, "VERSION", VERSION4);
+      _defineProperty(Log, "VERSION", VERSION5);
     }
   });
 
@@ -2875,8 +2968,9 @@
     return loader;
   }
   function selectLoaderInternal(data, loaders, options, context) {
-    const { url, type } = getResourceUrlAndType(data);
-    const testUrl = url || context?.url;
+    const url = getResourceUrl(data);
+    const type = getResourceMIMEType(data);
+    const testUrl = stripQueryString(url) || context?.url;
     let loader = null;
     let reason = "";
     if (options?.mimeType) {
@@ -2905,7 +2999,8 @@
     return true;
   }
   function getNoValidLoaderMessage(data) {
-    const { url, type } = getResourceUrlAndType(data);
+    const url = getResourceUrl(data);
+    const type = getResourceMIMEType(data);
     let message = "No valid loader found (";
     message += url ? `${path_exports.filename(url)}, ` : "no url provided, ";
     message += `MIME type: ${type ? `"${type}"` : "not provided"}, `;
@@ -3024,6 +3119,7 @@
       init_resource_utils();
       init_register_loaders();
       init_is_type();
+      init_url_utils();
       EXT_PATTERN = /\.([^.]+)$/;
     }
   });
@@ -3236,18 +3332,25 @@
   });
 
   // ../core/src/lib/loader-utils/loader-context.ts
-  function getLoaderContext(context, options, previousContext = null) {
-    if (previousContext) {
-      return previousContext;
+  function getLoaderContext(context, options, parentContext) {
+    if (parentContext) {
+      return parentContext;
     }
-    const resolvedContext = {
+    const newContext = {
       fetch: getFetchFunction(options, context),
       ...context
     };
-    if (!Array.isArray(resolvedContext.loaders)) {
-      resolvedContext.loaders = null;
+    if (newContext.url) {
+      const baseUrl = stripQueryString(newContext.url);
+      newContext.baseUrl = baseUrl;
+      newContext.queryString = extractQueryString(newContext.url);
+      newContext.filename = path_exports.filename(baseUrl);
+      newContext.baseUrl = path_exports.dirname(baseUrl);
+    }
+    if (!Array.isArray(newContext.loaders)) {
+      newContext.loaders = null;
     }
-    return resolvedContext;
+    return newContext;
   }
   function getLoadersFromContext(loaders, context) {
     if (!context && loaders && !Array.isArray(loaders)) {
@@ -3266,6 +3369,8 @@
   var init_loader_context = __esm({
     "../core/src/lib/loader-utils/loader-context.ts"() {
       init_get_fetch_function();
+      init_url_utils();
+      init_src2();
     }
   });
 
@@ -3279,7 +3384,7 @@
     }
     data = await data;
     options = options || {};
-    const { url } = getResourceUrlAndType(data);
+    const url = getResourceUrl(data);
     const typedLoaders = loaders;
     const candidateLoaders = getLoadersFromContext(typedLoaders, context);
     const loader = await selectLoader(data, candidateLoaders, options);
@@ -3287,7 +3392,7 @@
       return null;
     }
     options = normalizeOptions(options, loader, candidateLoaders, url);
-    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context);
+    context = getLoaderContext({ url, parse, loaders: candidateLoaders }, options, context || null);
     return await parseWithLoader(loader, data, options, context);
   }
   async function parseWithLoader(loader, data, options, context) {
@@ -6685,10 +6790,10 @@
   });
 
   // ../images/src/lib/utils/version.ts
-  var VERSION5;
+  var VERSION6;
   var init_version2 = __esm({
     "../images/src/lib/utils/version.ts"() {
-      VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -7137,7 +7242,7 @@
         id: "image",
         module: "images",
         name: "Images",
-        version: VERSION5,
+        version: VERSION6,
         mimeTypes: MIME_TYPES,
         extensions: EXTENSIONS,
         parse: parseImage,
@@ -7155,10 +7260,10 @@
   });
 
   // ../draco/src/lib/utils/version.ts
-  var VERSION6;
+  var VERSION7;
   var init_version3 = __esm({
     "../draco/src/lib/utils/version.ts"() {
-      VERSION6 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
     }
   });
 
@@ -7166,7 +7271,6 @@
   var DEFAULT_DRACO_OPTIONS, DracoLoader;
   var init_draco_loader = __esm({
     "../draco/src/draco-loader.ts"() {
-      init_src();
       init_version3();
       DEFAULT_DRACO_OPTIONS = {
         draco: {
@@ -7178,9 +7282,9 @@
       };
       DracoLoader = {
         name: "Draco",
-        id: isBrowser2 ? "draco" : "draco-nodejs",
+        id: "draco",
         module: "draco",
-        version: VERSION6,
+        version: VERSION7,
         worker: true,
         extensions: ["drc"],
         mimeTypes: ["application/octet-stream"],
@@ -7758,10 +7862,10 @@
   });
 
   // ../textures/src/lib/utils/version.ts
-  var VERSION7;
+  var VERSION8;
   var init_version4 = __esm({
     "../textures/src/lib/utils/version.ts"() {
-      VERSION7 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION8 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
     }
   });
 
@@ -7828,13 +7932,13 @@
       });
     });
   }
-  var VERSION8, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, loadBasisTranscoderPromise, loadBasisEncoderPromise;
+  var VERSION9, BASIS_CDN_ENCODER_WASM, BASIS_CDN_ENCODER_JS, 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`;
+      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      BASIS_CDN_ENCODER_WASM = `https://unpkg.com/@loaders.gl/textures@${VERSION9}/dist/libs/basis_encoder.wasm`;
+      BASIS_CDN_ENCODER_JS = `https://unpkg.com/@loaders.gl/textures@${VERSION9}/dist/libs/basis_encoder.js`;
     }
   });
 
@@ -8395,14 +8499,13 @@
   var BasisWorkerLoader, BasisLoader;
   var init_basis_loader = __esm({
     "../textures/src/basis-loader.ts"() {
-      init_src();
       init_version4();
       init_parse_basis();
       BasisWorkerLoader = {
         name: "Basis",
-        id: isBrowser2 ? "basis" : "basis-nodejs",
+        id: "basis",
         module: "textures",
-        version: VERSION7,
+        version: VERSION8,
         worker: true,
         extensions: ["basis", "ktx2"],
         mimeTypes: ["application/octet-stream", "image/ktx2"],
@@ -8745,7 +8848,7 @@
         name: "Texture Containers",
         id: "compressed-texture",
         module: "textures",
-        version: VERSION7,
+        version: VERSION8,
         worker: true,
         extensions: [
           "ktx",
@@ -8816,7 +8919,7 @@
     }
     return attributeUrls;
   }
-  var init_url_utils = __esm({
+  var init_url_utils2 = __esm({
     "src/lib/utils/url-utils.ts"() {
     }
   });
@@ -8970,20 +9073,20 @@
     }
     return value;
   }
-  var VERSION9, EMPTY_VALUE, REJECTED_STATUS, I3SAttributeLoader;
+  var VERSION10, EMPTY_VALUE, REJECTED_STATUS, I3SAttributeLoader;
   var init_i3s_attribute_loader = __esm({
     "src/i3s-attribute-loader.ts"() {
       init_src3();
       init_parse_i3s_attribute();
-      init_url_utils();
-      VERSION9 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      init_url_utils2();
+      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       EMPTY_VALUE = "";
       REJECTED_STATUS = "rejected";
       I3SAttributeLoader = {
         name: "I3S Attribute",
         id: "i3s-attribute",
         module: "i3s",
-        version: VERSION9,
+        version: VERSION10,
         mimeTypes: ["application/binary"],
         parse: async (arrayBuffer, options) => parseI3STileAttribute(arrayBuffer, options),
         extensions: ["bin"],
@@ -8993,7 +9096,7 @@
     }
   });
 
-  // src/lib/utils/customizeColors.ts
+  // src/lib/utils/customize-сolors.ts
   async function customizeColors(colors, featureIds, tileOptions, tilesetOptions, options) {
     if (!options?.i3s?.colorsByAttribute) {
       return colors;
@@ -9023,7 +9126,13 @@
       if (!color) {
         continue;
       }
-      colors.value.set(color, i2 * 4);
+      if (options.i3s.colorsByAttribute.mode === "multiply") {
+        color.forEach((colorItem, index) => {
+          colors.value[i2 * 4 + index] = colors.value[i2 * 4 + index] * colorItem / 255;
+        });
+      } else {
+        colors.value.set(color, i2 * 4);
+      }
     }
     return colors;
   }
@@ -9052,11 +9161,11 @@
     });
     return objectIdAttributeData;
   }
-  var init_customizeColors = __esm({
-    "src/lib/utils/customizeColors.ts"() {
+  var init_customize_olors = __esm({
+    "src/lib/utils/customize-\u0441olors.ts"() {
       init_src3();
       init_i3s_attribute_loader();
-      init_url_utils();
+      init_url_utils2();
     }
   });
 
@@ -9442,9 +9551,9 @@
       init_src6();
       init_src7();
       init_types();
-      init_url_utils();
+      init_url_utils2();
       init_constants();
-      init_customizeColors();
+      init_customize_olors();
       scratchVector5 = new Vector3([0, 0, 0]);
       I3S_ATTRIBUTE_TYPE = "i3s-attribute-type";
     }
@@ -9460,18 +9569,17 @@
     }
     return await parseI3STileContent(data, tileOptions, tilesetOptions, options, context);
   }
-  var VERSION10, I3SContentLoader;
+  var VERSION11, I3SContentLoader;
   var init_i3s_content_loader = __esm({
     "src/i3s-content-loader.ts"() {
-      init_src();
       init_parse_i3s_tile_content();
-      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       I3SContentLoader = {
         name: "I3S Content (Indexed Scene Layers)",
-        id: isBrowser2 ? "i3s-content" : "i3s-content-nodejs",
+        id: "i3s-content",
         module: "i3s",
         worker: true,
-        version: VERSION10,
+        version: VERSION11,
         mimeTypes: ["application/octet-stream"],
         parse: parse3,
         extensions: ["bin"],
@@ -10040,23 +10148,27 @@
   });
 
   // ../tiles/src/constants.ts
-  var TILE_REFINEMENT, TILE_TYPE, TILESET_TYPE;
+  var TILE_REFINEMENT, TILE_TYPE, TILESET_TYPE, LOD_METRIC_TYPE;
   var init_constants4 = __esm({
     "../tiles/src/constants.ts"() {
-      TILE_REFINEMENT = {
-        ADD: 1,
-        REPLACE: 2
-      };
-      TILE_TYPE = {
-        EMPTY: "empty",
-        SCENEGRAPH: "scenegraph",
-        POINTCLOUD: "pointcloud",
-        MESH: "mesh"
-      };
-      TILESET_TYPE = {
-        I3S: "I3S",
-        TILES3D: "TILES3D"
-      };
+      (function(TILE_REFINEMENT2) {
+        TILE_REFINEMENT2[TILE_REFINEMENT2["ADD"] = 1] = "ADD";
+        TILE_REFINEMENT2[TILE_REFINEMENT2["REPLACE"] = 2] = "REPLACE";
+      })(TILE_REFINEMENT || (TILE_REFINEMENT = {}));
+      (function(TILE_TYPE2) {
+        TILE_TYPE2["EMPTY"] = "empty";
+        TILE_TYPE2["SCENEGRAPH"] = "scenegraph";
+        TILE_TYPE2["POINTCLOUD"] = "pointcloud";
+        TILE_TYPE2["MESH"] = "mesh";
+      })(TILE_TYPE || (TILE_TYPE = {}));
+      (function(TILESET_TYPE2) {
+        TILESET_TYPE2["I3S"] = "I3S";
+        TILESET_TYPE2["TILES3D"] = "TILES3D";
+      })(TILESET_TYPE || (TILESET_TYPE = {}));
+      (function(LOD_METRIC_TYPE2) {
+        LOD_METRIC_TYPE2["GEOMETRIC_ERROR"] = "geometricError";
+        LOD_METRIC_TYPE2["MAX_SCREEN_THRESHOLD"] = "maxScreenThreshold";
+      })(LOD_METRIC_TYPE || (LOD_METRIC_TYPE = {}));
     }
   });
 
@@ -10071,15 +10183,15 @@
   async function parseNodePage(data, options) {
     return JSON.parse(new TextDecoder().decode(data));
   }
-  var VERSION11, I3SNodePageLoader;
+  var VERSION12, I3SNodePageLoader;
   var init_i3s_node_page_loader = __esm({
     "src/i3s-node-page-loader.ts"() {
-      VERSION11 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION12 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       I3SNodePageLoader = {
         name: "I3S Node Page",
         id: "i3s-node-page",
         module: "i3s",
-        version: VERSION11,
+        version: VERSION12,
         mimeTypes: ["application/json"],
         parse: parseNodePage,
         extensions: ["json"],
@@ -10096,7 +10208,7 @@
       init_src7();
       init_i3s_node_page_loader();
       init_parse_i3s();
-      init_url_utils();
+      init_url_utils2();
       I3SNodePagesTiles = class {
         constructor(tileset, options) {
           this.nodePages = [];
@@ -10348,7 +10460,7 @@
       init_src3();
       init_src8();
       init_i3s_nodepages_tiles();
-      init_url_utils();
+      init_url_utils2();
     }
   });
 
@@ -10403,14 +10515,14 @@
     }
     return null;
   }
-  var VERSION12, TILESET_REGEX, TILE_HEADER_REGEX, SLPK_HEX, POINT_CLOUD, I3SLoader;
+  var VERSION13, 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";
+      VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
       TILESET_REGEX = /layers\/[0-9]+$/;
       TILE_HEADER_REGEX = /nodes\/([0-9-]+|root)$/;
       SLPK_HEX = "504b0304";
@@ -10419,7 +10531,7 @@
         name: "I3S (Indexed Scene Layers)",
         id: "i3s",
         module: "i3s",
-        version: VERSION12,
+        version: VERSION13,
         mimeTypes: ["application/octet-stream"],
         parse: parseI3S,
         extensions: ["bin"],
@@ -10443,6 +10555,517 @@
     }
   });
 
+  // src/lib/parsers/parse-zip/cd-file-header.ts
+  var parseZipCDFileHeader;
+  var init_cd_file_header = __esm({
+    "src/lib/parsers/parse-zip/cd-file-header.ts"() {
+      parseZipCDFileHeader = (headerOffset, buffer) => {
+        const offsets = {
+          CD_COMPRESSED_SIZE_OFFSET: 20,
+          CD_UNCOMPRESSED_SIZE_OFFSET: 24,
+          CD_FILE_NAME_LENGTH_OFFSET: 28,
+          CD_EXTRA_FIELD_LENGTH_OFFSET: 30,
+          CD_LOCAL_HEADER_OFFSET_OFFSET: 42,
+          CD_FILE_NAME_OFFSET: 46
+        };
+        const compressedSize = buffer.getUint32(headerOffset + offsets.CD_COMPRESSED_SIZE_OFFSET, true);
+        const uncompressedSize = buffer.getUint32(headerOffset + offsets.CD_UNCOMPRESSED_SIZE_OFFSET, true);
+        const fileNameLength = buffer.getUint16(headerOffset + offsets.CD_FILE_NAME_LENGTH_OFFSET, true);
+        const fileName = buffer.buffer.slice(headerOffset + offsets.CD_FILE_NAME_OFFSET, headerOffset + offsets.CD_FILE_NAME_OFFSET + fileNameLength);
+        const extraOffset = headerOffset + offsets.CD_FILE_NAME_OFFSET + fileNameLength;
+        const oldFormatOffset = buffer.getUint32(headerOffset + offsets.CD_LOCAL_HEADER_OFFSET_OFFSET, true);
+        let fileDataOffset = oldFormatOffset;
+        if (fileDataOffset === 4294967295) {
+          let offsetInZip64Data = 4;
+          if (compressedSize === 4294967295) {
+            offsetInZip64Data += 8;
+          }
+          if (uncompressedSize === 4294967295) {
+            offsetInZip64Data += 8;
+          }
+          fileDataOffset = buffer.getUint32(extraOffset + offsetInZip64Data, true);
+        }
+        const localHeaderOffset = fileDataOffset;
+        return {
+          compressedSize,
+          uncompressedSize,
+          fileNameLength,
+          fileName,
+          extraOffset,
+          localHeaderOffset
+        };
+      };
+    }
+  });
+
+  // src/lib/parsers/parse-zip/local-file-header.ts
+  var parseZipLocalFileHeader;
+  var init_local_file_header = __esm({
+    "src/lib/parsers/parse-zip/local-file-header.ts"() {
+      parseZipLocalFileHeader = (headerOffset, buffer) => {
+        const offsets = {
+          COMPRESSED_SIZE_OFFSET: 18,
+          FILE_NAME_LENGTH_OFFSET: 26,
+          EXTRA_FIELD_LENGTH_OFFSET: 28,
+          FILE_NAME_OFFSET: 30
+        };
+        const fileNameLength = buffer.getUint16(headerOffset + offsets.FILE_NAME_LENGTH_OFFSET, true);
+        const extraFieldLength = buffer.getUint16(headerOffset + offsets.EXTRA_FIELD_LENGTH_OFFSET, true);
+        const fileDataOffset = headerOffset + offsets.FILE_NAME_OFFSET + fileNameLength + extraFieldLength;
+        const compressedSize = buffer.getUint32(headerOffset + offsets.COMPRESSED_SIZE_OFFSET, true);
+        return {
+          fileNameLength,
+          extraFieldLength,
+          fileDataOffset,
+          compressedSize
+        };
+      };
+    }
+  });
+
+  // ../../node_modules/crypt/crypt.js
+  var require_crypt = __commonJS({
+    "../../node_modules/crypt/crypt.js"(exports, module) {
+      (function() {
+        var base64map = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", crypt = {
+          rotl: function(n2, b) {
+            return n2 << b | n2 >>> 32 - b;
+          },
+          rotr: function(n2, b) {
+            return n2 << 32 - b | n2 >>> b;
+          },
+          endian: function(n2) {
+            if (n2.constructor == Number) {
+              return crypt.rotl(n2, 8) & 16711935 | crypt.rotl(n2, 24) & 4278255360;
+            }
+            for (var i2 = 0; i2 < n2.length; i2++)
+              n2[i2] = crypt.endian(n2[i2]);
+            return n2;
+          },
+          randomBytes: function(n2) {
+            for (var bytes = []; n2 > 0; n2--)
+              bytes.push(Math.floor(Math.random() * 256));
+            return bytes;
+          },
+          bytesToWords: function(bytes) {
+            for (var words = [], i2 = 0, b = 0; i2 < bytes.length; i2++, b += 8)
+              words[b >>> 5] |= bytes[i2] << 24 - b % 32;
+            return words;
+          },
+          wordsToBytes: function(words) {
+            for (var bytes = [], b = 0; b < words.length * 32; b += 8)
+              bytes.push(words[b >>> 5] >>> 24 - b % 32 & 255);
+            return bytes;
+          },
+          bytesToHex: function(bytes) {
+            for (var hex = [], i2 = 0; i2 < bytes.length; i2++) {
+              hex.push((bytes[i2] >>> 4).toString(16));
+              hex.push((bytes[i2] & 15).toString(16));
+            }
+            return hex.join("");
+          },
+          hexToBytes: function(hex) {
+            for (var bytes = [], c2 = 0; c2 < hex.length; c2 += 2)
+              bytes.push(parseInt(hex.substr(c2, 2), 16));
+            return bytes;
+          },
+          bytesToBase64: function(bytes) {
+            for (var base64 = [], i2 = 0; i2 < bytes.length; i2 += 3) {
+              var triplet = bytes[i2] << 16 | bytes[i2 + 1] << 8 | bytes[i2 + 2];
+              for (var j = 0; j < 4; j++)
+                if (i2 * 8 + j * 6 <= bytes.length * 8)
+                  base64.push(base64map.charAt(triplet >>> 6 * (3 - j) & 63));
+                else
+                  base64.push("=");
+            }
+            return base64.join("");
+          },
+          base64ToBytes: function(base64) {
+            base64 = base64.replace(/[^A-Z0-9+\/]/ig, "");
+            for (var bytes = [], i2 = 0, imod4 = 0; i2 < base64.length; imod4 = ++i2 % 4) {
+              if (imod4 == 0)
+                continue;
+              bytes.push((base64map.indexOf(base64.charAt(i2 - 1)) & Math.pow(2, -2 * imod4 + 8) - 1) << imod4 * 2 | base64map.indexOf(base64.charAt(i2)) >>> 6 - imod4 * 2);
+            }
+            return bytes;
+          }
+        };
+        module.exports = crypt;
+      })();
+    }
+  });
+
+  // ../../node_modules/charenc/charenc.js
+  var require_charenc = __commonJS({
+    "../../node_modules/charenc/charenc.js"(exports, module) {
+      var charenc = {
+        utf8: {
+          stringToBytes: function(str) {
+            return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
+          },
+          bytesToString: function(bytes) {
+            return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
+          }
+        },
+        bin: {
+          stringToBytes: function(str) {
+            for (var bytes = [], i2 = 0; i2 < str.length; i2++)
+              bytes.push(str.charCodeAt(i2) & 255);
+            return bytes;
+          },
+          bytesToString: function(bytes) {
+            for (var str = [], i2 = 0; i2 < bytes.length; i2++)
+              str.push(String.fromCharCode(bytes[i2]));
+            return str.join("");
+          }
+        }
+      };
+      module.exports = charenc;
+    }
+  });
+
+  // ../../node_modules/is-buffer/index.js
+  var require_is_buffer = __commonJS({
+    "../../node_modules/is-buffer/index.js"(exports, module) {
+      module.exports = function(obj) {
+        return obj != null && (isBuffer3(obj) || isSlowBuffer(obj) || !!obj._isBuffer);
+      };
+      function isBuffer3(obj) {
+        return !!obj.constructor && typeof obj.constructor.isBuffer === "function" && obj.constructor.isBuffer(obj);
+      }
+      function isSlowBuffer(obj) {
+        return typeof obj.readFloatLE === "function" && typeof obj.slice === "function" && isBuffer3(obj.slice(0, 0));
+      }
+    }
+  });
+
+  // ../../node_modules/md5/md5.js
+  var require_md5 = __commonJS({
+    "../../node_modules/md5/md5.js"(exports, module) {
+      (function() {
+        var crypt = require_crypt(), utf8 = require_charenc().utf8, isBuffer3 = require_is_buffer(), bin = require_charenc().bin, md52 = function(message, options) {
+          if (message.constructor == String)
+            if (options && options.encoding === "binary")
+              message = bin.stringToBytes(message);
+            else
+              message = utf8.stringToBytes(message);
+          else if (isBuffer3(message))
+            message = Array.prototype.slice.call(message, 0);
+          else if (!Array.isArray(message) && message.constructor !== Uint8Array)
+            message = message.toString();
+          var m = crypt.bytesToWords(message), l2 = message.length * 8, a2 = 1732584193, b = -271733879, c2 = -1732584194, d = 271733878;
+          for (var i2 = 0; i2 < m.length; i2++) {
+            m[i2] = (m[i2] << 8 | m[i2] >>> 24) & 16711935 | (m[i2] << 24 | m[i2] >>> 8) & 4278255360;
+          }
+          m[l2 >>> 5] |= 128 << l2 % 32;
+          m[(l2 + 64 >>> 9 << 4) + 14] = l2;
+          var FF = md52._ff, GG = md52._gg, HH = md52._hh, II = md52._ii;
+          for (var i2 = 0; i2 < m.length; i2 += 16) {
+            var aa = a2, bb = b, cc = c2, dd = d;
+            a2 = FF(a2, b, c2, d, m[i2 + 0], 7, -680876936);
+            d = FF(d, a2, b, c2, m[i2 + 1], 12, -389564586);
+            c2 = FF(c2, d, a2, b, m[i2 + 2], 17, 606105819);
+            b = FF(b, c2, d, a2, m[i2 + 3], 22, -1044525330);
+            a2 = FF(a2, b, c2, d, m[i2 + 4], 7, -176418897);
+            d = FF(d, a2, b, c2, m[i2 + 5], 12, 1200080426);
+            c2 = FF(c2, d, a2, b, m[i2 + 6], 17, -1473231341);
+            b = FF(b, c2, d, a2, m[i2 + 7], 22, -45705983);
+            a2 = FF(a2, b, c2, d, m[i2 + 8], 7, 1770035416);
+            d = FF(d, a2, b, c2, m[i2 + 9], 12, -1958414417);
+            c2 = FF(c2, d, a2, b, m[i2 + 10], 17, -42063);
+            b = FF(b, c2, d, a2, m[i2 + 11], 22, -1990404162);
+            a2 = FF(a2, b, c2, d, m[i2 + 12], 7, 1804603682);
+            d = FF(d, a2, b, c2, m[i2 + 13], 12, -40341101);
+            c2 = FF(c2, d, a2, b, m[i2 + 14], 17, -1502002290);
+            b = FF(b, c2, d, a2, m[i2 + 15], 22, 1236535329);
+            a2 = GG(a2, b, c2, d, m[i2 + 1], 5, -165796510);
+            d = GG(d, a2, b, c2, m[i2 + 6], 9, -1069501632);
+            c2 = GG(c2, d, a2, b, m[i2 + 11], 14, 643717713);
+            b = GG(b, c2, d, a2, m[i2 + 0], 20, -373897302);
+            a2 = GG(a2, b, c2, d, m[i2 + 5], 5, -701558691);
+            d = GG(d, a2, b, c2, m[i2 + 10], 9, 38016083);
+            c2 = GG(c2, d, a2, b, m[i2 + 15], 14, -660478335);
+            b = GG(b, c2, d, a2, m[i2 + 4], 20, -405537848);
+            a2 = GG(a2, b, c2, d, m[i2 + 9], 5, 568446438);
+            d = GG(d, a2, b, c2, m[i2 + 14], 9, -1019803690);
+            c2 = GG(c2, d, a2, b, m[i2 + 3], 14, -187363961);
+            b = GG(b, c2, d, a2, m[i2 + 8], 20, 1163531501);
+            a2 = GG(a2, b, c2, d, m[i2 + 13], 5, -1444681467);
+            d = GG(d, a2, b, c2, m[i2 + 2], 9, -51403784);
+            c2 = GG(c2, d, a2, b, m[i2 + 7], 14, 1735328473);
+            b = GG(b, c2, d, a2, m[i2 + 12], 20, -1926607734);
+            a2 = HH(a2, b, c2, d, m[i2 + 5], 4, -378558);
+            d = HH(d, a2, b, c2, m[i2 + 8], 11, -2022574463);
+            c2 = HH(c2, d, a2, b, m[i2 + 11], 16, 1839030562);
+            b = HH(b, c2, d, a2, m[i2 + 14], 23, -35309556);
+            a2 = HH(a2, b, c2, d, m[i2 + 1], 4, -1530992060);
+            d = HH(d, a2, b, c2, m[i2 + 4], 11, 1272893353);
+            c2 = HH(c2, d, a2, b, m[i2 + 7], 16, -155497632);
+            b = HH(b, c2, d, a2, m[i2 + 10], 23, -1094730640);
+            a2 = HH(a2, b, c2, d, m[i2 + 13], 4, 681279174);
+            d = HH(d, a2, b, c2, m[i2 + 0], 11, -358537222);
+            c2 = HH(c2, d, a2, b, m[i2 + 3], 16, -722521979);
+            b = HH(b, c2, d, a2, m[i2 + 6], 23, 76029189);
+            a2 = HH(a2, b, c2, d, m[i2 + 9], 4, -640364487);
+            d = HH(d, a2, b, c2, m[i2 + 12], 11, -421815835);
+            c2 = HH(c2, d, a2, b, m[i2 + 15], 16, 530742520);
+            b = HH(b, c2, d, a2, m[i2 + 2], 23, -995338651);
+            a2 = II(a2, b, c2, d, m[i2 + 0], 6, -198630844);
+            d = II(d, a2, b, c2, m[i2 + 7], 10, 1126891415);
+            c2 = II(c2, d, a2, b, m[i2 + 14], 15, -1416354905);
+            b = II(b, c2, d, a2, m[i2 + 5], 21, -57434055);
+            a2 = II(a2, b, c2, d, m[i2 + 12], 6, 1700485571);
+            d = II(d, a2, b, c2, m[i2 + 3], 10, -1894986606);
+            c2 = II(c2, d, a2, b, m[i2 + 10], 15, -1051523);
+            b = II(b, c2, d, a2, m[i2 + 1], 21, -2054922799);
+            a2 = II(a2, b, c2, d, m[i2 + 8], 6, 1873313359);
+            d = II(d, a2, b, c2, m[i2 + 15], 10, -30611744);
+            c2 = II(c2, d, a2, b, m[i2 + 6], 15, -1560198380);
+            b = II(b, c2, d, a2, m[i2 + 13], 21, 1309151649);
+            a2 = II(a2, b, c2, d, m[i2 + 4], 6, -145523070);
+            d = II(d, a2, b, c2, m[i2 + 11], 10, -1120210379);
+            c2 = II(c2, d, a2, b, m[i2 + 2], 15, 718787259);
+            b = II(b, c2, d, a2, m[i2 + 9], 21, -343485551);
+            a2 = a2 + aa >>> 0;
+            b = b + bb >>> 0;
+            c2 = c2 + cc >>> 0;
+            d = d + dd >>> 0;
+          }
+          return crypt.endian([a2, b, c2, d]);
+        };
+        md52._ff = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (b & c2 | ~b & d) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._gg = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (b & d | c2 & ~d) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._hh = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (b ^ c2 ^ d) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._ii = function(a2, b, c2, d, x, s2, t2) {
+          var n2 = a2 + (c2 ^ (b | ~d)) + (x >>> 0) + t2;
+          return (n2 << s2 | n2 >>> 32 - s2) + b;
+        };
+        md52._blocksize = 16;
+        md52._digestsize = 16;
+        module.exports = function(message, options) {
+          if (message === void 0 || message === null)
+            throw new Error("Illegal argument " + message);
+          var digestbytes = crypt.wordsToBytes(md52(message, options));
+          return options && options.asBytes ? digestbytes : options && options.asString ? bin.bytesToString(digestbytes) : crypt.bytesToHex(digestbytes);
+        };
+      })();
+    }
+  });
+
+  // ../compression/src/compression-worker.ts
+  var VERSION14, CompressionWorker;
+  var init_compression_worker = __esm({
+    "../compression/src/compression-worker.ts"() {
+      VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      CompressionWorker = {
+        id: "compression",
+        name: "compression",
+        module: "compression",
+        version: VERSION14,
+        options: {}
+      };
+    }
+  });
+
+  // ../compression/src/index.ts
+  var init_src9 = __esm({
+    "../compression/src/index.ts"() {
+      init_compression_worker();
+    }
+  });
+
+  // src/lib/parsers/parse-slpk/slpk-archieve.ts
+  var import_md5, PATH_DESCRIPTIONS, SLPKArchive;
+  var init_slpk_archieve = __esm({
+    "src/lib/parsers/parse-slpk/slpk-archieve.ts"() {
+      init_src();
+      import_md5 = __toModule(require_md5());
+      init_src9();
+      init_local_file_header();
+      PATH_DESCRIPTIONS = [
+        {
+          test: /^$/,
+          extensions: ["3dSceneLayer.json.gz"]
+        },
+        {
+          test: /^nodepages\/\d+$/,
+          extensions: [".json.gz"]
+        },
+        {
+          test: /^nodes\/\d+$/,
+          extensions: ["/3dNodeIndexDocument.json.gz"]
+        },
+        {
+          test: /^nodes\/\d+\/textures\/.+$/,
+          extensions: [".jpg", ".png", ".bin.dds.gz", ".ktx"]
+        },
+        {
+          test: /^nodes\/\d+\/geometries\/\d+$/,
+          extensions: [".bin.gz", ".draco.gz"]
+        },
+        {
+          test: /^nodes\/\d+\/attributes\/f_\d+\/\d+$/,
+          extensions: [".bin.gz"]
+        },
+        {
+          test: /^statistics\/f_\d+\/\d+$/,
+          extensions: [".json.gz"]
+        },
+        {
+          test: /^nodes\/\d+\/shared$/,
+          extensions: ["/sharedResource.json.gz"]
+        }
+      ];
+      SLPKArchive = class {
+        constructor(slpkArchiveBuffer, hashFile) {
+          this.slpkArchive = new DataView(slpkArchiveBuffer);
+          this.hashArray = this.parseHashFile(hashFile);
+        }
+        parseHashFile(hashFile) {
+          const hashFileBuffer = Buffer.from(hashFile);
+          const hashArray = [];
+          for (let i2 = 0; i2 < hashFileBuffer.buffer.byteLength; i2 = i2 + 24) {
+            const offsetBuffer = new DataView(hashFileBuffer.buffer.slice(hashFileBuffer.byteOffset + i2 + 16, hashFileBuffer.byteOffset + i2 + 24));
+            const offset = offsetBuffer.getUint32(offsetBuffer.byteOffset, true);
+            hashArray.push({
+              hash: Buffer.from(hashFileBuffer.subarray(hashFileBuffer.byteOffset + i2, hashFileBuffer.byteOffset + i2 + 16)),
+              offset
+            });
+          }
+          return hashArray;
+        }
+        async getFile(path, mode = "raw") {
+          if (mode === "http") {
+            const extensions = PATH_DESCRIPTIONS.find((val) => val.test.test(path))?.extensions;
+            if (extensions) {
+              let data;
+              for (const ext of extensions) {
+                data = await this.getDataByPath(`${path}${ext}`);
+                if (data) {
+                  break;
+                }
+              }
+              if (data) {
+                return Buffer.from(data);
+              }
+            }
+          }
+          if (mode === "raw") {
+            const decompressedFile = await this.getDataByPath(`${path}.gz`);
+            if (decompressedFile) {
+              return Buffer.from(decompressedFile);
+            }
+            const fileWithoutCompression = this.getFileBytes(path);
+            if (fileWithoutCompression) {
+              return Buffer.from(fileWithoutCompression);
+            }
+          }
+          throw new Error("No such file in the archieve");
+        }
+        async getDataByPath(path) {
+          const data = this.getFileBytes(path);
+          if (!data) {
+            return void 0;
+          }
+          if (/\.gz$/.test(path)) {
+            const decompressedData = await processOnWorker(CompressionWorker, data, {
+              compression: "gzip",
+              operation: "decompress",
+              _workerType: "test",
+              gzip: {}
+            });
+            return decompressedData;
+          }
+          return Buffer.from(data);
+        }
+        getFileBytes(path) {
+          const nameHash = Buffer.from((0, import_md5.default)(path), "hex");
+          const fileInfo = this.hashArray.find((val) => Buffer.compare(val.hash, nameHash) === 0);
+          if (!fileInfo) {
+            return void 0;
+          }
+          const localFileHeader = parseZipLocalFileHeader(this.slpkArchive.byteOffset + fileInfo?.offset, this.slpkArchive);
+          const compressedFile = this.slpkArchive.buffer.slice(localFileHeader.fileDataOffset, localFileHeader.fileDataOffset + localFileHeader.compressedSize);
+          return compressedFile;
+        }
+      };
+    }
+  });
+
+  // src/lib/parsers/parse-slpk/parse-slpk.ts
+  async function parseSLPK(data, options = {}) {
+    const archive = new DataView(data);
+    const cdFileHeaderSignature = [80, 75, 1, 2];
+    const searchWindow = [
+      getByteAt(archive.byteLength - 1, archive),
+      getByteAt(archive.byteLength - 2, archive),
+      getByteAt(archive.byteLength - 3, archive),
+      void 0
+    ];
+    let hashCDOffset = 0;
+    for (let i2 = archive.byteLength - 4; i2 > -1; i2--) {
+      searchWindow[3] = searchWindow[2];
+      searchWindow[2] = searchWindow[1];
+      searchWindow[1] = searchWindow[0];
+      searchWindow[0] = getByteAt(i2, archive);
+      if (searchWindow.every((val, index) => val === cdFileHeaderSignature[index])) {
+        hashCDOffset = i2;
+        break;
+      }
+    }
+    const cdFileHeader = parseZipCDFileHeader(hashCDOffset, archive);
+    const textDecoder = new TextDecoder();
+    if (textDecoder.decode(cdFileHeader.fileName) !== "@specialIndexFileHASH128@") {
+      throw new Error("No hash file in slpk");
+    }
+    const localFileHeader = parseZipLocalFileHeader(cdFileHeader.localHeaderOffset, archive);
+    const fileDataOffset = localFileHeader.fileDataOffset;
+    const hashFile = archive.buffer.slice(fileDataOffset, fileDataOffset + localFileHeader.compressedSize);
+    if (!hashFile) {
+      throw new Error("No hash file in slpk");
+    }
+    return await new SLPKArchive(data, hashFile).getFile(options.slpk?.path ?? "", options.slpk?.pathMode);
+  }
+  var getByteAt;
+  var init_parse_slpk = __esm({
+    "src/lib/parsers/parse-slpk/parse-slpk.ts"() {
+      init_cd_file_header();
+      init_local_file_header();
+      init_slpk_archieve();
+      getByteAt = (offset, buffer) => {
+        return buffer.getUint8(buffer.byteOffset + offset);
+      };
+    }
+  });
+
+  // src/i3s-slpk-loader.ts
+  var VERSION15, SLPKLoader;
+  var init_i3s_slpk_loader = __esm({
+    "src/i3s-slpk-loader.ts"() {
+      init_parse_slpk();
+      VERSION15 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      SLPKLoader = {
+        name: "I3S SLPK (Scene Layer Package)",
+        id: "slpk",
+        module: "i3s",
+        version: VERSION15,
+        mimeTypes: ["application/octet-stream"],
+        parse: parseSLPK,
+        extensions: ["slpk"],
+        options: {}
+      };
+    }
+  });
+
   // src/lib/parsers/parse-i3s-building-scene-layer.ts
   async function parseBuildingSceneLayer(data, url) {
     const layer0 = JSON.parse(new TextDecoder().decode(data));
@@ -10487,16 +11110,16 @@
     }
     return parseBuildingSceneLayer(data, context.url);
   }
-  var VERSION13, I3SBuildingSceneLayerLoader;
+  var VERSION16, I3SBuildingSceneLayerLoader;
   var init_i3s_building_scene_layer_loader = __esm({
     "src/i3s-building-scene-layer-loader.ts"() {
       init_parse_i3s_building_scene_layer();
-      VERSION13 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION16 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       I3SBuildingSceneLayerLoader = {
         name: "I3S Building Scene Layer",
         id: "i3s-building-scene-layer",
         module: "i3s",
-        version: VERSION13,
+        version: VERSION16,
         mimeTypes: ["application/json"],
         parse: parse4,
         extensions: ["json"],
@@ -10577,16 +11200,16 @@
   async function parse5(data) {
     return parseWebscene(data);
   }
-  var VERSION14, ArcGisWebSceneLoader;
+  var VERSION17, ArcGisWebSceneLoader;
   var init_arcgis_webscene_loader = __esm({
     "src/arcgis-webscene-loader.ts"() {
       init_parse_arcgis_webscene();
-      VERSION14 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
+      VERSION17 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
       ArcGisWebSceneLoader = {
         name: "ArcGIS Web Scene Loader",
         id: "arcgis-web-scene",
         module: "i3s",
-        version: VERSION14,
+        version: VERSION17,
         mimeTypes: ["application/json"],
         parse: parse5,
         extensions: ["json"],
@@ -10605,16 +11228,18 @@
     I3SContentLoader: () => I3SContentLoader,
     I3SLoader: () => I3SLoader,
     I3SNodePageLoader: () => I3SNodePageLoader,
+    SLPKLoader: () => SLPKLoader,
     loadFeatureAttributes: () => loadFeatureAttributes
   });
-  var init_src9 = __esm({
+  var init_src10 = __esm({
     "src/index.ts"() {
       init_constants();
       init_i3s_loader();
+      init_i3s_slpk_loader();
       init_i3s_content_loader();
       init_i3s_attribute_loader();
-      init_i3s_node_page_loader();
       init_i3s_building_scene_layer_loader();
+      init_i3s_node_page_loader();
       init_arcgis_webscene_loader();
     }
   });
@@ -10622,10 +11247,16 @@
   // src/bundle.ts
   var require_bundle = __commonJS({
     "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src9(), src_exports);
+      var moduleExports = (init_src10(), src_exports);
       globalThis.loaders = globalThis.loaders || {};
       module.exports = Object.assign(globalThis.loaders, moduleExports);
     }
   });
   require_bundle();
 })();
+/*!
+ * Determine if an object is a Buffer
+ *
+ * @author   Feross Aboukhadijeh <https://feross.org>
+ * @license  MIT
+ */