@loaders.gl/i3s 4.3.2 → 4.4.0-alpha.1

package/dist/dist.dev.js

@@ -4305,1082 +4305,631 @@ var __exports__ = (() => {
     ...GL_TYPE
   };
 
-  // ../loader-utils/src/loader-types.ts
-  async function parseFromContext(data, loaders, options, context) {
-    return context._parse(data, loaders, options, context);
+  // ../../node_modules/@math.gl/core/dist/lib/common.js
+  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+  var DEFAULT_CONFIG = {
+    EPSILON: 1e-12,
+    debug: false,
+    precision: 4,
+    printTypes: false,
+    printDegrees: false,
+    printRowMajor: true,
+    _cartographicRadians: false
+  };
+  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
+  var config = globalThis.mathgl.config;
+  function formatValue(value, { precision = config.precision } = {}) {
+    value = round(value);
+    return `${parseFloat(value.toPrecision(precision))}`;
   }
-
-  // ../loader-utils/src/lib/env-utils/assert.ts
-  function assert(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loader assertion failed.");
-    }
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
-
-  // ../loader-utils/src/lib/env-utils/globals.ts
-  var globals = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_ = globals.self || globals.window || globals.global || {};
-  var window_ = globals.window || globals.self || globals.global || {};
-  var global_ = globals.global || globals.self || globals.window || {};
-  var document_ = globals.document || {};
-  var isBrowser = (
-    // @ts-ignore process does not exist on browser
-    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
-  );
-  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion = matches && parseFloat(matches[1]) || 0;
-
-  // ../loader-utils/src/lib/module-utils/js-module-utils.ts
-  function registerJSModules(modules) {
-    globalThis.loaders ||= {};
-    globalThis.loaders.modules ||= {};
-    Object.assign(globalThis.loaders.modules, modules);
+  function toRadians(degrees2) {
+    return radians(degrees2);
   }
-  function getJSModuleOrNull(name) {
-    const module = globalThis.loaders?.modules?.[name];
-    return module || null;
+  function toDegrees(radians2) {
+    return degrees(radians2);
   }
-
-  // ../worker-utils/src/lib/env-utils/version.ts
-  var NPM_TAG = "latest";
-  function getVersion() {
-    if (!globalThis._loadersgl_?.version) {
-      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (typeof __VERSION__ === "undefined") {
-        console.warn(
-          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
-        );
-        globalThis._loadersgl_.version = NPM_TAG;
-      } else {
-        globalThis._loadersgl_.version = __VERSION__;
+  function radians(degrees2, result) {
+    return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
+  }
+  function degrees(radians2, result) {
+    return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
+  }
+  function equals(a, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+      config.EPSILON = epsilon;
+    }
+    try {
+      if (a === b) {
+        return true;
+      }
+      if (isArray(a) && isArray(b)) {
+        if (a.length !== b.length) {
+          return false;
+        }
+        for (let i = 0; i < a.length; ++i) {
+          if (!equals(a[i], b[i])) {
+            return false;
+          }
+        }
+        return true;
       }
+      if (a && a.equals) {
+        return a.equals(b);
+      }
+      if (b && b.equals) {
+        return b.equals(a);
+      }
+      if (typeof a === "number" && typeof b === "number") {
+        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+      }
+      return false;
+    } finally {
+      config.EPSILON = oldEpsilon;
     }
-    return globalThis._loadersgl_.version;
   }
-  var VERSION = getVersion();
-
-  // ../worker-utils/src/lib/env-utils/assert.ts
-  function assert2(condition, message) {
-    if (!condition) {
-      throw new Error(message || "loaders.gl assertion failed.");
-    }
+  function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
   }
-
-  // ../worker-utils/src/lib/env-utils/globals.ts
-  var globals2 = {
-    self: typeof self !== "undefined" && self,
-    window: typeof window !== "undefined" && window,
-    global: typeof global !== "undefined" && global,
-    document: typeof document !== "undefined" && document
-  };
-  var self_2 = globals2.self || globals2.window || globals2.global || {};
-  var window_2 = globals2.window || globals2.self || globals2.global || {};
-  var global_2 = globals2.global || globals2.self || globals2.window || {};
-  var document_2 = globals2.document || {};
-  var isBrowser2 = (
-    // @ts-ignore process.browser
-    typeof process !== "object" || String(process) !== "[object process]" || process.browser
-  );
-  var isWorker = typeof importScripts === "function";
-  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
-  var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
-  var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
-
-  // ../worker-utils/src/lib/library-utils/library-utils.ts
-  var loadLibraryPromises = {};
-  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
-    if (moduleName) {
-      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
-    }
-    loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
-    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
-    return await loadLibraryPromises[libraryUrl];
+  function duplicateArray(array) {
+    return array.clone ? array.clone() : new Array(array.length);
   }
-  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
-    if (!options.useLocalLibraries && library.startsWith("http")) {
-      return library;
+  function map(value, func, result) {
+    if (isArray(value)) {
+      const array = value;
+      result = result || duplicateArray(array);
+      for (let i = 0; i < result.length && i < array.length; ++i) {
+        const val = typeof value === "number" ? value : value[i];
+        result[i] = func(val, i, result);
+      }
+      return result;
     }
-    libraryName = libraryName || library;
-    const modules = options.modules || {};
-    if (modules[libraryName]) {
-      return modules[libraryName];
+    return func(value);
+  }
+
+  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
+  var MathArray = class extends Array {
+    // Common methods
+    /**
+     * Clone the current object
+     * @returns a new copy of this object
+     */
+    clone() {
+      return new this.constructor().copy(this);
     }
-    if (!isBrowser2) {
-      return `modules/${moduleName}/dist/libs/${libraryName}`;
+    fromArray(array, offset = 0) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = array[i + offset];
+      }
+      return this.check();
     }
-    if (options.CDN) {
-      assert2(options.CDN.startsWith("http"));
-      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
+    toArray(targetArray = [], offset = 0) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        targetArray[offset + i] = this[i];
+      }
+      return targetArray;
     }
-    if (isWorker) {
-      return `../src/libs/${libraryName}`;
+    toObject(targetObject) {
+      return targetObject;
     }
-    return `modules/${moduleName}/src/libs/${libraryName}`;
-  }
-  async function loadLibraryFromFile(libraryUrl) {
-    if (libraryUrl.endsWith("wasm")) {
-      return await loadAsArrayBuffer(libraryUrl);
+    from(arrayOrObject) {
+      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
+        // @ts-ignore
+        this.fromObject(arrayOrObject)
+      );
     }
-    if (!isBrowser2) {
-      try {
-        const { requireFromFile } = globalThis.loaders || {};
-        return await requireFromFile?.(libraryUrl);
-      } catch (error) {
-        console.error(error);
-        return null;
+    to(arrayOrObject) {
+      if (arrayOrObject === this) {
+        return this;
       }
+      return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
     }
-    if (isWorker) {
-      return importScripts(libraryUrl);
+    toTarget(target) {
+      return target ? this.to(target) : this;
     }
-    const scriptSource = await loadAsText(libraryUrl);
-    return loadLibraryFromString(scriptSource, libraryUrl);
-  }
-  function loadLibraryFromString(scriptSource, id) {
-    if (!isBrowser2) {
-      const { requireFromString } = globalThis.loaders || {};
-      return requireFromString?.(scriptSource, id);
+    /** @deprecated */
+    toFloat32Array() {
+      return new Float32Array(this);
     }
-    if (isWorker) {
-      eval.call(globalThis, scriptSource);
-      return null;
+    toString() {
+      return this.formatString(config);
     }
-    const script = document.createElement("script");
-    script.id = id;
-    try {
-      script.appendChild(document.createTextNode(scriptSource));
-    } catch (e) {
-      script.text = scriptSource;
+    /** Formats string according to options */
+    formatString(opts) {
+      let string = "";
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
+      }
+      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
     }
-    document.body.appendChild(script);
-    return null;
-  }
-  async function loadAsArrayBuffer(url) {
-    const { readFileAsArrayBuffer } = globalThis.loaders || {};
-    if (isBrowser2 || !readFileAsArrayBuffer || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.arrayBuffer();
+    equals(array) {
+      if (!array || this.length !== array.length) {
+        return false;
+      }
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        if (!equals(this[i], array[i])) {
+          return false;
+        }
+      }
+      return true;
     }
-    return await readFileAsArrayBuffer(url);
-  }
-  async function loadAsText(url) {
-    const { readFileAsText } = globalThis.loaders || {};
-    if (isBrowser2 || !readFileAsText || url.startsWith("http")) {
-      const response = await fetch(url);
-      return await response.text();
+    exactEquals(array) {
+      if (!array || this.length !== array.length) {
+        return false;
+      }
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        if (this[i] !== array[i]) {
+          return false;
+        }
+      }
+      return true;
     }
-    return await readFileAsText(url);
-  }
-
-  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
-  function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
-    byteLength = byteLength || arrayBuffer1.byteLength;
-    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
-      return false;
+    // Modifiers
+    /** Negates all values in this object */
+    negate() {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = -this[i];
+      }
+      return this.check();
     }
-    const array1 = new Uint8Array(arrayBuffer1);
-    const array2 = new Uint8Array(arrayBuffer2);
-    for (let i = 0; i < array1.length; ++i) {
-      if (array1[i] !== array2[i]) {
-        return false;
+    lerp(a, b, t) {
+      if (t === void 0) {
+        return this.lerp(this, a, b);
+      }
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        const ai = a[i];
+        const endValue = typeof b === "number" ? b : b[i];
+        this[i] = ai + t * (endValue - ai);
       }
+      return this.check();
     }
-    return true;
-  }
-  function concatenateArrayBuffers(...sources) {
-    return concatenateArrayBuffersFromArray(sources);
-  }
-  function concatenateArrayBuffersFromArray(sources) {
-    const sourceArrays = sources.map(
-      (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
-    );
-    const byteLength = sourceArrays.reduce((length4, typedArray) => length4 + typedArray.byteLength, 0);
-    const result = new Uint8Array(byteLength);
-    let offset = 0;
-    for (const sourceArray of sourceArrays) {
-      result.set(sourceArray, offset);
-      offset += sourceArray.byteLength;
+    /** Minimal */
+    min(vector) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = Math.min(vector[i], this[i]);
+      }
+      return this.check();
     }
-    return result.buffer;
-  }
-
-  // ../loader-utils/src/lib/iterators/async-iteration.ts
-  async function concatenateArrayBuffersAsync(asyncIterator) {
-    const arrayBuffers = [];
-    for await (const chunk of asyncIterator) {
-      arrayBuffers.push(chunk);
+    /** Maximal */
+    max(vector) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = Math.max(vector[i], this[i]);
+      }
+      return this.check();
     }
-    return concatenateArrayBuffers(...arrayBuffers);
-  }
-
-  // ../loader-utils/src/lib/node/buffer.browser.ts
-  function toArrayBuffer(buffer) {
-    return buffer;
-  }
-
-  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
-  function isBuffer(value) {
-    return value && typeof value === "object" && value.isBuffer;
-  }
-  function toArrayBuffer2(data) {
-    if (isBuffer(data)) {
-      return toArrayBuffer(data);
+    clamp(minVector, maxVector) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
+      }
+      return this.check();
     }
-    if (data instanceof ArrayBuffer) {
-      return data;
+    add(...vectors) {
+      for (const vector of vectors) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] += vector[i];
+        }
+      }
+      return this.check();
     }
-    if (ArrayBuffer.isView(data)) {
-      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-        return data.buffer;
+    subtract(...vectors) {
+      for (const vector of vectors) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] -= vector[i];
+        }
       }
-      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+      return this.check();
     }
-    if (typeof data === "string") {
-      const text = data;
-      const uint8Array = new TextEncoder().encode(text);
-      return uint8Array.buffer;
+    scale(scale6) {
+      if (typeof scale6 === "number") {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] *= scale6;
+        }
+      } else {
+        for (let i = 0; i < this.ELEMENTS && i < scale6.length; ++i) {
+          this[i] *= scale6[i];
+        }
+      }
+      return this.check();
     }
-    if (data && typeof data === "object" && data._toArrayBuffer) {
-      return data._toArrayBuffer();
+    /**
+     * Multiplies all elements by `scale`
+     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
+     */
+    multiplyByScalar(scalar) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] *= scalar;
+      }
+      return this.check();
     }
-    throw new Error("toArrayBuffer");
-  }
-
-  // ../loader-utils/src/lib/node/promisify.ts
-  function promisify1(fn) {
-    return (args) => new Promise(
-      (resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs))
-    );
-  }
-
-  // ../loader-utils/src/lib/files/node-file-facade.ts
-  var NOT_IMPLEMENTED = new Error("Not implemented");
-  var NodeFileFacade = class {
-    handle;
-    size = 0;
-    bigsize = 0n;
-    url = "";
-    constructor(url, flags, mode) {
-      if (globalThis.loaders?.NodeFile) {
-        return new globalThis.loaders.NodeFile(url, flags, mode);
+    // Debug checks
+    /** Throws an error if array length is incorrect or contains illegal values */
+    check() {
+      if (config.debug && !this.validate()) {
+        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
       }
-      if (isBrowser) {
-        throw new Error("Can't instantiate NodeFile in browser.");
+      return this;
+    }
+    /** Returns false if the array length is incorrect or contains illegal values */
+    validate() {
+      let valid = this.length === this.ELEMENTS;
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        valid = valid && Number.isFinite(this[i]);
       }
-      throw new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
+      return valid;
     }
-    /** Read data */
-    async read(start, end) {
-      throw NOT_IMPLEMENTED;
+    // three.js compatibility
+    /** @deprecated */
+    sub(a) {
+      return this.subtract(a);
     }
-    /** Write to file. The number of bytes written will be returned */
-    async write(arrayBuffer, offset, length4) {
-      throw NOT_IMPLEMENTED;
+    /** @deprecated */
+    setScalar(a) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = a;
+      }
+      return this.check();
     }
-    /** Get information about file */
-    async stat() {
-      throw NOT_IMPLEMENTED;
+    /** @deprecated */
+    addScalar(a) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] += a;
+      }
+      return this.check();
     }
-    /** Truncates the file descriptor. Only available on NodeFile. */
-    async truncate(length4) {
-      throw NOT_IMPLEMENTED;
+    /** @deprecated */
+    subScalar(a) {
+      return this.addScalar(-a);
     }
-    /** Append data to a file. Only available on NodeFile. */
-    async append(data) {
-      throw NOT_IMPLEMENTED;
+    /** @deprecated */
+    multiplyScalar(scalar) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] *= scalar;
+      }
+      return this.check();
     }
-    /** Close the file */
-    async close() {
+    /** @deprecated */
+    divideScalar(a) {
+      return this.multiplyByScalar(1 / a);
+    }
+    /** @deprecated */
+    clampScalar(min2, max2) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = Math.min(Math.max(this[i], min2), max2);
+      }
+      return this.check();
+    }
+    /** @deprecated */
+    get elements() {
+      return this;
     }
   };
 
-  // ../loader-utils/src/lib/file-provider/file-provider-interface.ts
-  var isFileProvider = (fileProvider) => {
-    return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
-  };
-
-  // ../loader-utils/src/lib/file-provider/file-handle-file.ts
-  var FileHandleFile = class {
-    /** The FileHandle from which data is provided */
-    file;
-    /** Create a new FileHandleFile */
-    constructor(path, append = false) {
-      this.file = new NodeFileFacade(path, append ? "a+" : "r");
+  // ../../node_modules/@math.gl/core/dist/lib/validators.js
+  function validateVector(v, length4) {
+    if (v.length !== length4) {
+      return false;
+    }
+    for (let i = 0; i < v.length; ++i) {
+      if (!Number.isFinite(v[i])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function checkNumber(value) {
+    if (!Number.isFinite(value)) {
+      throw new Error(`Invalid number ${JSON.stringify(value)}`);
+    }
+    return value;
+  }
+  function checkVector(v, length4, callerName = "") {
+    if (config.debug && !validateVector(v, length4)) {
+      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
+    }
+    return v;
+  }
+
+  // ../../node_modules/@math.gl/core/dist/lib/assert.js
+  function assert(condition, message) {
+    if (!condition) {
+      throw new Error(`math.gl assertion ${message}`);
+    }
+  }
+
+  // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
+  var Vector = class extends MathArray {
+    // ACCESSORS
+    get x() {
+      return this[0];
+    }
+    set x(value) {
+      this[0] = checkNumber(value);
+    }
+    get y() {
+      return this[1];
+    }
+    set y(value) {
+      this[1] = checkNumber(value);
     }
     /**
-     * Truncates the file descriptor.
-     * @param length desired file lenght
+     * Returns the length of the vector from the origin to the point described by this vector
+     *
+     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
+     * Instead we provide `len` and `magnitude`
      */
-    async truncate(length4) {
-      await this.file.truncate(length4);
+    len() {
+      return Math.sqrt(this.lengthSquared());
     }
     /**
-     * Append data to a file.
-     * @param buffer data to append
+     * Returns the length of the vector from the origin to the point described by this vector
      */
-    async append(buffer) {
-      await this.file.append(buffer);
-    }
-    /** Close file */
-    async destroy() {
-      await this.file.close();
+    magnitude() {
+      return this.len();
     }
     /**
-     * Gets an unsigned 8-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     * Returns the squared length of the vector from the origin to the point described by this vector
      */
-    async getUint8(offset) {
-      const arrayBuffer = await this.file.read(offset, 1);
-      const val = new Uint8Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
+    lengthSquared() {
+      let length4 = 0;
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        length4 += this[i] * this[i];
       }
-      return val;
+      return length4;
     }
     /**
-     * Gets an unsigned 16-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     * Returns the squared length of the vector from the origin to the point described by this vector
      */
-    async getUint16(offset) {
-      const arrayBuffer = await this.file.read(offset, 2);
-      const val = new Uint16Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
+    magnitudeSquared() {
+      return this.lengthSquared();
+    }
+    distance(mathArray) {
+      return Math.sqrt(this.distanceSquared(mathArray));
+    }
+    distanceSquared(mathArray) {
+      let length4 = 0;
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        const dist2 = this[i] - mathArray[i];
+        length4 += dist2 * dist2;
       }
-      return val;
+      return checkNumber(length4);
     }
-    /**
-     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint32(offset) {
-      const arrayBuffer = await this.file.read(offset, 4);
-      const val = new Uint32Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
+    dot(mathArray) {
+      let product = 0;
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        product += this[i] * mathArray[i];
       }
-      return val;
+      return checkNumber(product);
     }
-    /**
-     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getBigUint64(offset) {
-      const arrayBuffer = await this.file.read(offset, 8);
-      const val = new BigInt64Array(arrayBuffer).at(0);
-      if (val === void 0) {
-        throw new Error("something went wrong");
+    // MODIFIERS
+    normalize() {
+      const length4 = this.magnitude();
+      if (length4 !== 0) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] /= length4;
+        }
       }
-      return val;
+      return this.check();
     }
-    /**
-     * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
-     * @param startOffset The offset, in byte, from the start of the file where to start reading the data.
-     * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
-     */
-    async slice(startOffset, endOffset) {
-      const bigLength = endOffset - startOffset;
-      if (bigLength > Number.MAX_SAFE_INTEGER) {
-        throw new Error("too big slice");
+    multiply(...vectors) {
+      for (const vector of vectors) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] *= vector[i];
+        }
       }
-      const length4 = Number(bigLength);
-      return await this.file.read(startOffset, length4);
+      return this.check();
     }
-    /**
-     * the length (in bytes) of the data.
-     */
-    get length() {
-      return this.file.bigsize;
+    divide(...vectors) {
+      for (const vector of vectors) {
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] /= vector[i];
+        }
+      }
+      return this.check();
     }
-  };
-
-  // ../loader-utils/src/lib/file-provider/data-view-file.ts
-  var toNumber = (bigint) => {
-    if (bigint > Number.MAX_SAFE_INTEGER) {
-      throw new Error("Offset is out of bounds");
+    // THREE.js compatibility
+    lengthSq() {
+      return this.lengthSquared();
     }
-    return Number(bigint);
-  };
-  var DataViewFile = class {
-    /** The DataView from which data is provided */
-    file;
-    constructor(file) {
-      this.file = file;
+    distanceTo(vector) {
+      return this.distance(vector);
     }
-    async destroy() {
+    distanceToSquared(vector) {
+      return this.distanceSquared(vector);
     }
-    /**
-     * Gets an unsigned 8-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint8(offset) {
-      return this.file.getUint8(toNumber(offset));
+    getComponent(i) {
+      assert(i >= 0 && i < this.ELEMENTS, "index is out of range");
+      return checkNumber(this[i]);
     }
-    /**
-     * Gets an unsigned 16-bit intege at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint16(offset) {
-      return this.file.getUint16(toNumber(offset), true);
+    setComponent(i, value) {
+      assert(i >= 0 && i < this.ELEMENTS, "index is out of range");
+      this[i] = value;
+      return this.check();
     }
-    /**
-     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getUint32(offset) {
-      return this.file.getUint32(toNumber(offset), true);
+    addVectors(a, b) {
+      return this.copy(a).add(b);
     }
-    /**
-     * Gets an unsigned 64-bit integer at the specified byte offset from the start of the file.
-     * @param offset The offset, in bytes, from the start of the file where to read the data.
-     */
-    async getBigUint64(offset) {
-      return this.file.getBigUint64(toNumber(offset), true);
+    subVectors(a, b) {
+      return this.copy(a).subtract(b);
     }
-    /**
-     * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
-     * @param startOffset The offset, in bytes, from the start of the file where to start reading the data.
-     * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
-     */
-    async slice(startOffset, endOffset) {
-      return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
+    multiplyVectors(a, b) {
+      return this.copy(a).multiply(b);
     }
-    /** the length (in bytes) of the data. */
-    get length() {
-      return BigInt(this.file.byteLength);
+    addScaledVector(a, b) {
+      return this.add(new this.constructor(a).multiplyScalar(b));
     }
   };
 
-  // ../../node_modules/@math.gl/core/dist/lib/common.js
-  var RADIANS_TO_DEGREES = 1 / Math.PI * 180;
-  var DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
-  var DEFAULT_CONFIG = {
-    EPSILON: 1e-12,
-    debug: false,
-    precision: 4,
-    printTypes: false,
-    printDegrees: false,
-    printRowMajor: true,
-    _cartographicRadians: false
-  };
-  globalThis.mathgl = globalThis.mathgl || { config: { ...DEFAULT_CONFIG } };
-  var config = globalThis.mathgl.config;
-  function formatValue(value, { precision = config.precision } = {}) {
-    value = round(value);
-    return `${parseFloat(value.toPrecision(precision))}`;
-  }
-  function isArray(value) {
-    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
-  }
-  function toRadians(degrees2) {
-    return radians(degrees2);
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
+  var EPSILON = 1e-6;
+  var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+  var RANDOM = Math.random;
+  function round2(a) {
+    if (a >= 0)
+      return Math.round(a);
+    return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
   }
-  function toDegrees(radians2) {
-    return degrees(radians2);
+  var degree = Math.PI / 180;
+
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec2.js
+  function create() {
+    const out = new ARRAY_TYPE(2);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+    }
+    return out;
   }
-  function radians(degrees2, result) {
-    return map(degrees2, (degrees3) => degrees3 * DEGREES_TO_RADIANS, result);
+  function transformMat3(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[3] * y + m[6];
+    out[1] = m[1] * x + m[4] * y + m[7];
+    return out;
   }
-  function degrees(radians2, result) {
-    return map(radians2, (radians3) => radians3 * RADIANS_TO_DEGREES, result);
+  function transformMat4(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[4] * y + m[12];
+    out[1] = m[1] * x + m[5] * y + m[13];
+    return out;
   }
-  function equals(a, b, epsilon) {
-    const oldEpsilon = config.EPSILON;
-    if (epsilon) {
-      config.EPSILON = epsilon;
-    }
-    try {
-      if (a === b) {
-        return true;
-      }
-      if (isArray(a) && isArray(b)) {
-        if (a.length !== b.length) {
-          return false;
-        }
-        for (let i = 0; i < a.length; ++i) {
-          if (!equals(a[i], b[i])) {
-            return false;
-          }
-        }
-        return true;
+  var forEach = function() {
+    const vec = create();
+    return function(a, stride, offset, count, fn, arg) {
+      let i;
+      let l;
+      if (!stride) {
+        stride = 2;
       }
-      if (a && a.equals) {
-        return a.equals(b);
+      if (!offset) {
+        offset = 0;
       }
-      if (b && b.equals) {
-        return b.equals(a);
+      if (count) {
+        l = Math.min(count * stride + offset, a.length);
+      } else {
+        l = a.length;
       }
-      if (typeof a === "number" && typeof b === "number") {
-        return Math.abs(a - b) <= config.EPSILON * Math.max(1, Math.abs(a), Math.abs(b));
+      for (i = offset; i < l; i += stride) {
+        vec[0] = a[i];
+        vec[1] = a[i + 1];
+        fn(vec, vec, arg);
+        a[i] = vec[0];
+        a[i + 1] = vec[1];
       }
-      return false;
-    } finally {
-      config.EPSILON = oldEpsilon;
-    }
+      return a;
+    };
+  }();
+
+  // ../../node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js
+  function vec2_transformMat4AsVector(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const w = m[3] * x + m[7] * y || 1;
+    out[0] = (m[0] * x + m[4] * y) / w;
+    out[1] = (m[1] * x + m[5] * y) / w;
+    return out;
   }
-  function round(value) {
-    return Math.round(value / config.EPSILON) * config.EPSILON;
+  function vec3_transformMat4AsVector(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    const w = m[3] * x + m[7] * y + m[11] * z || 1;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
+    return out;
   }
-  function duplicateArray(array) {
-    return array.clone ? array.clone() : new Array(array.length);
+  function vec3_transformMat2(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    return out;
   }
-  function map(value, func, result) {
-    if (isArray(value)) {
-      const array = value;
-      result = result || duplicateArray(array);
-      for (let i = 0; i < result.length && i < array.length; ++i) {
-        const val = typeof value === "number" ? value : value[i];
-        result[i] = func(val, i, result);
-      }
-      return result;
-    }
-    return func(value);
+  function vec4_transformMat2(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a[2];
+    out[3] = a[3];
+    return out;
+  }
+  function vec4_transformMat3(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
+    out[0] = m[0] * x + m[3] * y + m[6] * z;
+    out[1] = m[1] * x + m[4] * y + m[7] * z;
+    out[2] = m[2] * x + m[5] * y + m[8] * z;
+    out[3] = a[3];
+    return out;
   }
 
-  // ../../node_modules/@math.gl/core/dist/classes/base/math-array.js
-  var MathArray = class extends Array {
-    // Common methods
-    /**
-     * Clone the current object
-     * @returns a new copy of this object
-     */
-    clone() {
-      return new this.constructor().copy(this);
-    }
-    fromArray(array, offset = 0) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = array[i + offset];
-      }
-      return this.check();
-    }
-    toArray(targetArray = [], offset = 0) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        targetArray[offset + i] = this[i];
-      }
-      return targetArray;
-    }
-    toObject(targetObject) {
-      return targetObject;
-    }
-    from(arrayOrObject) {
-      return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : (
-        // @ts-ignore
-        this.fromObject(arrayOrObject)
-      );
-    }
-    to(arrayOrObject) {
-      if (arrayOrObject === this) {
-        return this;
-      }
-      return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
-    }
-    toTarget(target) {
-      return target ? this.to(target) : this;
-    }
-    /** @deprecated */
-    toFloat32Array() {
-      return new Float32Array(this);
-    }
-    toString() {
-      return this.formatString(config);
-    }
-    /** Formats string according to options */
-    formatString(opts) {
-      let string = "";
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
-      }
-      return `${opts.printTypes ? this.constructor.name : ""}[${string}]`;
-    }
-    equals(array) {
-      if (!array || this.length !== array.length) {
-        return false;
-      }
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        if (!equals(this[i], array[i])) {
-          return false;
-        }
-      }
-      return true;
-    }
-    exactEquals(array) {
-      if (!array || this.length !== array.length) {
-        return false;
-      }
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        if (this[i] !== array[i]) {
-          return false;
-        }
-      }
-      return true;
-    }
-    // Modifiers
-    /** Negates all values in this object */
-    negate() {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = -this[i];
-      }
-      return this.check();
-    }
-    lerp(a, b, t) {
-      if (t === void 0) {
-        return this.lerp(this, a, b);
-      }
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        const ai = a[i];
-        const endValue = typeof b === "number" ? b : b[i];
-        this[i] = ai + t * (endValue - ai);
-      }
-      return this.check();
-    }
-    /** Minimal */
-    min(vector) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = Math.min(vector[i], this[i]);
-      }
-      return this.check();
-    }
-    /** Maximal */
-    max(vector) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = Math.max(vector[i], this[i]);
-      }
-      return this.check();
-    }
-    clamp(minVector, maxVector) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = Math.min(Math.max(this[i], minVector[i]), maxVector[i]);
-      }
-      return this.check();
-    }
-    add(...vectors) {
-      for (const vector of vectors) {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] += vector[i];
-        }
-      }
-      return this.check();
-    }
-    subtract(...vectors) {
-      for (const vector of vectors) {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] -= vector[i];
-        }
-      }
-      return this.check();
-    }
-    scale(scale6) {
-      if (typeof scale6 === "number") {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] *= scale6;
-        }
-      } else {
-        for (let i = 0; i < this.ELEMENTS && i < scale6.length; ++i) {
-          this[i] *= scale6[i];
-        }
-      }
-      return this.check();
-    }
-    /**
-     * Multiplies all elements by `scale`
-     * Note: `Matrix4.multiplyByScalar` only scales its 3x3 "minor"
-     */
-    multiplyByScalar(scalar) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] *= scalar;
-      }
-      return this.check();
-    }
-    // Debug checks
-    /** Throws an error if array length is incorrect or contains illegal values */
-    check() {
-      if (config.debug && !this.validate()) {
-        throw new Error(`math.gl: ${this.constructor.name} some fields set to invalid numbers'`);
-      }
-      return this;
-    }
-    /** Returns false if the array length is incorrect or contains illegal values */
-    validate() {
-      let valid = this.length === this.ELEMENTS;
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        valid = valid && Number.isFinite(this[i]);
-      }
-      return valid;
-    }
-    // three.js compatibility
-    /** @deprecated */
-    sub(a) {
-      return this.subtract(a);
-    }
-    /** @deprecated */
-    setScalar(a) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = a;
-      }
-      return this.check();
-    }
-    /** @deprecated */
-    addScalar(a) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] += a;
-      }
-      return this.check();
-    }
-    /** @deprecated */
-    subScalar(a) {
-      return this.addScalar(-a);
-    }
-    /** @deprecated */
-    multiplyScalar(scalar) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] *= scalar;
-      }
-      return this.check();
-    }
-    /** @deprecated */
-    divideScalar(a) {
-      return this.multiplyByScalar(1 / a);
-    }
-    /** @deprecated */
-    clampScalar(min2, max2) {
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        this[i] = Math.min(Math.max(this[i], min2), max2);
-      }
-      return this.check();
-    }
-    /** @deprecated */
-    get elements() {
-      return this;
-    }
-  };
-
-  // ../../node_modules/@math.gl/core/dist/lib/validators.js
-  function validateVector(v, length4) {
-    if (v.length !== length4) {
-      return false;
-    }
-    for (let i = 0; i < v.length; ++i) {
-      if (!Number.isFinite(v[i])) {
-        return false;
-      }
-    }
-    return true;
-  }
-  function checkNumber(value) {
-    if (!Number.isFinite(value)) {
-      throw new Error(`Invalid number ${JSON.stringify(value)}`);
-    }
-    return value;
-  }
-  function checkVector(v, length4, callerName = "") {
-    if (config.debug && !validateVector(v, length4)) {
-      throw new Error(`math.gl: ${callerName} some fields set to invalid numbers'`);
-    }
-    return v;
-  }
-
-  // ../../node_modules/@math.gl/core/dist/lib/assert.js
-  function assert3(condition, message) {
-    if (!condition) {
-      throw new Error(`math.gl assertion ${message}`);
-    }
-  }
-
-  // ../../node_modules/@math.gl/core/dist/classes/base/vector.js
-  var Vector = class extends MathArray {
-    // ACCESSORS
-    get x() {
-      return this[0];
-    }
-    set x(value) {
-      this[0] = checkNumber(value);
-    }
-    get y() {
-      return this[1];
-    }
-    set y(value) {
-      this[1] = checkNumber(value);
-    }
-    /**
-     * Returns the length of the vector from the origin to the point described by this vector
-     *
-     * @note `length` is a reserved word for Arrays, so `v.length()` will return number of elements
-     * Instead we provide `len` and `magnitude`
-     */
-    len() {
-      return Math.sqrt(this.lengthSquared());
-    }
-    /**
-     * Returns the length of the vector from the origin to the point described by this vector
-     */
-    magnitude() {
-      return this.len();
-    }
-    /**
-     * Returns the squared length of the vector from the origin to the point described by this vector
-     */
-    lengthSquared() {
-      let length4 = 0;
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        length4 += this[i] * this[i];
-      }
-      return length4;
-    }
-    /**
-     * Returns the squared length of the vector from the origin to the point described by this vector
-     */
-    magnitudeSquared() {
-      return this.lengthSquared();
-    }
-    distance(mathArray) {
-      return Math.sqrt(this.distanceSquared(mathArray));
-    }
-    distanceSquared(mathArray) {
-      let length4 = 0;
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        const dist2 = this[i] - mathArray[i];
-        length4 += dist2 * dist2;
-      }
-      return checkNumber(length4);
-    }
-    dot(mathArray) {
-      let product = 0;
-      for (let i = 0; i < this.ELEMENTS; ++i) {
-        product += this[i] * mathArray[i];
-      }
-      return checkNumber(product);
-    }
-    // MODIFIERS
-    normalize() {
-      const length4 = this.magnitude();
-      if (length4 !== 0) {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] /= length4;
-        }
-      }
-      return this.check();
-    }
-    multiply(...vectors) {
-      for (const vector of vectors) {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] *= vector[i];
-        }
-      }
-      return this.check();
-    }
-    divide(...vectors) {
-      for (const vector of vectors) {
-        for (let i = 0; i < this.ELEMENTS; ++i) {
-          this[i] /= vector[i];
-        }
-      }
-      return this.check();
-    }
-    // THREE.js compatibility
-    lengthSq() {
-      return this.lengthSquared();
-    }
-    distanceTo(vector) {
-      return this.distance(vector);
-    }
-    distanceToSquared(vector) {
-      return this.distanceSquared(vector);
-    }
-    getComponent(i) {
-      assert3(i >= 0 && i < this.ELEMENTS, "index is out of range");
-      return checkNumber(this[i]);
-    }
-    setComponent(i, value) {
-      assert3(i >= 0 && i < this.ELEMENTS, "index is out of range");
-      this[i] = value;
-      return this.check();
-    }
-    addVectors(a, b) {
-      return this.copy(a).add(b);
-    }
-    subVectors(a, b) {
-      return this.copy(a).subtract(b);
-    }
-    multiplyVectors(a, b) {
-      return this.copy(a).multiply(b);
-    }
-    addScaledVector(a, b) {
-      return this.add(new this.constructor(a).multiplyScalar(b));
-    }
-  };
-
-  // ../../node_modules/@math.gl/core/dist/gl-matrix/common.js
-  var EPSILON = 1e-6;
-  var ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
-  var RANDOM = Math.random;
-  function round2(a) {
-    if (a >= 0)
-      return Math.round(a);
-    return a % 0.5 === 0 ? Math.floor(a) : Math.round(a);
-  }
-  var degree = Math.PI / 180;
-
-  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec2.js
-  function create() {
-    const out = new ARRAY_TYPE(2);
-    if (ARRAY_TYPE != Float32Array) {
-      out[0] = 0;
-      out[1] = 0;
-    }
-    return out;
-  }
-  function transformMat3(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    out[0] = m[0] * x + m[3] * y + m[6];
-    out[1] = m[1] * x + m[4] * y + m[7];
-    return out;
-  }
-  function transformMat4(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    out[0] = m[0] * x + m[4] * y + m[12];
-    out[1] = m[1] * x + m[5] * y + m[13];
-    return out;
-  }
-  var forEach2 = function() {
-    const vec = create();
-    return function(a, stride, offset, count, fn, arg) {
-      let i;
-      let l;
-      if (!stride) {
-        stride = 2;
-      }
-      if (!offset) {
-        offset = 0;
-      }
-      if (count) {
-        l = Math.min(count * stride + offset, a.length);
-      } else {
-        l = a.length;
-      }
-      for (i = offset; i < l; i += stride) {
-        vec[0] = a[i];
-        vec[1] = a[i + 1];
-        fn(vec, vec, arg);
-        a[i] = vec[0];
-        a[i + 1] = vec[1];
-      }
-      return a;
-    };
-  }();
-
-  // ../../node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js
-  function vec2_transformMat4AsVector(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    const w = m[3] * x + m[7] * y || 1;
-    out[0] = (m[0] * x + m[4] * y) / w;
-    out[1] = (m[1] * x + m[5] * y) / w;
-    return out;
-  }
-  function vec3_transformMat4AsVector(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    const w = m[3] * x + m[7] * y + m[11] * z || 1;
-    out[0] = (m[0] * x + m[4] * y + m[8] * z) / w;
-    out[1] = (m[1] * x + m[5] * y + m[9] * z) / w;
-    out[2] = (m[2] * x + m[6] * y + m[10] * z) / w;
-    return out;
-  }
-  function vec3_transformMat2(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    out[0] = m[0] * x + m[2] * y;
-    out[1] = m[1] * x + m[3] * y;
-    out[2] = a[2];
-    return out;
-  }
-  function vec4_transformMat2(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    out[0] = m[0] * x + m[2] * y;
-    out[1] = m[1] * x + m[3] * y;
-    out[2] = a[2];
-    out[3] = a[3];
-    return out;
-  }
-  function vec4_transformMat3(out, a, m) {
-    const x = a[0];
-    const y = a[1];
-    const z = a[2];
-    out[0] = m[0] * x + m[3] * y + m[6] * z;
-    out[1] = m[1] * x + m[4] * y + m[7] * z;
-    out[2] = m[2] * x + m[5] * y + m[8] * z;
-    out[3] = a[3];
-    return out;
-  }
-
-  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
-  var vec3_exports = {};
-  __export(vec3_exports, {
-    add: () => add,
-    angle: () => angle,
-    bezier: () => bezier,
-    ceil: () => ceil,
-    clone: () => clone,
-    copy: () => copy,
-    create: () => create2,
-    cross: () => cross,
-    dist: () => dist,
-    distance: () => distance,
-    div: () => div,
-    divide: () => divide,
-    dot: () => dot,
-    equals: () => equals2,
-    exactEquals: () => exactEquals,
-    floor: () => floor,
-    forEach: () => forEach3,
-    fromValues: () => fromValues,
-    hermite: () => hermite,
-    inverse: () => inverse,
-    len: () => len,
-    length: () => length,
-    lerp: () => lerp,
-    max: () => max,
-    min: () => min,
-    mul: () => mul,
-    multiply: () => multiply,
-    negate: () => negate,
-    normalize: () => normalize,
-    random: () => random,
-    rotateX: () => rotateX,
-    rotateY: () => rotateY,
-    rotateZ: () => rotateZ,
-    round: () => round3,
-    scale: () => scale,
-    scaleAndAdd: () => scaleAndAdd,
-    set: () => set,
-    slerp: () => slerp,
-    sqrDist: () => sqrDist,
-    sqrLen: () => sqrLen,
-    squaredDistance: () => squaredDistance,
-    squaredLength: () => squaredLength,
-    str: () => str,
-    sub: () => sub,
-    subtract: () => subtract,
-    transformMat3: () => transformMat32,
-    transformMat4: () => transformMat42,
-    transformQuat: () => transformQuat,
-    zero: () => zero
-  });
-  function create2() {
-    const out = new ARRAY_TYPE(3);
-    if (ARRAY_TYPE != Float32Array) {
-      out[0] = 0;
-      out[1] = 0;
-      out[2] = 0;
+  // ../../node_modules/@math.gl/core/dist/gl-matrix/vec3.js
+  var vec3_exports = {};
+  __export(vec3_exports, {
+    add: () => add,
+    angle: () => angle,
+    bezier: () => bezier,
+    ceil: () => ceil,
+    clone: () => clone,
+    copy: () => copy,
+    create: () => create2,
+    cross: () => cross,
+    dist: () => dist,
+    distance: () => distance,
+    div: () => div,
+    divide: () => divide,
+    dot: () => dot,
+    equals: () => equals2,
+    exactEquals: () => exactEquals,
+    floor: () => floor,
+    forEach: () => forEach2,
+    fromValues: () => fromValues,
+    hermite: () => hermite,
+    inverse: () => inverse,
+    len: () => len,
+    length: () => length,
+    lerp: () => lerp,
+    max: () => max,
+    min: () => min,
+    mul: () => mul,
+    multiply: () => multiply,
+    negate: () => negate,
+    normalize: () => normalize,
+    random: () => random,
+    rotateX: () => rotateX,
+    rotateY: () => rotateY,
+    rotateZ: () => rotateZ,
+    round: () => round3,
+    scale: () => scale,
+    scaleAndAdd: () => scaleAndAdd,
+    set: () => set,
+    slerp: () => slerp,
+    sqrDist: () => sqrDist,
+    sqrLen: () => sqrLen,
+    squaredDistance: () => squaredDistance,
+    squaredLength: () => squaredLength,
+    str: () => str,
+    sub: () => sub,
+    subtract: () => subtract,
+    transformMat3: () => transformMat32,
+    transformMat4: () => transformMat42,
+    transformQuat: () => transformQuat,
+    zero: () => zero
+  });
+  function create2() {
+    const out = new ARRAY_TYPE(3);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
     }
     return out;
   }
@@ -5720,7 +5269,7 @@ var __exports__ = (() => {
   var sqrDist = squaredDistance;
   var len = length;
   var sqrLen = squaredLength;
-  var forEach3 = function() {
+  var forEach2 = function() {
     const vec = create2();
     return function(a, stride, offset, count, fn, arg) {
       let i;
@@ -7989,7 +7538,7 @@ var __exports__ = (() => {
     out[3] = a[3];
     return out;
   }
-  var forEach4 = function() {
+  var forEach3 = function() {
     const vec = create5();
     return function(a, stride, offset, count, fn, arg) {
       let i;
@@ -8789,716 +8338,1169 @@ var __exports__ = (() => {
         this.set(x, y, z, w);
       }
     }
-    copy(array) {
-      this[0] = array[0];
-      this[1] = array[1];
-      this[2] = array[2];
-      this[3] = array[3];
+    copy(array) {
+      this[0] = array[0];
+      this[1] = array[1];
+      this[2] = array[2];
+      this[3] = array[3];
+      return this.check();
+    }
+    set(x, y, z, w) {
+      this[0] = x;
+      this[1] = y;
+      this[2] = z;
+      this[3] = w;
+      return this.check();
+    }
+    fromObject(object) {
+      this[0] = object.x;
+      this[1] = object.y;
+      this[2] = object.z;
+      this[3] = object.w;
+      return this.check();
+    }
+    /**
+     * Creates a quaternion from the given 3x3 rotation matrix.
+     * NOTE: The resultant quaternion is not normalized, so you should
+     * be sure to renormalize the quaternion yourself where necessary.
+     * @param m
+     * @returns
+     */
+    fromMatrix3(m) {
+      fromMat3(this, m);
+      return this.check();
+    }
+    fromAxisRotation(axis, rad) {
+      setAxisAngle(this, axis, rad);
+      return this.check();
+    }
+    /** Set a quat to the identity quaternion */
+    identity() {
+      identity2(this);
+      return this.check();
+    }
+    // Set the components of a quat to the given values
+    // set(i, j, k, l) {
+    //   quat_set(this, i, j, k, l);
+    //   return this.check();
+    // }
+    // Sets a quat from the given angle and rotation axis, then returns it.
+    setAxisAngle(axis, rad) {
+      return this.fromAxisRotation(axis, rad);
+    }
+    // Getters/setters
+    get ELEMENTS() {
+      return 4;
+    }
+    get x() {
+      return this[0];
+    }
+    set x(value) {
+      this[0] = checkNumber(value);
+    }
+    get y() {
+      return this[1];
+    }
+    set y(value) {
+      this[1] = checkNumber(value);
+    }
+    get z() {
+      return this[2];
+    }
+    set z(value) {
+      this[2] = checkNumber(value);
+    }
+    get w() {
+      return this[3];
+    }
+    set w(value) {
+      this[3] = checkNumber(value);
+    }
+    // Calculates the length of a quat
+    len() {
+      return length3(this);
+    }
+    // Calculates the squared length of a quat
+    lengthSquared() {
+      return squaredLength3(this);
+    }
+    // Calculates the dot product of two quat's
+    // @return {Number}
+    dot(a) {
+      return dot3(this, a);
+    }
+    // Gets the rotation axis and angle for a given quaternion.
+    // If a quaternion is created with setAxisAngle, this method will
+    // return the same values as providied in the original parameter
+    // list OR functionally equivalent values.
+    // Example: The quaternion formed by axis [0, 0, 1] and angle -90
+    // is the same as the quaternion formed by [0, 0, 1] and 270.
+    // This method favors the latter.
+    // @return {{[x,y,z], Number}}
+    // getAxisAngle() {
+    //   const axis = [];
+    // //   const angle = quat_getAxisAngle(axis, this);
+    //   return {axis, angle};
+    // }
+    // MODIFIERS
+    // Sets a quaternion to represent the shortest rotation from one vector
+    // to another. Both vectors are assumed to be unit length.
+    rotationTo(vectorA, vectorB) {
+      rotationTo(this, vectorA, vectorB);
+      return this.check();
+    }
+    // Sets the specified quaternion with values corresponding to the given axes.
+    // Each axis is a vec3 and is expected to be unit length and perpendicular
+    // to all other specified axes.
+    // setAxes() {
+    //   Number
+    // }
+    // Performs a spherical linear interpolation with two control points
+    // sqlerp() {
+    //   Number;
+    // }
+    // Adds two quat's
+    add(a) {
+      add4(this, this, a);
+      return this.check();
+    }
+    // Calculates the W component of a quat from the X, Y, and Z components.
+    // Any existing W component will be ignored.
+    calculateW() {
+      calculateW(this, this);
+      return this.check();
+    }
+    // Calculates the conjugate of a quat If the quaternion is normalized,
+    // this function is faster than quat_invert and produces the same result.
+    conjugate() {
+      conjugate(this, this);
+      return this.check();
+    }
+    // Calculates the inverse of a quat
+    invert() {
+      invert3(this, this);
+      return this.check();
+    }
+    // Performs a linear interpolation between two quat's
+    lerp(a, b, t) {
+      if (t === void 0) {
+        return this.lerp(this, a, b);
+      }
+      lerp3(this, a, b, t);
+      return this.check();
+    }
+    // Multiplies two quat's
+    multiplyRight(a) {
+      multiply4(this, this, a);
       return this.check();
     }
-    set(x, y, z, w) {
-      this[0] = x;
-      this[1] = y;
-      this[2] = z;
-      this[3] = w;
+    multiplyLeft(a) {
+      multiply4(this, a, this);
       return this.check();
     }
-    fromObject(object) {
-      this[0] = object.x;
-      this[1] = object.y;
-      this[2] = object.z;
-      this[3] = object.w;
+    // Normalize a quat
+    normalize() {
+      const length4 = this.len();
+      const l = length4 > 0 ? 1 / length4 : 0;
+      this[0] = this[0] * l;
+      this[1] = this[1] * l;
+      this[2] = this[2] * l;
+      this[3] = this[3] * l;
+      if (length4 === 0) {
+        this[3] = 1;
+      }
+      return this.check();
+    }
+    // Rotates a quaternion by the given angle about the X axis
+    rotateX(rad) {
+      rotateX3(this, this, rad);
+      return this.check();
+    }
+    // Rotates a quaternion by the given angle about the Y axis
+    rotateY(rad) {
+      rotateY3(this, this, rad);
+      return this.check();
+    }
+    // Rotates a quaternion by the given angle about the Z axis
+    rotateZ(rad) {
+      rotateZ3(this, this, rad);
+      return this.check();
+    }
+    // Scales a quat by a scalar number
+    scale(b) {
+      scale5(this, this, b);
+      return this.check();
+    }
+    // Performs a spherical linear interpolation between two quat
+    slerp(arg0, arg1, arg2) {
+      let start;
+      let target;
+      let ratio;
+      switch (arguments.length) {
+        case 1:
+          ({
+            start = IDENTITY_QUATERNION,
+            target,
+            ratio
+          } = arg0);
+          break;
+        case 2:
+          start = this;
+          target = arg0;
+          ratio = arg1;
+          break;
+        default:
+          start = arg0;
+          target = arg1;
+          ratio = arg2;
+      }
+      slerp2(this, start, target, ratio);
       return this.check();
     }
-    /**
-     * Creates a quaternion from the given 3x3 rotation matrix.
-     * NOTE: The resultant quaternion is not normalized, so you should
-     * be sure to renormalize the quaternion yourself where necessary.
-     * @param m
-     * @returns
-     */
-    fromMatrix3(m) {
-      fromMat3(this, m);
-      return this.check();
+    transformVector4(vector, result = new Vector4()) {
+      transformQuat2(result, vector, this);
+      return checkVector(result, 4);
+    }
+    // THREE.js Math API compatibility
+    lengthSq() {
+      return this.lengthSquared();
+    }
+    setFromAxisAngle(axis, rad) {
+      return this.setAxisAngle(axis, rad);
+    }
+    premultiply(a) {
+      return this.multiplyLeft(a);
+    }
+    multiply(a) {
+      return this.multiplyRight(a);
+    }
+  };
+
+  // ../../node_modules/@math.gl/core/dist/lib/math-utils.js
+  var math_utils_exports = {};
+  __export(math_utils_exports, {
+    EPSILON1: () => EPSILON1,
+    EPSILON10: () => EPSILON10,
+    EPSILON11: () => EPSILON11,
+    EPSILON12: () => EPSILON12,
+    EPSILON13: () => EPSILON13,
+    EPSILON14: () => EPSILON14,
+    EPSILON15: () => EPSILON15,
+    EPSILON16: () => EPSILON16,
+    EPSILON17: () => EPSILON17,
+    EPSILON18: () => EPSILON18,
+    EPSILON19: () => EPSILON19,
+    EPSILON2: () => EPSILON2,
+    EPSILON20: () => EPSILON20,
+    EPSILON3: () => EPSILON3,
+    EPSILON4: () => EPSILON4,
+    EPSILON5: () => EPSILON5,
+    EPSILON6: () => EPSILON6,
+    EPSILON7: () => EPSILON7,
+    EPSILON8: () => EPSILON8,
+    EPSILON9: () => EPSILON9,
+    PI_OVER_FOUR: () => PI_OVER_FOUR,
+    PI_OVER_SIX: () => PI_OVER_SIX,
+    PI_OVER_TWO: () => PI_OVER_TWO,
+    TWO_PI: () => TWO_PI
+  });
+  var EPSILON1 = 0.1;
+  var EPSILON2 = 0.01;
+  var EPSILON3 = 1e-3;
+  var EPSILON4 = 1e-4;
+  var EPSILON5 = 1e-5;
+  var EPSILON6 = 1e-6;
+  var EPSILON7 = 1e-7;
+  var EPSILON8 = 1e-8;
+  var EPSILON9 = 1e-9;
+  var EPSILON10 = 1e-10;
+  var EPSILON11 = 1e-11;
+  var EPSILON12 = 1e-12;
+  var EPSILON13 = 1e-13;
+  var EPSILON14 = 1e-14;
+  var EPSILON15 = 1e-15;
+  var EPSILON16 = 1e-16;
+  var EPSILON17 = 1e-17;
+  var EPSILON18 = 1e-18;
+  var EPSILON19 = 1e-19;
+  var EPSILON20 = 1e-20;
+  var PI_OVER_TWO = Math.PI / 2;
+  var PI_OVER_FOUR = Math.PI / 4;
+  var PI_OVER_SIX = Math.PI / 6;
+  var TWO_PI = Math.PI * 2;
+
+  // src/lib/parsers/constants.ts
+  function getConstructorForDataFormat(dataType) {
+    switch (dataType) {
+      case "UInt8":
+        return Uint8Array;
+      case "UInt16":
+        return Uint16Array;
+      case "UInt32":
+        return Uint32Array;
+      case "Float32":
+        return Float32Array;
+      case "UInt64":
+        return Float64Array;
+      default:
+        throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
+    }
+  }
+  var GL_TYPE_MAP = {
+    UInt8: GL.UNSIGNED_BYTE,
+    UInt16: GL.UNSIGNED_SHORT,
+    Float32: GL.FLOAT,
+    UInt32: GL.UNSIGNED_INT,
+    UInt64: GL.DOUBLE
+  };
+  function sizeOf(dataType) {
+    switch (dataType) {
+      case "UInt8":
+        return 1;
+      case "UInt16":
+      case "Int16":
+        return 2;
+      case "UInt32":
+      case "Int32":
+      case "Float32":
+        return 4;
+      case "UInt64":
+      case "Int64":
+      case "Float64":
+        return 8;
+      default:
+        throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
+    }
+  }
+  var STRING_ATTRIBUTE_TYPE = "String";
+  var OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
+  var FLOAT_64_TYPE = "Float64";
+  var INT_16_ATTRIBUTE_TYPE = "Int16";
+  var COORDINATE_SYSTEM = /* @__PURE__ */ ((COORDINATE_SYSTEM2) => {
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["DEFAULT"] = -1] = "DEFAULT";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT"] = 1] = "LNGLAT";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["METER_OFFSETS"] = 2] = "METER_OFFSETS";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
+    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["CARTESIAN"] = 0] = "CARTESIAN";
+    return COORDINATE_SYSTEM2;
+  })(COORDINATE_SYSTEM || {});
+
+  // src/i3s-loader.ts
+  var import_core18 = __toESM(require_core(), 1);
+
+  // src/lib/parsers/parse-i3s-tile-content.ts
+  var import_core5 = __toESM(require_core(), 1);
+
+  // ../../node_modules/@math.gl/geospatial/dist/constants.js
+  var WGS84_RADIUS_X = 6378137;
+  var WGS84_RADIUS_Y = 6378137;
+  var WGS84_RADIUS_Z = 6356752314245179e-9;
+  var WGS84_CONSTANTS = {
+    radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
+    radiiSquared: [
+      WGS84_RADIUS_X * WGS84_RADIUS_X,
+      WGS84_RADIUS_Y * WGS84_RADIUS_Y,
+      WGS84_RADIUS_Z * WGS84_RADIUS_Z
+    ],
+    oneOverRadii: [1 / WGS84_RADIUS_X, 1 / WGS84_RADIUS_Y, 1 / WGS84_RADIUS_Z],
+    oneOverRadiiSquared: [
+      1 / (WGS84_RADIUS_X * WGS84_RADIUS_X),
+      1 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),
+      1 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)
+    ],
+    maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
+    centerToleranceSquared: 0.1
+    // EPSILON1;
+  };
+
+  // ../../node_modules/@math.gl/geospatial/dist/type-utils.js
+  function identity3(x) {
+    return x;
+  }
+  var scratchVector = new Vector3();
+  function fromCartographic(cartographic, result = [], map2 = identity3) {
+    if ("longitude" in cartographic) {
+      result[0] = map2(cartographic.longitude);
+      result[1] = map2(cartographic.latitude);
+      result[2] = cartographic.height;
+    } else if ("x" in cartographic) {
+      result[0] = map2(cartographic.x);
+      result[1] = map2(cartographic.y);
+      result[2] = cartographic.z;
+    } else {
+      result[0] = map2(cartographic[0]);
+      result[1] = map2(cartographic[1]);
+      result[2] = cartographic[2];
+    }
+    return result;
+  }
+  function fromCartographicToRadians(cartographic, vector = []) {
+    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity3 : toRadians);
+  }
+  function toCartographic(vector, cartographic, map2 = identity3) {
+    if ("longitude" in cartographic) {
+      cartographic.longitude = map2(vector[0]);
+      cartographic.latitude = map2(vector[1]);
+      cartographic.height = vector[2];
+    } else if ("x" in cartographic) {
+      cartographic.x = map2(vector[0]);
+      cartographic.y = map2(vector[1]);
+      cartographic.z = vector[2];
+    } else {
+      cartographic[0] = map2(vector[0]);
+      cartographic[1] = map2(vector[1]);
+      cartographic[2] = vector[2];
     }
-    fromAxisRotation(axis, rad) {
-      setAxisAngle(this, axis, rad);
-      return this.check();
+    return cartographic;
+  }
+  function toCartographicFromRadians(vector, cartographic) {
+    return toCartographic(vector, cartographic, config._cartographicRadians ? identity3 : toDegrees);
+  }
+
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/helpers/ellipsoid-transform.js
+  var EPSILON142 = 1e-14;
+  var scratchOrigin = new Vector3();
+  var VECTOR_PRODUCT_LOCAL_FRAME = {
+    up: {
+      south: "east",
+      north: "west",
+      west: "south",
+      east: "north"
+    },
+    down: {
+      south: "west",
+      north: "east",
+      west: "north",
+      east: "south"
+    },
+    south: {
+      up: "west",
+      down: "east",
+      west: "down",
+      east: "up"
+    },
+    north: {
+      up: "east",
+      down: "west",
+      west: "up",
+      east: "down"
+    },
+    west: {
+      up: "north",
+      down: "south",
+      north: "down",
+      south: "up"
+    },
+    east: {
+      up: "south",
+      down: "north",
+      north: "up",
+      south: "down"
     }
-    /** Set a quat to the identity quaternion */
-    identity() {
-      identity2(this);
-      return this.check();
+  };
+  var degeneratePositionLocalFrame = {
+    north: [-1, 0, 0],
+    east: [0, 1, 0],
+    up: [0, 0, 1],
+    south: [1, 0, 0],
+    west: [0, -1, 0],
+    down: [0, 0, -1]
+  };
+  var scratchAxisVectors = {
+    east: new Vector3(),
+    north: new Vector3(),
+    up: new Vector3(),
+    west: new Vector3(),
+    south: new Vector3(),
+    down: new Vector3()
+  };
+  var scratchVector1 = new Vector3();
+  var scratchVector2 = new Vector3();
+  var scratchVector3 = new Vector3();
+  function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
+    const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
+    assert(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
+    let firstAxisVector;
+    let secondAxisVector;
+    let thirdAxisVector;
+    const origin = scratchOrigin.copy(cartesianOrigin);
+    const atPole = equals(origin.x, 0, EPSILON142) && equals(origin.y, 0, EPSILON142);
+    if (atPole) {
+      const sign = Math.sign(origin.z);
+      firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
+      if (firstAxis !== "east" && firstAxis !== "west") {
+        firstAxisVector.scale(sign);
+      }
+      secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);
+      if (secondAxis !== "east" && secondAxis !== "west") {
+        secondAxisVector.scale(sign);
+      }
+      thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);
+      if (thirdAxis !== "east" && thirdAxis !== "west") {
+        thirdAxisVector.scale(sign);
+      }
+    } else {
+      const { up, east, north } = scratchAxisVectors;
+      east.set(-origin.y, origin.x, 0).normalize();
+      ellipsoid.geodeticSurfaceNormal(origin, up);
+      north.copy(up).cross(east);
+      const { down, west, south } = scratchAxisVectors;
+      down.copy(up).scale(-1);
+      west.copy(east).scale(-1);
+      south.copy(north).scale(-1);
+      firstAxisVector = scratchAxisVectors[firstAxis];
+      secondAxisVector = scratchAxisVectors[secondAxis];
+      thirdAxisVector = scratchAxisVectors[thirdAxis];
     }
-    // Set the components of a quat to the given values
-    // set(i, j, k, l) {
-    //   quat_set(this, i, j, k, l);
-    //   return this.check();
-    // }
-    // Sets a quat from the given angle and rotation axis, then returns it.
-    setAxisAngle(axis, rad) {
-      return this.fromAxisRotation(axis, rad);
+    result[0] = firstAxisVector.x;
+    result[1] = firstAxisVector.y;
+    result[2] = firstAxisVector.z;
+    result[3] = 0;
+    result[4] = secondAxisVector.x;
+    result[5] = secondAxisVector.y;
+    result[6] = secondAxisVector.z;
+    result[7] = 0;
+    result[8] = thirdAxisVector.x;
+    result[9] = thirdAxisVector.y;
+    result[10] = thirdAxisVector.z;
+    result[11] = 0;
+    result[12] = origin.x;
+    result[13] = origin.y;
+    result[14] = origin.z;
+    result[15] = 1;
+    return result;
+  }
+
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/helpers/scale-to-geodetic-surface.js
+  var scratchVector4 = new Vector3();
+  var scaleToGeodeticSurfaceIntersection = new Vector3();
+  var scaleToGeodeticSurfaceGradient = new Vector3();
+  function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
+    const { oneOverRadii, oneOverRadiiSquared, centerToleranceSquared } = ellipsoid;
+    scratchVector4.from(cartesian);
+    const positionX = scratchVector4.x;
+    const positionY = scratchVector4.y;
+    const positionZ = scratchVector4.z;
+    const oneOverRadiiX = oneOverRadii.x;
+    const oneOverRadiiY = oneOverRadii.y;
+    const oneOverRadiiZ = oneOverRadii.z;
+    const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
+    const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
+    const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
+    const squaredNorm = x2 + y2 + z2;
+    const ratio = Math.sqrt(1 / squaredNorm);
+    if (!Number.isFinite(ratio)) {
+      return void 0;
     }
-    // Getters/setters
-    get ELEMENTS() {
-      return 4;
+    const intersection = scaleToGeodeticSurfaceIntersection;
+    intersection.copy(cartesian).scale(ratio);
+    if (squaredNorm < centerToleranceSquared) {
+      return intersection.to(result);
     }
-    get x() {
-      return this[0];
+    const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
+    const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
+    const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
+    const gradient = scaleToGeodeticSurfaceGradient;
+    gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
+    let lambda = (1 - ratio) * scratchVector4.len() / (0.5 * gradient.len());
+    let correction = 0;
+    let xMultiplier;
+    let yMultiplier;
+    let zMultiplier;
+    let func;
+    do {
+      lambda -= correction;
+      xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
+      yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
+      zMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredZ);
+      const xMultiplier2 = xMultiplier * xMultiplier;
+      const yMultiplier2 = yMultiplier * yMultiplier;
+      const zMultiplier2 = zMultiplier * zMultiplier;
+      const xMultiplier3 = xMultiplier2 * xMultiplier;
+      const yMultiplier3 = yMultiplier2 * yMultiplier;
+      const zMultiplier3 = zMultiplier2 * zMultiplier;
+      func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
+      const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
+      const derivative = -2 * denominator;
+      correction = func / derivative;
+    } while (Math.abs(func) > math_utils_exports.EPSILON12);
+    return scratchVector4.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
+  }
+
+  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/ellipsoid.js
+  var scratchVector5 = new Vector3();
+  var scratchNormal = new Vector3();
+  var scratchK = new Vector3();
+  var scratchPosition = new Vector3();
+  var scratchHeight = new Vector3();
+  var scratchCartesian = new Vector3();
+  var Ellipsoid = class {
+    constructor(x = 0, y = 0, z = 0) {
+      this.centerToleranceSquared = math_utils_exports.EPSILON1;
+      assert(x >= 0);
+      assert(y >= 0);
+      assert(z >= 0);
+      this.radii = new Vector3(x, y, z);
+      this.radiiSquared = new Vector3(x * x, y * y, z * z);
+      this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
+      this.oneOverRadii = new Vector3(x === 0 ? 0 : 1 / x, y === 0 ? 0 : 1 / y, z === 0 ? 0 : 1 / z);
+      this.oneOverRadiiSquared = new Vector3(x === 0 ? 0 : 1 / (x * x), y === 0 ? 0 : 1 / (y * y), z === 0 ? 0 : 1 / (z * z));
+      this.minimumRadius = Math.min(x, y, z);
+      this.maximumRadius = Math.max(x, y, z);
+      if (this.radiiSquared.z !== 0) {
+        this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
+      }
+      Object.freeze(this);
     }
-    set x(value) {
-      this[0] = checkNumber(value);
+    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
+    equals(right) {
+      return this === right || Boolean(right && this.radii.equals(right.radii));
     }
-    get y() {
-      return this[1];
+    /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
+    toString() {
+      return this.radii.toString();
     }
-    set y(value) {
-      this[1] = checkNumber(value);
+    cartographicToCartesian(cartographic, result = [0, 0, 0]) {
+      const normal = scratchNormal;
+      const k = scratchK;
+      const [, , height] = cartographic;
+      this.geodeticSurfaceNormalCartographic(cartographic, normal);
+      k.copy(this.radiiSquared).scale(normal);
+      const gamma = Math.sqrt(normal.dot(k));
+      k.scale(1 / gamma);
+      normal.scale(height);
+      k.add(normal);
+      return k.to(result);
     }
-    get z() {
-      return this[2];
+    cartesianToCartographic(cartesian, result = [0, 0, 0]) {
+      scratchCartesian.from(cartesian);
+      const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
+      if (!point) {
+        return void 0;
+      }
+      const normal = this.geodeticSurfaceNormal(point, scratchNormal);
+      const h = scratchHeight;
+      h.copy(scratchCartesian).subtract(point);
+      const longitude = Math.atan2(normal.y, normal.x);
+      const latitude = Math.asin(normal.z);
+      const height = Math.sign(vec3_exports.dot(h, scratchCartesian)) * vec3_exports.length(h);
+      return toCartographicFromRadians([longitude, latitude, height], result);
     }
-    set z(value) {
-      this[2] = checkNumber(value);
+    eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
+      return localFrameToFixedFrame(this, "east", "north", "up", origin, result);
     }
-    get w() {
-      return this[3];
+    // Computes a 4x4 transformation matrix from a reference frame centered at
+    // the provided origin to the ellipsoid's fixed reference frame.
+    localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {
+      return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
     }
-    set w(value) {
-      this[3] = checkNumber(value);
+    geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
+      return scratchVector5.from(cartesian).normalize().to(result);
     }
-    // Calculates the length of a quat
-    len() {
-      return length3(this);
+    geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
+      const cartographicVectorRadians = fromCartographicToRadians(cartographic);
+      const longitude = cartographicVectorRadians[0];
+      const latitude = cartographicVectorRadians[1];
+      const cosLatitude = Math.cos(latitude);
+      scratchVector5.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
+      return scratchVector5.to(result);
     }
-    // Calculates the squared length of a quat
-    lengthSquared() {
-      return squaredLength3(this);
+    geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
+      return scratchVector5.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
     }
-    // Calculates the dot product of two quat's
-    // @return {Number}
-    dot(a) {
-      return dot3(this, a);
+    /** Scales the provided Cartesian position along the geodetic surface normal
+     * so that it is on the surface of this ellipsoid.  If the position is
+     * at the center of the ellipsoid, this function returns undefined. */
+    scaleToGeodeticSurface(cartesian, result) {
+      return scaleToGeodeticSurface(cartesian, this, result);
     }
-    // Gets the rotation axis and angle for a given quaternion.
-    // If a quaternion is created with setAxisAngle, this method will
-    // return the same values as providied in the original parameter
-    // list OR functionally equivalent values.
-    // Example: The quaternion formed by axis [0, 0, 1] and angle -90
-    // is the same as the quaternion formed by [0, 0, 1] and 270.
-    // This method favors the latter.
-    // @return {{[x,y,z], Number}}
-    // getAxisAngle() {
-    //   const axis = [];
-    // //   const angle = quat_getAxisAngle(axis, this);
-    //   return {axis, angle};
-    // }
-    // MODIFIERS
-    // Sets a quaternion to represent the shortest rotation from one vector
-    // to another. Both vectors are assumed to be unit length.
-    rotationTo(vectorA, vectorB) {
-      rotationTo(this, vectorA, vectorB);
-      return this.check();
+    /** Scales the provided Cartesian position along the geocentric surface normal
+     * so that it is on the surface of this ellipsoid. */
+    scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {
+      scratchPosition.from(cartesian);
+      const positionX = scratchPosition.x;
+      const positionY = scratchPosition.y;
+      const positionZ = scratchPosition.z;
+      const oneOverRadiiSquared = this.oneOverRadiiSquared;
+      const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
+      return scratchPosition.multiplyScalar(beta).to(result);
     }
-    // Sets the specified quaternion with values corresponding to the given axes.
-    // Each axis is a vec3 and is expected to be unit length and perpendicular
-    // to all other specified axes.
-    // setAxes() {
-    //   Number
-    // }
-    // Performs a spherical linear interpolation with two control points
-    // sqlerp() {
-    //   Number;
-    // }
-    // Adds two quat's
-    add(a) {
-      add4(this, this, a);
-      return this.check();
+    /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#oneOverRadii` */
+    transformPositionToScaledSpace(position, result = [0, 0, 0]) {
+      return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
     }
-    // Calculates the W component of a quat from the X, Y, and Z components.
-    // Any existing W component will be ignored.
-    calculateW() {
-      calculateW(this, this);
-      return this.check();
+    /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
+     * its components by the result of `Ellipsoid#radii`. */
+    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
+      return scratchPosition.from(position).scale(this.radii).to(result);
     }
-    // Calculates the conjugate of a quat If the quaternion is normalized,
-    // this function is faster than quat_invert and produces the same result.
-    conjugate() {
-      conjugate(this, this);
-      return this.check();
+    /** Computes a point which is the intersection of the surface normal with the z-axis. */
+    getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
+      assert(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
+      assert(this.radii.z > 0);
+      scratchPosition.from(position);
+      const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
+      if (Math.abs(z) >= this.radii.z - buffer) {
+        return void 0;
+      }
+      return scratchPosition.set(0, 0, z).to(result);
     }
-    // Calculates the inverse of a quat
-    invert() {
-      invert3(this, this);
-      return this.check();
+  };
+  Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
+
+  // ../loader-utils/src/loader-types.ts
+  async function parseFromContext(data, loaders, options, context) {
+    return context._parse(data, loaders, options, context);
+  }
+
+  // ../loader-utils/src/lib/env-utils/assert.ts
+  function assert2(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loader assertion failed.");
     }
-    // Performs a linear interpolation between two quat's
-    lerp(a, b, t) {
-      if (t === void 0) {
-        return this.lerp(this, a, b);
+  }
+
+  // ../loader-utils/src/lib/env-utils/globals.ts
+  var globals = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_ = globals.self || globals.window || globals.global || {};
+  var window_ = globals.window || globals.self || globals.global || {};
+  var global_ = globals.global || globals.self || globals.window || {};
+  var document_ = globals.document || {};
+  var isBrowser = (
+    // @ts-ignore process does not exist on browser
+    Boolean(typeof process !== "object" || String(process) !== "[object process]" || process.browser)
+  );
+  var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion = matches && parseFloat(matches[1]) || 0;
+
+  // ../loader-utils/src/lib/module-utils/js-module-utils.ts
+  function registerJSModules(modules) {
+    globalThis.loaders ||= {};
+    globalThis.loaders.modules ||= {};
+    Object.assign(globalThis.loaders.modules, modules);
+  }
+  function getJSModuleOrNull(name) {
+    const module = globalThis.loaders?.modules?.[name];
+    return module || null;
+  }
+
+  // ../worker-utils/src/lib/npm-tag.ts
+  var NPM_TAG = "beta";
+
+  // ../worker-utils/src/lib/env-utils/version.ts
+  function getVersion() {
+    if (!globalThis._loadersgl_?.version) {
+      globalThis._loadersgl_ = globalThis._loadersgl_ || {};
+      if (typeof __VERSION__ === "undefined") {
+        console.warn(
+          "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
+        );
+        globalThis._loadersgl_.version = NPM_TAG;
+      } else {
+        globalThis._loadersgl_.version = __VERSION__;
       }
-      lerp3(this, a, b, t);
-      return this.check();
     }
-    // Multiplies two quat's
-    multiplyRight(a) {
-      multiply4(this, this, a);
-      return this.check();
+    return globalThis._loadersgl_.version;
+  }
+  var VERSION = getVersion();
+
+  // ../worker-utils/src/lib/env-utils/assert.ts
+  function assert3(condition, message) {
+    if (!condition) {
+      throw new Error(message || "loaders.gl assertion failed.");
+    }
+  }
+
+  // ../worker-utils/src/lib/env-utils/globals.ts
+  var globals2 = {
+    self: typeof self !== "undefined" && self,
+    window: typeof window !== "undefined" && window,
+    global: typeof global !== "undefined" && global,
+    document: typeof document !== "undefined" && document
+  };
+  var self_2 = globals2.self || globals2.window || globals2.global || {};
+  var window_2 = globals2.window || globals2.self || globals2.global || {};
+  var global_2 = globals2.global || globals2.self || globals2.window || {};
+  var document_2 = globals2.document || {};
+  var isBrowser2 = (
+    // @ts-ignore process.browser
+    typeof process !== "object" || String(process) !== "[object process]" || process.browser
+  );
+  var isWorker = typeof importScripts === "function";
+  var isMobile = typeof window !== "undefined" && typeof window.orientation !== "undefined";
+  var matches2 = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
+  var nodeVersion2 = matches2 && parseFloat(matches2[1]) || 0;
+
+  // ../worker-utils/src/lib/library-utils/library-utils.ts
+  var loadLibraryPromises = {};
+  async function loadLibrary(libraryUrl, moduleName = null, options = {}, libraryName = null) {
+    if (moduleName) {
+      libraryUrl = getLibraryUrl(libraryUrl, moduleName, options, libraryName);
     }
-    multiplyLeft(a) {
-      multiply4(this, a, this);
-      return this.check();
+    loadLibraryPromises[libraryUrl] = // eslint-disable-next-line @typescript-eslint/no-misused-promises
+    loadLibraryPromises[libraryUrl] || loadLibraryFromFile(libraryUrl);
+    return await loadLibraryPromises[libraryUrl];
+  }
+  function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (!options.useLocalLibraries && library.startsWith("http")) {
+      return library;
     }
-    // Normalize a quat
-    normalize() {
-      const length4 = this.len();
-      const l = length4 > 0 ? 1 / length4 : 0;
-      this[0] = this[0] * l;
-      this[1] = this[1] * l;
-      this[2] = this[2] * l;
-      this[3] = this[3] * l;
-      if (length4 === 0) {
-        this[3] = 1;
-      }
-      return this.check();
+    libraryName = libraryName || library;
+    const modules = options.modules || {};
+    if (modules[libraryName]) {
+      return modules[libraryName];
     }
-    // Rotates a quaternion by the given angle about the X axis
-    rotateX(rad) {
-      rotateX3(this, this, rad);
-      return this.check();
+    if (!isBrowser2) {
+      return `modules/${moduleName}/dist/libs/${libraryName}`;
     }
-    // Rotates a quaternion by the given angle about the Y axis
-    rotateY(rad) {
-      rotateY3(this, this, rad);
-      return this.check();
+    if (options.CDN) {
+      assert3(options.CDN.startsWith("http"));
+      return `${options.CDN}/${moduleName}@${VERSION}/dist/libs/${libraryName}`;
     }
-    // Rotates a quaternion by the given angle about the Z axis
-    rotateZ(rad) {
-      rotateZ3(this, this, rad);
-      return this.check();
+    if (isWorker) {
+      return `../src/libs/${libraryName}`;
     }
-    // Scales a quat by a scalar number
-    scale(b) {
-      scale5(this, this, b);
-      return this.check();
+    return `modules/${moduleName}/src/libs/${libraryName}`;
+  }
+  async function loadLibraryFromFile(libraryUrl) {
+    if (libraryUrl.endsWith("wasm")) {
+      return await loadAsArrayBuffer(libraryUrl);
     }
-    // Performs a spherical linear interpolation between two quat
-    slerp(arg0, arg1, arg2) {
-      let start;
-      let target;
-      let ratio;
-      switch (arguments.length) {
-        case 1:
-          ({
-            start = IDENTITY_QUATERNION,
-            target,
-            ratio
-          } = arg0);
-          break;
-        case 2:
-          start = this;
-          target = arg0;
-          ratio = arg1;
-          break;
-        default:
-          start = arg0;
-          target = arg1;
-          ratio = arg2;
+    if (!isBrowser2) {
+      try {
+        const { requireFromFile } = globalThis.loaders || {};
+        return await requireFromFile?.(libraryUrl);
+      } catch (error) {
+        console.error(error);
+        return null;
       }
-      slerp2(this, start, target, ratio);
-      return this.check();
     }
-    transformVector4(vector, result = new Vector4()) {
-      transformQuat2(result, vector, this);
-      return checkVector(result, 4);
+    if (isWorker) {
+      return importScripts(libraryUrl);
     }
-    // THREE.js Math API compatibility
-    lengthSq() {
-      return this.lengthSquared();
+    const scriptSource = await loadAsText(libraryUrl);
+    return loadLibraryFromString(scriptSource, libraryUrl);
+  }
+  function loadLibraryFromString(scriptSource, id) {
+    if (!isBrowser2) {
+      const { requireFromString } = globalThis.loaders || {};
+      return requireFromString?.(scriptSource, id);
     }
-    setFromAxisAngle(axis, rad) {
-      return this.setAxisAngle(axis, rad);
+    if (isWorker) {
+      eval.call(globalThis, scriptSource);
+      return null;
     }
-    premultiply(a) {
-      return this.multiplyLeft(a);
+    const script = document.createElement("script");
+    script.id = id;
+    try {
+      script.appendChild(document.createTextNode(scriptSource));
+    } catch (e) {
+      script.text = scriptSource;
     }
-    multiply(a) {
-      return this.multiplyRight(a);
+    document.body.appendChild(script);
+    return null;
+  }
+  async function loadAsArrayBuffer(url) {
+    const { readFileAsArrayBuffer } = globalThis.loaders || {};
+    if (isBrowser2 || !readFileAsArrayBuffer || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.arrayBuffer();
     }
-  };
-
-  // ../../node_modules/@math.gl/core/dist/lib/math-utils.js
-  var math_utils_exports = {};
-  __export(math_utils_exports, {
-    EPSILON1: () => EPSILON1,
-    EPSILON10: () => EPSILON10,
-    EPSILON11: () => EPSILON11,
-    EPSILON12: () => EPSILON12,
-    EPSILON13: () => EPSILON13,
-    EPSILON14: () => EPSILON14,
-    EPSILON15: () => EPSILON15,
-    EPSILON16: () => EPSILON16,
-    EPSILON17: () => EPSILON17,
-    EPSILON18: () => EPSILON18,
-    EPSILON19: () => EPSILON19,
-    EPSILON2: () => EPSILON2,
-    EPSILON20: () => EPSILON20,
-    EPSILON3: () => EPSILON3,
-    EPSILON4: () => EPSILON4,
-    EPSILON5: () => EPSILON5,
-    EPSILON6: () => EPSILON6,
-    EPSILON7: () => EPSILON7,
-    EPSILON8: () => EPSILON8,
-    EPSILON9: () => EPSILON9,
-    PI_OVER_FOUR: () => PI_OVER_FOUR,
-    PI_OVER_SIX: () => PI_OVER_SIX,
-    PI_OVER_TWO: () => PI_OVER_TWO,
-    TWO_PI: () => TWO_PI
-  });
-  var EPSILON1 = 0.1;
-  var EPSILON2 = 0.01;
-  var EPSILON3 = 1e-3;
-  var EPSILON4 = 1e-4;
-  var EPSILON5 = 1e-5;
-  var EPSILON6 = 1e-6;
-  var EPSILON7 = 1e-7;
-  var EPSILON8 = 1e-8;
-  var EPSILON9 = 1e-9;
-  var EPSILON10 = 1e-10;
-  var EPSILON11 = 1e-11;
-  var EPSILON12 = 1e-12;
-  var EPSILON13 = 1e-13;
-  var EPSILON14 = 1e-14;
-  var EPSILON15 = 1e-15;
-  var EPSILON16 = 1e-16;
-  var EPSILON17 = 1e-17;
-  var EPSILON18 = 1e-18;
-  var EPSILON19 = 1e-19;
-  var EPSILON20 = 1e-20;
-  var PI_OVER_TWO = Math.PI / 2;
-  var PI_OVER_FOUR = Math.PI / 4;
-  var PI_OVER_SIX = Math.PI / 6;
-  var TWO_PI = Math.PI * 2;
-
-  // src/lib/parsers/constants.ts
-  function getConstructorForDataFormat(dataType) {
-    switch (dataType) {
-      case "UInt8":
-        return Uint8Array;
-      case "UInt16":
-        return Uint16Array;
-      case "UInt32":
-        return Uint32Array;
-      case "Float32":
-        return Float32Array;
-      case "UInt64":
-        return Float64Array;
-      default:
-        throw new Error(`parse i3s tile content: unknown type of data: ${dataType}`);
+    return await readFileAsArrayBuffer(url);
+  }
+  async function loadAsText(url) {
+    const { readFileAsText } = globalThis.loaders || {};
+    if (isBrowser2 || !readFileAsText || url.startsWith("http")) {
+      const response = await fetch(url);
+      return await response.text();
     }
+    return await readFileAsText(url);
   }
-  var GL_TYPE_MAP = {
-    UInt8: GL.UNSIGNED_BYTE,
-    UInt16: GL.UNSIGNED_SHORT,
-    Float32: GL.FLOAT,
-    UInt32: GL.UNSIGNED_INT,
-    UInt64: GL.DOUBLE
-  };
-  function sizeOf(dataType) {
-    switch (dataType) {
-      case "UInt8":
-        return 1;
-      case "UInt16":
-      case "Int16":
-        return 2;
-      case "UInt32":
-      case "Int32":
-      case "Float32":
-        return 4;
-      case "UInt64":
-      case "Int64":
-      case "Float64":
-        return 8;
-      default:
-        throw new Error(`parse i3s tile content: unknown size of data: ${dataType}`);
+
+  // ../loader-utils/src/lib/binary-utils/array-buffer-utils.ts
+  function compareArrayBuffers(arrayBuffer1, arrayBuffer2, byteLength) {
+    byteLength = byteLength || arrayBuffer1.byteLength;
+    if (arrayBuffer1.byteLength < byteLength || arrayBuffer2.byteLength < byteLength) {
+      return false;
+    }
+    const array1 = new Uint8Array(arrayBuffer1);
+    const array2 = new Uint8Array(arrayBuffer2);
+    for (let i = 0; i < array1.length; ++i) {
+      if (array1[i] !== array2[i]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function concatenateArrayBuffers(...sources) {
+    return concatenateArrayBuffersFromArray(sources);
+  }
+  function concatenateArrayBuffersFromArray(sources) {
+    const sourceArrays = sources.map(
+      (source2) => source2 instanceof ArrayBuffer ? new Uint8Array(source2) : source2
+    );
+    const byteLength = sourceArrays.reduce((length4, typedArray) => length4 + typedArray.byteLength, 0);
+    const result = new Uint8Array(byteLength);
+    let offset = 0;
+    for (const sourceArray of sourceArrays) {
+      result.set(sourceArray, offset);
+      offset += sourceArray.byteLength;
     }
+    return result.buffer;
   }
-  var STRING_ATTRIBUTE_TYPE = "String";
-  var OBJECT_ID_ATTRIBUTE_TYPE = "Oid32";
-  var FLOAT_64_TYPE = "Float64";
-  var INT_16_ATTRIBUTE_TYPE = "Int16";
-  var COORDINATE_SYSTEM = /* @__PURE__ */ ((COORDINATE_SYSTEM2) => {
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["DEFAULT"] = -1] = "DEFAULT";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT"] = 1] = "LNGLAT";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["METER_OFFSETS"] = 2] = "METER_OFFSETS";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["LNGLAT_OFFSETS"] = 3] = "LNGLAT_OFFSETS";
-    COORDINATE_SYSTEM2[COORDINATE_SYSTEM2["CARTESIAN"] = 0] = "CARTESIAN";
-    return COORDINATE_SYSTEM2;
-  })(COORDINATE_SYSTEM || {});
-
-  // src/i3s-loader.ts
-  var import_core18 = __toESM(require_core(), 1);
 
-  // src/lib/parsers/parse-i3s-tile-content.ts
-  var import_core5 = __toESM(require_core(), 1);
+  // ../loader-utils/src/lib/iterators/async-iteration.ts
+  async function concatenateArrayBuffersAsync(asyncIterator) {
+    const arrayBuffers = [];
+    for await (const chunk of asyncIterator) {
+      arrayBuffers.push(chunk);
+    }
+    return concatenateArrayBuffers(...arrayBuffers);
+  }
 
-  // ../../node_modules/@math.gl/geospatial/dist/constants.js
-  var WGS84_RADIUS_X = 6378137;
-  var WGS84_RADIUS_Y = 6378137;
-  var WGS84_RADIUS_Z = 6356752314245179e-9;
-  var WGS84_CONSTANTS = {
-    radii: [WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z],
-    radiiSquared: [
-      WGS84_RADIUS_X * WGS84_RADIUS_X,
-      WGS84_RADIUS_Y * WGS84_RADIUS_Y,
-      WGS84_RADIUS_Z * WGS84_RADIUS_Z
-    ],
-    oneOverRadii: [1 / WGS84_RADIUS_X, 1 / WGS84_RADIUS_Y, 1 / WGS84_RADIUS_Z],
-    oneOverRadiiSquared: [
-      1 / (WGS84_RADIUS_X * WGS84_RADIUS_X),
-      1 / (WGS84_RADIUS_Y * WGS84_RADIUS_Y),
-      1 / (WGS84_RADIUS_Z * WGS84_RADIUS_Z)
-    ],
-    maximumRadius: Math.max(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z),
-    centerToleranceSquared: 0.1
-    // EPSILON1;
-  };
+  // ../loader-utils/src/lib/node/buffer.browser.ts
+  function toArrayBuffer(buffer) {
+    return buffer;
+  }
 
-  // ../../node_modules/@math.gl/geospatial/dist/type-utils.js
-  function identity3(x) {
-    return x;
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function isBuffer(value) {
+    return value && typeof value === "object" && value.isBuffer;
   }
-  var scratchVector = new Vector3();
-  function fromCartographic(cartographic, result = [], map2 = identity3) {
-    if ("longitude" in cartographic) {
-      result[0] = map2(cartographic.longitude);
-      result[1] = map2(cartographic.latitude);
-      result[2] = cartographic.height;
-    } else if ("x" in cartographic) {
-      result[0] = map2(cartographic.x);
-      result[1] = map2(cartographic.y);
-      result[2] = cartographic.z;
-    } else {
-      result[0] = map2(cartographic[0]);
-      result[1] = map2(cartographic[1]);
-      result[2] = cartographic[2];
+  function toArrayBuffer2(data) {
+    if (isBuffer(data)) {
+      return toArrayBuffer(data);
     }
-    return result;
-  }
-  function fromCartographicToRadians(cartographic, vector = []) {
-    return fromCartographic(cartographic, vector, config._cartographicRadians ? identity3 : toRadians);
-  }
-  function toCartographic(vector, cartographic, map2 = identity3) {
-    if ("longitude" in cartographic) {
-      cartographic.longitude = map2(vector[0]);
-      cartographic.latitude = map2(vector[1]);
-      cartographic.height = vector[2];
-    } else if ("x" in cartographic) {
-      cartographic.x = map2(vector[0]);
-      cartographic.y = map2(vector[1]);
-      cartographic.z = vector[2];
-    } else {
-      cartographic[0] = map2(vector[0]);
-      cartographic[1] = map2(vector[1]);
-      cartographic[2] = vector[2];
+    if (data instanceof ArrayBuffer) {
+      return data;
     }
-    return cartographic;
+    if (ArrayBuffer.isView(data)) {
+      if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+        return data.buffer;
+      }
+      return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
+    }
+    if (typeof data === "string") {
+      const text = data;
+      const uint8Array = new TextEncoder().encode(text);
+      return uint8Array.buffer;
+    }
+    if (data && typeof data === "object" && data._toArrayBuffer) {
+      return data._toArrayBuffer();
+    }
+    throw new Error("toArrayBuffer");
   }
-  function toCartographicFromRadians(vector, cartographic) {
-    return toCartographic(vector, cartographic, config._cartographicRadians ? identity3 : toDegrees);
+
+  // ../loader-utils/src/lib/node/promisify.ts
+  function promisify1(fn) {
+    return (args) => new Promise(
+      (resolve, reject) => fn(args, (error, callbackArgs) => error ? reject(error) : resolve(callbackArgs))
+    );
   }
 
-  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/helpers/ellipsoid-transform.js
-  var EPSILON142 = 1e-14;
-  var scratchOrigin = new Vector3();
-  var VECTOR_PRODUCT_LOCAL_FRAME = {
-    up: {
-      south: "east",
-      north: "west",
-      west: "south",
-      east: "north"
-    },
-    down: {
-      south: "west",
-      north: "east",
-      west: "north",
-      east: "south"
-    },
-    south: {
-      up: "west",
-      down: "east",
-      west: "down",
-      east: "up"
-    },
-    north: {
-      up: "east",
-      down: "west",
-      west: "up",
-      east: "down"
-    },
-    west: {
-      up: "north",
-      down: "south",
-      north: "down",
-      south: "up"
-    },
-    east: {
-      up: "south",
-      down: "north",
-      north: "up",
-      south: "down"
-    }
-  };
-  var degeneratePositionLocalFrame = {
-    north: [-1, 0, 0],
-    east: [0, 1, 0],
-    up: [0, 0, 1],
-    south: [1, 0, 0],
-    west: [0, -1, 0],
-    down: [0, 0, -1]
-  };
-  var scratchAxisVectors = {
-    east: new Vector3(),
-    north: new Vector3(),
-    up: new Vector3(),
-    west: new Vector3(),
-    south: new Vector3(),
-    down: new Vector3()
-  };
-  var scratchVector1 = new Vector3();
-  var scratchVector2 = new Vector3();
-  var scratchVector3 = new Vector3();
-  function localFrameToFixedFrame(ellipsoid, firstAxis, secondAxis, thirdAxis, cartesianOrigin, result) {
-    const thirdAxisInferred = VECTOR_PRODUCT_LOCAL_FRAME[firstAxis] && VECTOR_PRODUCT_LOCAL_FRAME[firstAxis][secondAxis];
-    assert3(thirdAxisInferred && (!thirdAxis || thirdAxis === thirdAxisInferred));
-    let firstAxisVector;
-    let secondAxisVector;
-    let thirdAxisVector;
-    const origin = scratchOrigin.copy(cartesianOrigin);
-    const atPole = equals(origin.x, 0, EPSILON142) && equals(origin.y, 0, EPSILON142);
-    if (atPole) {
-      const sign = Math.sign(origin.z);
-      firstAxisVector = scratchVector1.fromArray(degeneratePositionLocalFrame[firstAxis]);
-      if (firstAxis !== "east" && firstAxis !== "west") {
-        firstAxisVector.scale(sign);
-      }
-      secondAxisVector = scratchVector2.fromArray(degeneratePositionLocalFrame[secondAxis]);
-      if (secondAxis !== "east" && secondAxis !== "west") {
-        secondAxisVector.scale(sign);
+  // ../loader-utils/src/lib/files/node-file-facade.ts
+  var NOT_IMPLEMENTED = new Error("Not implemented");
+  var NodeFileFacade = class {
+    handle;
+    size = 0;
+    bigsize = 0n;
+    url = "";
+    constructor(url, flags, mode) {
+      if (globalThis.loaders?.NodeFile) {
+        return new globalThis.loaders.NodeFile(url, flags, mode);
       }
-      thirdAxisVector = scratchVector3.fromArray(degeneratePositionLocalFrame[thirdAxis]);
-      if (thirdAxis !== "east" && thirdAxis !== "west") {
-        thirdAxisVector.scale(sign);
+      if (isBrowser) {
+        throw new Error("Can't instantiate NodeFile in browser.");
       }
-    } else {
-      const { up, east, north } = scratchAxisVectors;
-      east.set(-origin.y, origin.x, 0).normalize();
-      ellipsoid.geodeticSurfaceNormal(origin, up);
-      north.copy(up).cross(east);
-      const { down, west, south } = scratchAxisVectors;
-      down.copy(up).scale(-1);
-      west.copy(east).scale(-1);
-      south.copy(north).scale(-1);
-      firstAxisVector = scratchAxisVectors[firstAxis];
-      secondAxisVector = scratchAxisVectors[secondAxis];
-      thirdAxisVector = scratchAxisVectors[thirdAxis];
+      throw new Error("Can't instantiate NodeFile. Make sure to import @loaders.gl/polyfills first.");
+    }
+    /** Read data */
+    async read(start, length4) {
+      throw NOT_IMPLEMENTED;
+    }
+    /** Write to file. The number of bytes written will be returned */
+    async write(arrayBuffer, offset, length4) {
+      throw NOT_IMPLEMENTED;
+    }
+    /** Get information about file */
+    async stat() {
+      throw NOT_IMPLEMENTED;
+    }
+    /** Truncates the file descriptor. Only available on NodeFile. */
+    async truncate(length4) {
+      throw NOT_IMPLEMENTED;
+    }
+    /** Append data to a file. Only available on NodeFile. */
+    async append(data) {
+      throw NOT_IMPLEMENTED;
+    }
+    /** Close the file */
+    async close() {
     }
-    result[0] = firstAxisVector.x;
-    result[1] = firstAxisVector.y;
-    result[2] = firstAxisVector.z;
-    result[3] = 0;
-    result[4] = secondAxisVector.x;
-    result[5] = secondAxisVector.y;
-    result[6] = secondAxisVector.z;
-    result[7] = 0;
-    result[8] = thirdAxisVector.x;
-    result[9] = thirdAxisVector.y;
-    result[10] = thirdAxisVector.z;
-    result[11] = 0;
-    result[12] = origin.x;
-    result[13] = origin.y;
-    result[14] = origin.z;
-    result[15] = 1;
-    return result;
-  }
+  };
 
-  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/helpers/scale-to-geodetic-surface.js
-  var scratchVector4 = new Vector3();
-  var scaleToGeodeticSurfaceIntersection = new Vector3();
-  var scaleToGeodeticSurfaceGradient = new Vector3();
-  function scaleToGeodeticSurface(cartesian, ellipsoid, result = []) {
-    const { oneOverRadii, oneOverRadiiSquared, centerToleranceSquared } = ellipsoid;
-    scratchVector4.from(cartesian);
-    const positionX = scratchVector4.x;
-    const positionY = scratchVector4.y;
-    const positionZ = scratchVector4.z;
-    const oneOverRadiiX = oneOverRadii.x;
-    const oneOverRadiiY = oneOverRadii.y;
-    const oneOverRadiiZ = oneOverRadii.z;
-    const x2 = positionX * positionX * oneOverRadiiX * oneOverRadiiX;
-    const y2 = positionY * positionY * oneOverRadiiY * oneOverRadiiY;
-    const z2 = positionZ * positionZ * oneOverRadiiZ * oneOverRadiiZ;
-    const squaredNorm = x2 + y2 + z2;
-    const ratio = Math.sqrt(1 / squaredNorm);
-    if (!Number.isFinite(ratio)) {
-      return void 0;
+  // ../loader-utils/src/lib/file-provider/file-provider-interface.ts
+  var isFileProvider = (fileProvider) => {
+    return fileProvider?.getUint8 && fileProvider?.slice && fileProvider?.length;
+  };
+
+  // ../loader-utils/src/lib/file-provider/file-handle-file.ts
+  var FileHandleFile = class {
+    /** The FileHandle from which data is provided */
+    file;
+    /** Create a new FileHandleFile */
+    constructor(path, append = false) {
+      this.file = new NodeFileFacade(path, append ? "a+" : "r");
     }
-    const intersection = scaleToGeodeticSurfaceIntersection;
-    intersection.copy(cartesian).scale(ratio);
-    if (squaredNorm < centerToleranceSquared) {
-      return intersection.to(result);
+    /**
+     * Truncates the file descriptor.
+     * @param length desired file lenght
+     */
+    async truncate(length4) {
+      await this.file.truncate(length4);
     }
-    const oneOverRadiiSquaredX = oneOverRadiiSquared.x;
-    const oneOverRadiiSquaredY = oneOverRadiiSquared.y;
-    const oneOverRadiiSquaredZ = oneOverRadiiSquared.z;
-    const gradient = scaleToGeodeticSurfaceGradient;
-    gradient.set(intersection.x * oneOverRadiiSquaredX * 2, intersection.y * oneOverRadiiSquaredY * 2, intersection.z * oneOverRadiiSquaredZ * 2);
-    let lambda = (1 - ratio) * scratchVector4.len() / (0.5 * gradient.len());
-    let correction = 0;
-    let xMultiplier;
-    let yMultiplier;
-    let zMultiplier;
-    let func;
-    do {
-      lambda -= correction;
-      xMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredX);
-      yMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredY);
-      zMultiplier = 1 / (1 + lambda * oneOverRadiiSquaredZ);
-      const xMultiplier2 = xMultiplier * xMultiplier;
-      const yMultiplier2 = yMultiplier * yMultiplier;
-      const zMultiplier2 = zMultiplier * zMultiplier;
-      const xMultiplier3 = xMultiplier2 * xMultiplier;
-      const yMultiplier3 = yMultiplier2 * yMultiplier;
-      const zMultiplier3 = zMultiplier2 * zMultiplier;
-      func = x2 * xMultiplier2 + y2 * yMultiplier2 + z2 * zMultiplier2 - 1;
-      const denominator = x2 * xMultiplier3 * oneOverRadiiSquaredX + y2 * yMultiplier3 * oneOverRadiiSquaredY + z2 * zMultiplier3 * oneOverRadiiSquaredZ;
-      const derivative = -2 * denominator;
-      correction = func / derivative;
-    } while (Math.abs(func) > math_utils_exports.EPSILON12);
-    return scratchVector4.scale([xMultiplier, yMultiplier, zMultiplier]).to(result);
-  }
-
-  // ../../node_modules/@math.gl/geospatial/dist/ellipsoid/ellipsoid.js
-  var scratchVector5 = new Vector3();
-  var scratchNormal = new Vector3();
-  var scratchK = new Vector3();
-  var scratchPosition = new Vector3();
-  var scratchHeight = new Vector3();
-  var scratchCartesian = new Vector3();
-  var Ellipsoid = class {
-    constructor(x = 0, y = 0, z = 0) {
-      this.centerToleranceSquared = math_utils_exports.EPSILON1;
-      assert3(x >= 0);
-      assert3(y >= 0);
-      assert3(z >= 0);
-      this.radii = new Vector3(x, y, z);
-      this.radiiSquared = new Vector3(x * x, y * y, z * z);
-      this.radiiToTheFourth = new Vector3(x * x * x * x, y * y * y * y, z * z * z * z);
-      this.oneOverRadii = new Vector3(x === 0 ? 0 : 1 / x, y === 0 ? 0 : 1 / y, z === 0 ? 0 : 1 / z);
-      this.oneOverRadiiSquared = new Vector3(x === 0 ? 0 : 1 / (x * x), y === 0 ? 0 : 1 / (y * y), z === 0 ? 0 : 1 / (z * z));
-      this.minimumRadius = Math.min(x, y, z);
-      this.maximumRadius = Math.max(x, y, z);
-      if (this.radiiSquared.z !== 0) {
-        this.squaredXOverSquaredZ = this.radiiSquared.x / this.radiiSquared.z;
+    /**
+     * Append data to a file.
+     * @param buffer data to append
+     */
+    async append(buffer) {
+      await this.file.append(buffer);
+    }
+    /** Close file */
+    async destroy() {
+      await this.file.close();
+    }
+    /**
+     * Gets an unsigned 8-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint8(offset) {
+      const arrayBuffer = await this.file.read(offset, 1);
+      const val = new Uint8Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
       }
-      Object.freeze(this);
+      return val;
     }
-    /** Compares this Ellipsoid against the provided Ellipsoid componentwise */
-    equals(right) {
-      return this === right || Boolean(right && this.radii.equals(right.radii));
+    /**
+     * Gets an unsigned 16-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint16(offset) {
+      const arrayBuffer = await this.file.read(offset, 2);
+      const val = new Uint16Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
+      }
+      return val;
     }
-    /** Creates a string representing this Ellipsoid in the format '(radii.x, radii.y, radii.z)'. */
-    toString() {
-      return this.radii.toString();
+    /**
+     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint32(offset) {
+      const arrayBuffer = await this.file.read(offset, 4);
+      const val = new Uint32Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
+      }
+      return val;
     }
-    cartographicToCartesian(cartographic, result = [0, 0, 0]) {
-      const normal = scratchNormal;
-      const k = scratchK;
-      const [, , height] = cartographic;
-      this.geodeticSurfaceNormalCartographic(cartographic, normal);
-      k.copy(this.radiiSquared).scale(normal);
-      const gamma = Math.sqrt(normal.dot(k));
-      k.scale(1 / gamma);
-      normal.scale(height);
-      k.add(normal);
-      return k.to(result);
+    /**
+     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getBigUint64(offset) {
+      const arrayBuffer = await this.file.read(offset, 8);
+      const val = new BigInt64Array(arrayBuffer).at(0);
+      if (val === void 0) {
+        throw new Error("something went wrong");
+      }
+      return val;
     }
-    cartesianToCartographic(cartesian, result = [0, 0, 0]) {
-      scratchCartesian.from(cartesian);
-      const point = this.scaleToGeodeticSurface(scratchCartesian, scratchPosition);
-      if (!point) {
-        return void 0;
+    /**
+     * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
+     * @param startOffset The offset, in byte, from the start of the file where to start reading the data.
+     * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
+     */
+    async slice(startOffset, endOffset) {
+      const bigLength = endOffset - startOffset;
+      if (bigLength > Number.MAX_SAFE_INTEGER) {
+        throw new Error("too big slice");
       }
-      const normal = this.geodeticSurfaceNormal(point, scratchNormal);
-      const h = scratchHeight;
-      h.copy(scratchCartesian).subtract(point);
-      const longitude = Math.atan2(normal.y, normal.x);
-      const latitude = Math.asin(normal.z);
-      const height = Math.sign(vec3_exports.dot(h, scratchCartesian)) * vec3_exports.length(h);
-      return toCartographicFromRadians([longitude, latitude, height], result);
+      const length4 = Number(bigLength);
+      return await this.file.read(startOffset, length4);
     }
-    eastNorthUpToFixedFrame(origin, result = new Matrix4()) {
-      return localFrameToFixedFrame(this, "east", "north", "up", origin, result);
+    /**
+     * the length (in bytes) of the data.
+     */
+    get length() {
+      return this.file.bigsize;
     }
-    // Computes a 4x4 transformation matrix from a reference frame centered at
-    // the provided origin to the ellipsoid's fixed reference frame.
-    localFrameToFixedFrame(firstAxis, secondAxis, thirdAxis, origin, result = new Matrix4()) {
-      return localFrameToFixedFrame(this, firstAxis, secondAxis, thirdAxis, origin, result);
+  };
+
+  // ../loader-utils/src/lib/file-provider/data-view-file.ts
+  var toNumber = (bigint) => {
+    if (bigint > Number.MAX_SAFE_INTEGER) {
+      throw new Error("Offset is out of bounds");
     }
-    geocentricSurfaceNormal(cartesian, result = [0, 0, 0]) {
-      return scratchVector5.from(cartesian).normalize().to(result);
+    return Number(bigint);
+  };
+  var DataViewFile = class {
+    /** The DataView from which data is provided */
+    file;
+    constructor(file) {
+      this.file = file;
     }
-    geodeticSurfaceNormalCartographic(cartographic, result = [0, 0, 0]) {
-      const cartographicVectorRadians = fromCartographicToRadians(cartographic);
-      const longitude = cartographicVectorRadians[0];
-      const latitude = cartographicVectorRadians[1];
-      const cosLatitude = Math.cos(latitude);
-      scratchVector5.set(cosLatitude * Math.cos(longitude), cosLatitude * Math.sin(longitude), Math.sin(latitude)).normalize();
-      return scratchVector5.to(result);
+    async destroy() {
     }
-    geodeticSurfaceNormal(cartesian, result = [0, 0, 0]) {
-      return scratchVector5.from(cartesian).scale(this.oneOverRadiiSquared).normalize().to(result);
+    /**
+     * Gets an unsigned 8-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint8(offset) {
+      return this.file.getUint8(toNumber(offset));
     }
-    /** Scales the provided Cartesian position along the geodetic surface normal
-     * so that it is on the surface of this ellipsoid.  If the position is
-     * at the center of the ellipsoid, this function returns undefined. */
-    scaleToGeodeticSurface(cartesian, result) {
-      return scaleToGeodeticSurface(cartesian, this, result);
+    /**
+     * Gets an unsigned 16-bit intege at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint16(offset) {
+      return this.file.getUint16(toNumber(offset), true);
     }
-    /** Scales the provided Cartesian position along the geocentric surface normal
-     * so that it is on the surface of this ellipsoid. */
-    scaleToGeocentricSurface(cartesian, result = [0, 0, 0]) {
-      scratchPosition.from(cartesian);
-      const positionX = scratchPosition.x;
-      const positionY = scratchPosition.y;
-      const positionZ = scratchPosition.z;
-      const oneOverRadiiSquared = this.oneOverRadiiSquared;
-      const beta = 1 / Math.sqrt(positionX * positionX * oneOverRadiiSquared.x + positionY * positionY * oneOverRadiiSquared.y + positionZ * positionZ * oneOverRadiiSquared.z);
-      return scratchPosition.multiplyScalar(beta).to(result);
+    /**
+     * Gets an unsigned 32-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getUint32(offset) {
+      return this.file.getUint32(toNumber(offset), true);
     }
-    /** Transforms a Cartesian X, Y, Z position to the ellipsoid-scaled space by multiplying
-     * its components by the result of `Ellipsoid#oneOverRadii` */
-    transformPositionToScaledSpace(position, result = [0, 0, 0]) {
-      return scratchPosition.from(position).scale(this.oneOverRadii).to(result);
+    /**
+     * Gets an unsigned 64-bit integer at the specified byte offset from the start of the file.
+     * @param offset The offset, in bytes, from the start of the file where to read the data.
+     */
+    async getBigUint64(offset) {
+      return this.file.getBigUint64(toNumber(offset), true);
     }
-    /** Transforms a Cartesian X, Y, Z position from the ellipsoid-scaled space by multiplying
-     * its components by the result of `Ellipsoid#radii`. */
-    transformPositionFromScaledSpace(position, result = [0, 0, 0]) {
-      return scratchPosition.from(position).scale(this.radii).to(result);
+    /**
+     * returns an ArrayBuffer whose contents are a copy of this file bytes from startOffset, inclusive, up to endOffset, exclusive.
+     * @param startOffset The offset, in bytes, from the start of the file where to start reading the data.
+     * @param endOffset The offset, in bytes, from the start of the file where to end reading the data.
+     */
+    async slice(startOffset, endOffset) {
+      return this.file.buffer.slice(toNumber(startOffset), toNumber(endOffset));
     }
-    /** Computes a point which is the intersection of the surface normal with the z-axis. */
-    getSurfaceNormalIntersectionWithZAxis(position, buffer = 0, result = [0, 0, 0]) {
-      assert3(equals(this.radii.x, this.radii.y, math_utils_exports.EPSILON15));
-      assert3(this.radii.z > 0);
-      scratchPosition.from(position);
-      const z = scratchPosition.z * (1 - this.squaredXOverSquaredZ);
-      if (Math.abs(z) >= this.radii.z - buffer) {
-        return void 0;
-      }
-      return scratchPosition.set(0, 0, z).to(result);
+    /** the length (in bytes) of the data. */
+    get length() {
+      return BigInt(this.file.byteLength);
     }
   };
-  Ellipsoid.WGS84 = new Ellipsoid(WGS84_RADIUS_X, WGS84_RADIUS_Y, WGS84_RADIUS_Z);
 
   // ../images/src/lib/utils/version.ts
   var VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
@@ -9832,7 +9834,7 @@ var __exports__ = (() => {
   async function parseToNodeImage(arrayBuffer, options) {
     const { mimeType } = getBinaryImageMetadata(arrayBuffer) || {};
     const parseImageNode2 = globalThis.loaders?.parseImageNode;
-    assert(parseImageNode2);
+    assert2(parseImageNode2);
     return await parseImageNode2(arrayBuffer, mimeType);
   }
 
@@ -9855,7 +9857,7 @@ var __exports__ = (() => {
         image = await parseToNodeImage(arrayBuffer, options);
         break;
       default:
-        assert(false);
+        assert2(false);
     }
     if (imageType === "data") {
       image = getImageData(image);
@@ -9908,35 +9910,88 @@ var __exports__ = (() => {
     options: DEFAULT_IMAGE_LOADER_OPTIONS
   };
 
+  // ../draco/src/lib/draco-module-loader.ts
+  var DRACO_DECODER_VERSION = "1.5.6";
+  var DRACO_ENCODER_VERSION = "1.4.1";
+  var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
+  var DRACO_EXTERNAL_LIBRARIES = {
+    /** The primary Draco3D encoder, javascript wrapper part */
+    DECODER: "draco_wasm_wrapper.js",
+    /** The primary draco decoder, compiled web assembly part */
+    DECODER_WASM: "draco_decoder.wasm",
+    /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
+    FALLBACK_DECODER: "draco_decoder.js",
+    /** Draco encoder */
+    ENCODER: "draco_encoder.js"
+  };
+  var 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}`
+  };
+  var loadDecoderPromise;
+  async function loadDracoDecoderModule(options) {
+    const modules = options.modules || {};
+    if (modules.draco3d) {
+      loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
+        return { draco };
+      });
+    } else {
+      loadDecoderPromise ||= loadDracoDecoder(options);
+    }
+    return await loadDecoderPromise;
+  }
+  async function loadDracoDecoder(options) {
+    let DracoDecoderModule;
+    let wasmBinary;
+    switch (options.draco && options.draco.decoderType) {
+      case "js":
+        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_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;
+    return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
+  }
+  function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+      DracoDecoderModule({
+        ...options,
+        onModuleLoaded: (draco) => resolve({ draco })
+        // Module is Promise-like. Wrap in object to avoid loop.
+      });
+    });
+  }
+
   // ../draco/src/lib/utils/version.ts
   var VERSION3 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
 
-  // ../draco/src/draco-loader.ts
-  var DracoLoader = {
-    dataType: null,
-    batchType: null,
-    name: "Draco",
-    id: "draco",
-    module: "draco",
-    // shapes: ['mesh'],
-    version: VERSION3,
-    worker: true,
-    extensions: ["drc"],
-    mimeTypes: ["application/octet-stream"],
-    binary: true,
-    tests: ["DRACO"],
-    options: {
-      draco: {
-        decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
-        // 'js' for IE11
-        libraryPath: "libs/",
-        extraAttributes: {},
-        attributeNameEntry: void 0
-      }
-    }
-  };
-
-  // ../schema/src/lib/table/simple-table/data-type.ts
+  // ../schema-utils/src/lib/schema/data-type.ts
   function getDataTypeFromTypedArray(array) {
     switch (array.constructor) {
       case Int8Array:
@@ -9961,7 +10016,7 @@ var __exports__ = (() => {
     }
   }
 
-  // ../schema/src/lib/mesh/mesh-utils.ts
+  // ../schema-utils/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -9988,7 +10043,7 @@ var __exports__ = (() => {
     ];
   }
 
-  // ../schema/src/lib/mesh/deduce-mesh-schema.ts
+  // ../schema-utils/src/lib/mesh/deduce-mesh-schema.ts
   function deduceMeshField(name, attribute, optionalMetadata) {
     const type = getDataTypeFromTypedArray(attribute.value);
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
@@ -10212,6 +10267,7 @@ var __exports__ = (() => {
           case "triangle-strip":
             return {
               topology: "triangle-strip",
+              // TODO - mode is wrong?
               mode: 4,
               // GL.TRIANGLES
               attributes,
@@ -10224,6 +10280,7 @@ var __exports__ = (() => {
           default:
             return {
               topology: "triangle-list",
+              // TODO - mode is wrong?
               mode: 5,
               // GL.TRIANGLE_STRIP
               attributes,
@@ -10508,87 +10565,32 @@ var __exports__ = (() => {
     return intArray;
   }
 
-  // ../draco/src/lib/draco-module-loader.ts
-  var DRACO_DECODER_VERSION = "1.5.6";
-  var DRACO_ENCODER_VERSION = "1.4.1";
-  var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
-  var DRACO_EXTERNAL_LIBRARIES = {
-    /** The primary Draco3D encoder, javascript wrapper part */
-    DECODER: "draco_wasm_wrapper.js",
-    /** The primary draco decoder, compiled web assembly part */
-    DECODER_WASM: "draco_decoder.wasm",
-    /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
-    FALLBACK_DECODER: "draco_decoder.js",
-    /** Draco encoder */
-    ENCODER: "draco_encoder.js"
-  };
-  var 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}`
-  };
-  var loadDecoderPromise;
-  async function loadDracoDecoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.draco3d) {
-      loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
-        return { draco };
-      });
-    } else {
-      loadDecoderPromise ||= loadDracoDecoder(options);
-    }
-    return await loadDecoderPromise;
-  }
-  async function loadDracoDecoder(options) {
-    let DracoDecoderModule;
-    let wasmBinary;
-    switch (options.draco && options.draco.decoderType) {
-      case "js":
-        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_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;
-    return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
-  }
-  function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  // ../draco/src/draco-loader.ts
+  var DracoWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "Draco",
+    id: "draco",
+    module: "draco",
+    // shapes: ['mesh'],
+    version: VERSION3,
+    worker: true,
+    extensions: ["drc"],
+    mimeTypes: ["application/octet-stream"],
+    binary: true,
+    tests: ["DRACO"],
+    options: {
+      draco: {
+        decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
+        // 'js' for IE11
+        libraryPath: "libs/",
+        extraAttributes: {},
+        attributeNameEntry: void 0
+      }
     }
-    return new Promise((resolve) => {
-      DracoDecoderModule({
-        ...options,
-        onModuleLoaded: (draco) => resolve({ draco })
-        // Module is Promise-like. Wrap in object to avoid loop.
-      });
-    });
-  }
-
-  // ../draco/src/index.ts
-  var DracoLoader2 = {
-    ...DracoLoader,
+  };
+  var DracoLoader = {
+    ...DracoWorkerLoader,
     parse
   };
   async function parse(arrayBuffer, options) {
@@ -11507,14 +11509,14 @@ var __exports__ = (() => {
   function parseDDS(data) {
     const header = new Int32Array(data, 0, DDS_CONSTANTS.HEADER_LENGTH);
     const pixelFormatNumber = header[DDS_CONSTANTS.HEADER_PF_FOURCC_INDEX];
-    assert(
+    assert2(
       Boolean(header[DDS_CONSTANTS.HEADER_PF_FLAGS_INDEX] & DDS_CONSTANTS.DDPF_FOURCC),
       "DDS: Unsupported format, must contain a FourCC code"
     );
     const fourCC = int32ToFourCC(pixelFormatNumber);
     const internalFormat = DDS_PIXEL_FORMATS[fourCC];
     const sizeFunction = DDS_SIZE_FUNCTIONS[fourCC];
-    assert(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
+    assert2(internalFormat && sizeFunction, `DDS: Unknown pixel format ${pixelFormatNumber}`);
     let mipMapLevels = 1;
     if (header[DDS_CONSTANTS.HEADER_FLAGS_INDEX] & DDS_CONSTANTS.DDSD_MIPMAPCOUNT) {
       mipMapLevels = Math.max(1, header[DDS_CONSTANTS.MIPMAPCOUNT_INDEX]);
@@ -11918,7 +11920,7 @@ var __exports__ = (() => {
     let featureCount = 0;
     let indices;
     if (tileOptions.isDracoGeometry) {
-      const decompressedGeometry = await (0, import_core5.parse)(arrayBuffer, DracoLoader2, {
+      const decompressedGeometry = await (0, import_core5.parse)(arrayBuffer, DracoLoader, {
         draco: {
           attributeNameEntry: I3S_ATTRIBUTE_TYPE
         }
@@ -12620,7 +12622,7 @@ var __exports__ = (() => {
     }
     /** Creates a plane from a normal and a distance from the origin. */
     fromNormalDistance(normal, distance2) {
-      assert3(Number.isFinite(distance2));
+      assert(Number.isFinite(distance2));
       this.normal.from(normal).normalize();
       this.distance = distance2;
       return this;
@@ -12636,7 +12638,7 @@ var __exports__ = (() => {
     /** Creates a plane from the general equation */
     fromCoefficients(a, b, c, d) {
       this.normal.set(a, b, c);
-      assert3(equals(this.normal.len(), 1));
+      assert(equals(this.normal.len(), 1));
       this.distance = d;
       return this;
     }
@@ -12732,7 +12734,7 @@ var __exports__ = (() => {
      *   and that plane check can be skipped.
      */
     computeVisibilityWithPlaneMask(boundingVolume, parentPlaneMask) {
-      assert3(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
+      assert(Number.isFinite(parentPlaneMask), "parentPlaneMask is required.");
       if (parentPlaneMask === CullingVolume.MASK_OUTSIDE || parentPlaneMask === CullingVolume.MASK_INSIDE) {
         return parentPlaneMask;
       }
@@ -14708,7 +14710,7 @@ var __exports__ = (() => {
       extensions: [".bin.gz"]
     },
     {
-      test: /statistics\/f_\d+\/\d+$/,
+      test: /statistics\/(f_\d+\/\d+|summary)$/,
       extensions: [".json.gz"]
     },
     {