@loaders.gl/3d-tiles 4.0.0-alpha.12 → 4.0.0-alpha.14

package/dist/dist.min.js

@@ -5689,23 +5689,23 @@
   var init_color = __esm({
     "../../node_modules/@probe.gl/log/dist/utils/color.js"() {
       init_dist();
-      (function(COLOR2) {
-        COLOR2[COLOR2["BLACK"] = 30] = "BLACK";
-        COLOR2[COLOR2["RED"] = 31] = "RED";
-        COLOR2[COLOR2["GREEN"] = 32] = "GREEN";
-        COLOR2[COLOR2["YELLOW"] = 33] = "YELLOW";
-        COLOR2[COLOR2["BLUE"] = 34] = "BLUE";
-        COLOR2[COLOR2["MAGENTA"] = 35] = "MAGENTA";
-        COLOR2[COLOR2["CYAN"] = 36] = "CYAN";
-        COLOR2[COLOR2["WHITE"] = 37] = "WHITE";
-        COLOR2[COLOR2["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
-        COLOR2[COLOR2["BRIGHT_RED"] = 91] = "BRIGHT_RED";
-        COLOR2[COLOR2["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
-        COLOR2[COLOR2["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
-        COLOR2[COLOR2["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
-        COLOR2[COLOR2["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
-        COLOR2[COLOR2["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
-        COLOR2[COLOR2["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+      (function(COLOR3) {
+        COLOR3[COLOR3["BLACK"] = 30] = "BLACK";
+        COLOR3[COLOR3["RED"] = 31] = "RED";
+        COLOR3[COLOR3["GREEN"] = 32] = "GREEN";
+        COLOR3[COLOR3["YELLOW"] = 33] = "YELLOW";
+        COLOR3[COLOR3["BLUE"] = 34] = "BLUE";
+        COLOR3[COLOR3["MAGENTA"] = 35] = "MAGENTA";
+        COLOR3[COLOR3["CYAN"] = 36] = "CYAN";
+        COLOR3[COLOR3["WHITE"] = 37] = "WHITE";
+        COLOR3[COLOR3["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+        COLOR3[COLOR3["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+        COLOR3[COLOR3["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+        COLOR3[COLOR3["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+        COLOR3[COLOR3["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+        COLOR3[COLOR3["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+        COLOR3[COLOR3["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+        COLOR3[COLOR3["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
       })(COLOR || (COLOR = {}));
       BACKGROUND_INCREMENT = 10;
     }
@@ -12676,22 +12676,25 @@
     if (binaryByteLength) {
       internalBinaryBuffer = data.slice(24 + jsonByteLength);
     }
-    if ("bufferView" in subtree.tileAvailability) {
-      subtree.tileAvailability.explicitBitstream = await getExplicitBitstream(subtree, "tileAvailability", internalBinaryBuffer, context);
-    }
-    if ("bufferView" in subtree.contentAvailability) {
-      subtree.contentAvailability.explicitBitstream = await getExplicitBitstream(subtree, "contentAvailability", internalBinaryBuffer, context);
-    }
-    if ("bufferView" in subtree.childSubtreeAvailability) {
-      subtree.childSubtreeAvailability.explicitBitstream = await getExplicitBitstream(subtree, "childSubtreeAvailability", internalBinaryBuffer, context);
+    await loadExplicitBitstream(subtree, subtree.tileAvailability, internalBinaryBuffer, context);
+    if (Array.isArray(subtree.contentAvailability)) {
+      for (const contentAvailability of subtree.contentAvailability) {
+        await loadExplicitBitstream(subtree, contentAvailability, internalBinaryBuffer, context);
+      }
+    } else {
+      await loadExplicitBitstream(subtree, subtree.contentAvailability, internalBinaryBuffer, context);
     }
+    await loadExplicitBitstream(subtree, subtree.childSubtreeAvailability, internalBinaryBuffer, context);
     return subtree;
   }
-  async function getExplicitBitstream(subtree, name10, internalBinaryBuffer, context) {
-    const bufferViewIndex = subtree[name10].bufferView;
+  async function loadExplicitBitstream(subtree, availabilityObject, internalBinaryBuffer, context) {
+    const bufferViewIndex = Number.isFinite(availabilityObject.bitstream) ? availabilityObject.bitstream : availabilityObject.bufferView;
+    if (typeof bufferViewIndex !== "number") {
+      return;
+    }
     const bufferView = subtree.bufferViews[bufferViewIndex];
     const buffer = subtree.buffers[bufferView.buffer];
-    if (!context?.url || !context.fetch) {
+    if (!context?.baseUrl) {
       throw new Error("Url is not provided");
     }
     if (!context.fetch) {
@@ -12701,9 +12704,10 @@
       const bufferUri = `${context?.baseUrl || ""}/${buffer.uri}`;
       const response = await context.fetch(bufferUri);
       const data = await response.arrayBuffer();
-      return new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+      availabilityObject.explicitBitstream = new Uint8Array(data, bufferView.byteOffset, bufferView.byteLength);
+      return;
     }
-    return new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
+    availabilityObject.explicitBitstream = new Uint8Array(internalBinaryBuffer, bufferView.byteOffset, bufferView.byteLength);
   }
   function parseUint64Value(buffer) {
     const dataView = new DataView(buffer);
@@ -12739,6 +12743,608 @@
     }
   });
 
+  // node_modules/@probe.gl/env/dist/lib/is-electron.js
+  function isElectron2(mockUserAgent) {
+    if (typeof window !== "undefined" && typeof window.process === "object" && window.process.type === "renderer") {
+      return true;
+    }
+    if (typeof process !== "undefined" && typeof process.versions === "object" && Boolean(process.versions["electron"])) {
+      return true;
+    }
+    const realUserAgent = typeof navigator === "object" && typeof navigator.userAgent === "string" && navigator.userAgent;
+    const userAgent = mockUserAgent || realUserAgent;
+    if (userAgent && userAgent.indexOf("Electron") >= 0) {
+      return true;
+    }
+    return false;
+  }
+  var init_is_electron2 = __esm({
+    "node_modules/@probe.gl/env/dist/lib/is-electron.js"() {
+    }
+  });
+
+  // node_modules/@probe.gl/env/dist/lib/is-browser.js
+  function isBrowser5() {
+    const isNode = typeof process === "object" && String(process) === "[object process]" && !process.browser;
+    return !isNode || isElectron2();
+  }
+  var init_is_browser2 = __esm({
+    "node_modules/@probe.gl/env/dist/lib/is-browser.js"() {
+      init_is_electron2();
+    }
+  });
+
+  // node_modules/@probe.gl/env/dist/lib/globals.js
+  var self_4, window_4, document_4, process_2, console_2, navigator_2;
+  var init_globals5 = __esm({
+    "node_modules/@probe.gl/env/dist/lib/globals.js"() {
+      self_4 = globalThis.self || globalThis.window || globalThis.global;
+      window_4 = globalThis.window || globalThis.self || globalThis.global;
+      document_4 = globalThis.document || {};
+      process_2 = globalThis.process || {};
+      console_2 = globalThis.console;
+      navigator_2 = globalThis.navigator || {};
+    }
+  });
+
+  // node_modules/@probe.gl/env/dist/utils/globals.js
+  var VERSION10, isBrowser6;
+  var init_globals6 = __esm({
+    "node_modules/@probe.gl/env/dist/utils/globals.js"() {
+      init_is_browser2();
+      VERSION10 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "untranspiled source";
+      isBrowser6 = isBrowser5();
+    }
+  });
+
+  // node_modules/@probe.gl/env/dist/index.js
+  var init_dist3 = __esm({
+    "node_modules/@probe.gl/env/dist/index.js"() {
+      init_globals6();
+      init_globals5();
+      init_is_browser2();
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/utils/local-storage.js
+  function getStorage2(type) {
+    try {
+      const storage = window[type];
+      const x = "__storage_test__";
+      storage.setItem(x, x);
+      storage.removeItem(x);
+      return storage;
+    } catch (e) {
+      return null;
+    }
+  }
+  var LocalStorage2;
+  var init_local_storage2 = __esm({
+    "node_modules/@probe.gl/log/dist/utils/local-storage.js"() {
+      LocalStorage2 = class {
+        constructor(id, defaultConfig) {
+          let type = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : "sessionStorage";
+          this.storage = void 0;
+          this.id = void 0;
+          this.config = void 0;
+          this.storage = getStorage2(type);
+          this.id = id;
+          this.config = defaultConfig;
+          this._loadConfiguration();
+        }
+        getConfiguration() {
+          return this.config;
+        }
+        setConfiguration(configuration) {
+          Object.assign(this.config, configuration);
+          if (this.storage) {
+            const serialized = JSON.stringify(this.config);
+            this.storage.setItem(this.id, serialized);
+          }
+        }
+        _loadConfiguration() {
+          let configuration = {};
+          if (this.storage) {
+            const serializedConfiguration = this.storage.getItem(this.id);
+            configuration = serializedConfiguration ? JSON.parse(serializedConfiguration) : {};
+          }
+          Object.assign(this.config, configuration);
+          return this;
+        }
+      };
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/utils/formatters.js
+  function formatTime2(ms) {
+    let formatted;
+    if (ms < 10) {
+      formatted = "".concat(ms.toFixed(2), "ms");
+    } else if (ms < 100) {
+      formatted = "".concat(ms.toFixed(1), "ms");
+    } else if (ms < 1e3) {
+      formatted = "".concat(ms.toFixed(0), "ms");
+    } else {
+      formatted = "".concat((ms / 1e3).toFixed(2), "s");
+    }
+    return formatted;
+  }
+  function leftPad2(string) {
+    let length4 = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 8;
+    const padLength = Math.max(length4 - string.length, 0);
+    return "".concat(" ".repeat(padLength)).concat(string);
+  }
+  function formatImage2(image, message, scale5) {
+    let maxWidth = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : 600;
+    const imageUrl = image.src.replace(/\(/g, "%28").replace(/\)/g, "%29");
+    if (image.width > maxWidth) {
+      scale5 = Math.min(scale5, maxWidth / image.width);
+    }
+    const width = image.width * scale5;
+    const height = image.height * scale5;
+    const style = ["font-size:1px;", "padding:".concat(Math.floor(height / 2), "px ").concat(Math.floor(width / 2), "px;"), "line-height:".concat(height, "px;"), "background:url(".concat(imageUrl, ");"), "background-size:".concat(width, "px ").concat(height, "px;"), "color:transparent;"].join("");
+    return ["".concat(message, " %c+"), style];
+  }
+  var init_formatters2 = __esm({
+    "node_modules/@probe.gl/log/dist/utils/formatters.js"() {
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/utils/color.js
+  function getColor2(color) {
+    if (typeof color !== "string") {
+      return color;
+    }
+    color = color.toUpperCase();
+    return COLOR2[color] || COLOR2.WHITE;
+  }
+  function addColor2(string, color, background) {
+    if (!isBrowser5 && typeof string === "string") {
+      if (color) {
+        const colorCode = getColor2(color);
+        string = "[".concat(colorCode, "m").concat(string, "");
+      }
+      if (background) {
+        const colorCode = getColor2(background);
+        string = "[".concat(colorCode + BACKGROUND_INCREMENT2, "m").concat(string, "");
+      }
+    }
+    return string;
+  }
+  var COLOR2, BACKGROUND_INCREMENT2;
+  var init_color2 = __esm({
+    "node_modules/@probe.gl/log/dist/utils/color.js"() {
+      init_dist3();
+      (function(COLOR3) {
+        COLOR3[COLOR3["BLACK"] = 30] = "BLACK";
+        COLOR3[COLOR3["RED"] = 31] = "RED";
+        COLOR3[COLOR3["GREEN"] = 32] = "GREEN";
+        COLOR3[COLOR3["YELLOW"] = 33] = "YELLOW";
+        COLOR3[COLOR3["BLUE"] = 34] = "BLUE";
+        COLOR3[COLOR3["MAGENTA"] = 35] = "MAGENTA";
+        COLOR3[COLOR3["CYAN"] = 36] = "CYAN";
+        COLOR3[COLOR3["WHITE"] = 37] = "WHITE";
+        COLOR3[COLOR3["BRIGHT_BLACK"] = 90] = "BRIGHT_BLACK";
+        COLOR3[COLOR3["BRIGHT_RED"] = 91] = "BRIGHT_RED";
+        COLOR3[COLOR3["BRIGHT_GREEN"] = 92] = "BRIGHT_GREEN";
+        COLOR3[COLOR3["BRIGHT_YELLOW"] = 93] = "BRIGHT_YELLOW";
+        COLOR3[COLOR3["BRIGHT_BLUE"] = 94] = "BRIGHT_BLUE";
+        COLOR3[COLOR3["BRIGHT_MAGENTA"] = 95] = "BRIGHT_MAGENTA";
+        COLOR3[COLOR3["BRIGHT_CYAN"] = 96] = "BRIGHT_CYAN";
+        COLOR3[COLOR3["BRIGHT_WHITE"] = 97] = "BRIGHT_WHITE";
+      })(COLOR2 || (COLOR2 = {}));
+      BACKGROUND_INCREMENT2 = 10;
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/utils/autobind.js
+  function autobind2(obj) {
+    let predefined = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : ["constructor"];
+    const proto = Object.getPrototypeOf(obj);
+    const propNames = Object.getOwnPropertyNames(proto);
+    const object = obj;
+    for (const key of propNames) {
+      const value = object[key];
+      if (typeof value === "function") {
+        if (!predefined.find((name10) => key === name10)) {
+          object[key] = value.bind(obj);
+        }
+      }
+    }
+  }
+  var init_autobind2 = __esm({
+    "node_modules/@probe.gl/log/dist/utils/autobind.js"() {
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/utils/assert.js
+  function assert8(condition, message) {
+    if (!condition) {
+      throw new Error(message || "Assertion failed");
+    }
+  }
+  var init_assert7 = __esm({
+    "node_modules/@probe.gl/log/dist/utils/assert.js"() {
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js
+  function getHiResTimestamp2() {
+    let timestamp;
+    if (isBrowser5() && window_4.performance) {
+      var _window$performance, _window$performance$n;
+      timestamp = window_4 === null || window_4 === void 0 ? void 0 : (_window$performance = window_4.performance) === null || _window$performance === void 0 ? void 0 : (_window$performance$n = _window$performance.now) === null || _window$performance$n === void 0 ? void 0 : _window$performance$n.call(_window$performance);
+    } else if ("hrtime" in process_2) {
+      var _process$hrtime;
+      const timeParts = process_2 === null || process_2 === void 0 ? void 0 : (_process$hrtime = process_2.hrtime) === null || _process$hrtime === void 0 ? void 0 : _process$hrtime.call(process_2);
+      timestamp = timeParts[0] * 1e3 + timeParts[1] / 1e6;
+    } else {
+      timestamp = Date.now();
+    }
+    return timestamp;
+  }
+  var init_hi_res_timestamp2 = __esm({
+    "node_modules/@probe.gl/log/dist/utils/hi-res-timestamp.js"() {
+      init_dist3();
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/log.js
+  function noop2() {
+  }
+  function normalizeLogLevel2(logLevel) {
+    if (!logLevel) {
+      return 0;
+    }
+    let resolvedLevel;
+    switch (typeof logLevel) {
+      case "number":
+        resolvedLevel = logLevel;
+        break;
+      case "object":
+        resolvedLevel = logLevel.logLevel || logLevel.priority || 0;
+        break;
+      default:
+        return 0;
+    }
+    assert8(Number.isFinite(resolvedLevel) && resolvedLevel >= 0);
+    return resolvedLevel;
+  }
+  function normalizeArguments2(opts) {
+    const {
+      logLevel,
+      message
+    } = opts;
+    opts.logLevel = normalizeLogLevel2(logLevel);
+    const args = opts.args ? Array.from(opts.args) : [];
+    while (args.length && args.shift() !== message) {
+    }
+    switch (typeof logLevel) {
+      case "string":
+      case "function":
+        if (message !== void 0) {
+          args.unshift(message);
+        }
+        opts.message = logLevel;
+        break;
+      case "object":
+        Object.assign(opts, logLevel);
+        break;
+      default:
+    }
+    if (typeof opts.message === "function") {
+      opts.message = opts.message();
+    }
+    const messageType = typeof opts.message;
+    assert8(messageType === "string" || messageType === "object");
+    return Object.assign(opts, {
+      args
+    }, opts.opts);
+  }
+  function decorateMessage2(id, message, opts) {
+    if (typeof message === "string") {
+      const time = opts.time ? leftPad2(formatTime2(opts.total)) : "";
+      message = opts.time ? "".concat(id, ": ").concat(time, "  ").concat(message) : "".concat(id, ": ").concat(message);
+      message = addColor2(message, opts.color, opts.background);
+    }
+    return message;
+  }
+  function logImageInNode2(_ref2) {
+    let {
+      image,
+      message = "",
+      scale: scale5 = 1
+    } = _ref2;
+    console.warn("removed");
+    return noop2;
+  }
+  function logImageInBrowser2(_ref3) {
+    let {
+      image,
+      message = "",
+      scale: scale5 = 1
+    } = _ref3;
+    if (typeof image === "string") {
+      const img = new Image();
+      img.onload = () => {
+        const args = formatImage2(img, message, scale5);
+        console.log(...args);
+      };
+      img.src = image;
+      return noop2;
+    }
+    const element = image.nodeName || "";
+    if (element.toLowerCase() === "img") {
+      console.log(...formatImage2(image, message, scale5));
+      return noop2;
+    }
+    if (element.toLowerCase() === "canvas") {
+      const img = new Image();
+      img.onload = () => console.log(...formatImage2(img, message, scale5));
+      img.src = image.toDataURL();
+      return noop2;
+    }
+    return noop2;
+  }
+  function getTableHeader2(table) {
+    for (const key in table) {
+      for (const title in table[key]) {
+        return title || "untitled";
+      }
+    }
+    return "empty";
+  }
+  var originalConsole2, DEFAULT_LOG_CONFIGURATION2, cache2, ONCE2, Log2;
+  var init_log3 = __esm({
+    "node_modules/@probe.gl/log/dist/log.js"() {
+      init_dist3();
+      init_local_storage2();
+      init_formatters2();
+      init_color2();
+      init_autobind2();
+      init_assert7();
+      init_hi_res_timestamp2();
+      originalConsole2 = {
+        debug: isBrowser5() ? console.debug || console.log : console.log,
+        log: console.log,
+        info: console.info,
+        warn: console.warn,
+        error: console.error
+      };
+      DEFAULT_LOG_CONFIGURATION2 = {
+        enabled: true,
+        level: 0
+      };
+      cache2 = {};
+      ONCE2 = {
+        once: true
+      };
+      Log2 = class {
+        constructor() {
+          let {
+            id
+          } = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {
+            id: ""
+          };
+          this.id = void 0;
+          this.VERSION = VERSION10;
+          this._startTs = getHiResTimestamp2();
+          this._deltaTs = getHiResTimestamp2();
+          this._storage = void 0;
+          this.userData = {};
+          this.LOG_THROTTLE_TIMEOUT = 0;
+          this.id = id;
+          this.userData = {};
+          this._storage = new LocalStorage2("__probe-".concat(this.id, "__"), DEFAULT_LOG_CONFIGURATION2);
+          this.timeStamp("".concat(this.id, " started"));
+          autobind2(this);
+          Object.seal(this);
+        }
+        set level(newLevel) {
+          this.setLevel(newLevel);
+        }
+        get level() {
+          return this.getLevel();
+        }
+        isEnabled() {
+          return this._storage.config.enabled;
+        }
+        getLevel() {
+          return this._storage.config.level;
+        }
+        getTotal() {
+          return Number((getHiResTimestamp2() - this._startTs).toPrecision(10));
+        }
+        getDelta() {
+          return Number((getHiResTimestamp2() - this._deltaTs).toPrecision(10));
+        }
+        set priority(newPriority) {
+          this.level = newPriority;
+        }
+        get priority() {
+          return this.level;
+        }
+        getPriority() {
+          return this.level;
+        }
+        enable() {
+          let enabled = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+          this._storage.setConfiguration({
+            enabled
+          });
+          return this;
+        }
+        setLevel(level) {
+          this._storage.setConfiguration({
+            level
+          });
+          return this;
+        }
+        get(setting) {
+          return this._storage.config[setting];
+        }
+        set(setting, value) {
+          this._storage.setConfiguration({
+            [setting]: value
+          });
+        }
+        settings() {
+          if (console.table) {
+            console.table(this._storage.config);
+          } else {
+            console.log(this._storage.config);
+          }
+        }
+        assert(condition, message) {
+          assert8(condition, message);
+        }
+        warn(message) {
+          return this._getLogFunction(0, message, originalConsole2.warn, arguments, ONCE2);
+        }
+        error(message) {
+          return this._getLogFunction(0, message, originalConsole2.error, arguments);
+        }
+        deprecated(oldUsage, newUsage) {
+          return this.warn("`".concat(oldUsage, "` is deprecated and will be removed in a later version. Use `").concat(newUsage, "` instead"));
+        }
+        removed(oldUsage, newUsage) {
+          return this.error("`".concat(oldUsage, "` has been removed. Use `").concat(newUsage, "` instead"));
+        }
+        probe(logLevel, message) {
+          return this._getLogFunction(logLevel, message, originalConsole2.log, arguments, {
+            time: true,
+            once: true
+          });
+        }
+        log(logLevel, message) {
+          return this._getLogFunction(logLevel, message, originalConsole2.debug, arguments);
+        }
+        info(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.info, arguments);
+        }
+        once(logLevel, message) {
+          return this._getLogFunction(logLevel, message, originalConsole2.debug || originalConsole2.info, arguments, ONCE2);
+        }
+        table(logLevel, table, columns) {
+          if (table) {
+            return this._getLogFunction(logLevel, table, console.table || noop2, columns && [columns], {
+              tag: getTableHeader2(table)
+            });
+          }
+          return noop2;
+        }
+        image(_ref) {
+          let {
+            logLevel,
+            priority,
+            image,
+            message = "",
+            scale: scale5 = 1
+          } = _ref;
+          if (!this._shouldLog(logLevel || priority)) {
+            return noop2;
+          }
+          return isBrowser5() ? logImageInBrowser2({
+            image,
+            message,
+            scale: scale5
+          }) : logImageInNode2({
+            image,
+            message,
+            scale: scale5
+          });
+        }
+        time(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.time ? console.time : console.info);
+        }
+        timeEnd(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.timeEnd ? console.timeEnd : console.info);
+        }
+        timeStamp(logLevel, message) {
+          return this._getLogFunction(logLevel, message, console.timeStamp || noop2);
+        }
+        group(logLevel, message) {
+          let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {
+            collapsed: false
+          };
+          const options = normalizeArguments2({
+            logLevel,
+            message,
+            opts
+          });
+          const {
+            collapsed
+          } = opts;
+          options.method = (collapsed ? console.groupCollapsed : console.group) || console.info;
+          return this._getLogFunction(options);
+        }
+        groupCollapsed(logLevel, message) {
+          let opts = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {};
+          return this.group(logLevel, message, Object.assign({}, opts, {
+            collapsed: true
+          }));
+        }
+        groupEnd(logLevel) {
+          return this._getLogFunction(logLevel, "", console.groupEnd || noop2);
+        }
+        withGroup(logLevel, message, func) {
+          this.group(logLevel, message)();
+          try {
+            func();
+          } finally {
+            this.groupEnd(logLevel)();
+          }
+        }
+        trace() {
+          if (console.trace) {
+            console.trace();
+          }
+        }
+        _shouldLog(logLevel) {
+          return this.isEnabled() && this.getLevel() >= normalizeLogLevel2(logLevel);
+        }
+        _getLogFunction(logLevel, message, method, args, opts) {
+          if (this._shouldLog(logLevel)) {
+            opts = normalizeArguments2({
+              logLevel,
+              message,
+              args,
+              opts
+            });
+            method = method || opts.method;
+            assert8(method);
+            opts.total = this.getTotal();
+            opts.delta = this.getDelta();
+            this._deltaTs = getHiResTimestamp2();
+            const tag = opts.tag || opts.message;
+            if (opts.once && tag) {
+              if (!cache2[tag]) {
+                cache2[tag] = getHiResTimestamp2();
+              } else {
+                return noop2;
+              }
+            }
+            message = decorateMessage2(this.id, opts.message, opts);
+            return method.bind(console, message, ...opts.args);
+          }
+          return noop2;
+        }
+      };
+      Log2.VERSION = VERSION10;
+    }
+  });
+
+  // node_modules/@probe.gl/log/dist/index.js
+  var dist_default2;
+  var init_dist4 = __esm({
+    "node_modules/@probe.gl/log/dist/index.js"() {
+      init_log3();
+      dist_default2 = new Log2({
+        id: "@probe.gl/log"
+      });
+    }
+  });
+
   // ../../node_modules/long/index.js
   function Long(low, high, unsigned) {
     this.low = low | 0;
@@ -12753,27 +13359,27 @@
     return value ? 31 - c : c;
   }
   function fromInt(value, unsigned) {
-    var obj, cachedObj, cache2;
+    var obj, cachedObj, cache3;
     if (unsigned) {
       value >>>= 0;
-      if (cache2 = 0 <= value && value < 256) {
+      if (cache3 = 0 <= value && value < 256) {
         cachedObj = UINT_CACHE[value];
         if (cachedObj)
           return cachedObj;
       }
       obj = fromBits(value, 0, true);
-      if (cache2)
+      if (cache3)
         UINT_CACHE[value] = obj;
       return obj;
     } else {
       value |= 0;
-      if (cache2 = -128 <= value && value < 128) {
+      if (cache3 = -128 <= value && value < 128) {
         cachedObj = INT_CACHE[value];
         if (cachedObj)
           return cachedObj;
       }
       obj = fromBits(value, value < 0 ? -1 : 0, false);
-      if (cache2)
+      if (cache3)
         INT_CACHE[value] = obj;
       return obj;
     }
@@ -13995,7 +14601,7 @@
   }
   async function parseImplicitTiles(params) {
     const {
-      options,
+      implicitOptions,
       parentData = {
         mortonIndex: 0,
         x: 0,
@@ -14010,7 +14616,8 @@
         y: 0,
         z: 0
       },
-      s2VolumeBox
+      s2VolumeBox,
+      loaderOptions
     } = params;
     let { subtree, level = 0 } = params;
     const {
@@ -14020,30 +14627,38 @@
       contentUrlTemplate,
       subtreesUriTemplate,
       basePath
-    } = options;
+    } = implicitOptions;
     const tile = { children: [], lodMetricValue: 0, contentUrl: "" };
+    if (!maximumLevel) {
+      dist_default2.once(`Missing 'maximumLevel' or 'availableLevels' property. The subtree ${contentUrlTemplate} won't be loaded...`);
+      return tile;
+    }
+    const lev = level + globalData.level;
+    if (lev > maximumLevel) {
+      return tile;
+    }
     const childrenPerTile = SUBDIVISION_COUNT_MAP[subdivisionScheme];
+    const bitsPerTile = Math.log2(childrenPerTile);
     const childX = childIndex & 1;
     const childY = childIndex >> 1 & 1;
     const childZ = childIndex >> 2 & 1;
     const levelOffset = (childrenPerTile ** level - 1) / (childrenPerTile - 1);
-    let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex);
+    let childTileMortonIndex = concatBits(parentData.mortonIndex, childIndex, bitsPerTile);
     let tileAvailabilityIndex = levelOffset + childTileMortonIndex;
-    let childTileX = concatBits(parentData.x, childX);
-    let childTileY = concatBits(parentData.y, childY);
-    let childTileZ = concatBits(parentData.z, childZ);
+    let childTileX = concatBits(parentData.x, childX, 1);
+    let childTileY = concatBits(parentData.y, childY, 1);
+    let childTileZ = concatBits(parentData.z, childZ, 1);
     let isChildSubtreeAvailable = false;
-    if (level + 1 > subtreeLevels) {
+    if (level >= subtreeLevels) {
       isChildSubtreeAvailable = getAvailabilityResult(subtree.childSubtreeAvailability, childTileMortonIndex);
     }
-    const x = concatBits(globalData.x, childTileX);
-    const y = concatBits(globalData.y, childTileY);
-    const z = concatBits(globalData.z, childTileZ);
-    const lev = level + globalData.level;
+    const x = concatBits(globalData.x, childTileX, level * bitsPerTile);
+    const y = concatBits(globalData.y, childTileY, level * bitsPerTile);
+    const z = concatBits(globalData.z, childTileZ, level * bitsPerTile);
     if (isChildSubtreeAvailable) {
       const subtreePath = `${basePath}/${subtreesUriTemplate}`;
       const childSubtreeUrl = replaceContentUrlTemplate(subtreePath, lev, x, y, z);
-      const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader);
+      const childSubtree = await load(childSubtreeUrl, Tile3DSubtreeLoader, loaderOptions);
       subtree = childSubtree;
       globalData.mortonIndex = childTileMortonIndex;
       globalData.x = childTileX;
@@ -14058,7 +14673,7 @@
       level = 0;
     }
     const isTileAvailable = getAvailabilityResult(subtree.tileAvailability, tileAvailabilityIndex);
-    if (!isTileAvailable || level > maximumLevel) {
+    if (!isTileAvailable) {
       return tile;
     }
     const isContentAvailable = getAvailabilityResult(subtree.contentAvailability, tileAvailabilityIndex);
@@ -14071,28 +14686,38 @@
       const childS2VolumeBox = getChildS2VolumeBox(s2VolumeBox, index, subdivisionScheme);
       const childTileParsed = await parseImplicitTiles({
         subtree,
-        options,
+        implicitOptions,
+        loaderOptions,
         parentData: pData,
         childIndex: index,
         level: childTileLevel,
-        globalData,
+        globalData: { ...globalData },
         s2VolumeBox: childS2VolumeBox
       });
       if (childTileParsed.contentUrl || childTileParsed.children.length) {
         const globalLevel = lev + 1;
         const childCoordinates = { childTileX, childTileY, childTileZ };
-        const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, options, s2VolumeBox);
+        const formattedTile = formatTileData(childTileParsed, globalLevel, childCoordinates, implicitOptions, s2VolumeBox);
         tile.children.push(formattedTile);
       }
     }
     return tile;
   }
   function getAvailabilityResult(availabilityData, index) {
-    if ("constant" in availabilityData) {
-      return Boolean(availabilityData.constant);
+    let availabilityObject;
+    if (Array.isArray(availabilityData)) {
+      availabilityObject = availabilityData[0];
+      if (availabilityData.length > 1) {
+        dist_default2.once('Not supported extension "3DTILES_multiple_contents" has been detected');
+      }
+    } else {
+      availabilityObject = availabilityData;
+    }
+    if ("constant" in availabilityObject) {
+      return Boolean(availabilityObject.constant);
     }
-    if (availabilityData.explicitBitstream) {
-      return getBooleanValueFromBitstream(index, availabilityData.explicitBitstream);
+    if (availabilityObject.explicitBitstream) {
+      return getBooleanValueFromBitstream(index, availabilityObject.explicitBitstream);
     }
     return false;
   }
@@ -14147,8 +14772,8 @@
     }
     throw new Error(`Unsupported bounding volume type ${rootBoundingVolume}`);
   }
-  function concatBits(first, second) {
-    return parseInt(first.toString(2) + second.toString(2), 2);
+  function concatBits(higher, lower, shift) {
+    return (higher << shift) + lower;
   }
   function replaceContentUrlTemplate(templateUrl, level, x, y, z) {
     const mapUrl = generateMapUrl({ level, x, y, z });
@@ -14172,6 +14797,7 @@
     "src/lib/parsers/helpers/parse-3d-implicit-tiles.ts"() {
       init_tile_3d_subtree_loader();
       init_src3();
+      init_dist4();
       init_s2();
       init_s2_corners_to_obb();
       QUADTREE_DEVISION_COUNT = 4;
@@ -14280,6 +14906,7 @@
     const {
       subdivisionScheme,
       maximumLevel,
+      availableLevels,
       subtreeLevels,
       subtrees: { uri: subtreesUriTemplate }
     } = implicitTilingExtension;
@@ -14301,7 +14928,7 @@
       subtreesUriTemplate,
       subdivisionScheme,
       subtreeLevels,
-      maximumLevel,
+      maximumLevel: Number.isFinite(availableLevels) ? availableLevels - 1 : maximumLevel,
       refine,
       basePath,
       lodMetricType: LOD_METRIC_TYPE.GEOMETRIC_ERROR,
@@ -14310,15 +14937,16 @@
       getTileType,
       getRefine
     };
-    return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions);
+    return await normalizeImplicitTileData(tile, basePath, subtree, implicitOptions, options);
   }
-  async function normalizeImplicitTileData(tile, basePath, rootSubtree, options) {
+  async function normalizeImplicitTileData(tile, basePath, rootSubtree, implicitOptions, loaderOptions) {
     if (!tile) {
       return null;
     }
     const { children, contentUrl } = await parseImplicitTiles({
       subtree: rootSubtree,
-      options
+      implicitOptions,
+      loaderOptions
     });
     let tileContentUrl;
     let tileContent = null;