@loaders.gl/gltf 3.2.6 → 3.3.0-alpha.2

package/dist/dist.min.js

@@ -14,8 +14,8 @@
   };
   var __export = (target, all) => {
     __markAsModule(target);
-    for (var name8 in all)
-      __defProp(target, name8, { get: all[name8], enumerable: true });
+    for (var name10 in all)
+      __defProp(target, name10, { get: all[name10], enumerable: true });
   };
   var __reExport = (target, module, desc) => {
     if (module && typeof module === "object" || typeof module === "function") {
@@ -72,7 +72,7 @@
   var DEFAULT_VERSION, VERSION2;
   var init_version2 = __esm({
     "../worker-utils/src/lib/env-utils/version.ts"() {
-      DEFAULT_VERSION = "latest";
+      DEFAULT_VERSION = "beta";
       VERSION2 = typeof __VERSION__ !== "undefined" ? __VERSION__ : DEFAULT_VERSION;
       if (typeof __VERSION__ === "undefined") {
         console.error("loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN.");
@@ -191,7 +191,7 @@
       node = __toModule(require_require_utils());
       init_assert2();
       init_version2();
-      LATEST = "latest";
+      LATEST = "beta";
       VERSION3 = typeof VERSION2 !== "undefined" ? VERSION2 : LATEST;
       loadLibraryPromises = {};
     }
@@ -200,6 +200,7 @@
   // ../worker-utils/src/index.ts
   var init_src = __esm({
     "../worker-utils/src/index.ts"() {
+      init_globals2();
       init_library_utils();
     }
   });
@@ -324,7 +325,7 @@
   var VERSION4;
   var init_version3 = __esm({
     "../textures/src/lib/utils/version.ts"() {
-      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+      VERSION4 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "beta";
     }
   });
 
@@ -753,11 +754,12 @@
   var BasisWorkerLoader, BasisLoader;
   var init_basis_loader = __esm({
     "../textures/src/basis-loader.ts"() {
+      init_src();
       init_version3();
       init_parse_basis();
       BasisWorkerLoader = {
         name: "Basis",
-        id: "basis",
+        id: isBrowser2 ? "basis" : "basis-nodejs",
         module: "textures",
         version: VERSION4,
         worker: true,
@@ -1396,12 +1398,12 @@
           return extras[key];
         }
         getExtension(extensionName) {
-          const isExtension = this.getUsedExtensions().find((name8) => name8 === extensionName);
+          const isExtension = this.getUsedExtensions().find((name10) => name10 === extensionName);
           const extensions = this.json.extensions || {};
           return isExtension ? extensions[extensionName] || true : null;
         }
         getRequiredExtension(extensionName) {
-          const isRequired = this.getRequiredExtensions().find((name8) => name8 === extensionName);
+          const isRequired = this.getRequiredExtensions().find((name10) => name10 === extensionName);
           return isRequired ? this.getExtension(extensionName) : null;
         }
         getRequiredExtensions() {
@@ -2064,6 +2066,7 @@
   var DEFAULT_DRACO_OPTIONS, DracoLoader;
   var init_draco_loader = __esm({
     "../draco/src/draco-loader.ts"() {
+      init_src();
       init_version5();
       DEFAULT_DRACO_OPTIONS = {
         draco: {
@@ -2075,7 +2078,7 @@
       };
       DracoLoader = {
         name: "Draco",
-        id: "draco",
+        id: isBrowser2 ? "draco" : "draco-nodejs",
         module: "draco",
         shapes: ["mesh"],
         version: VERSION7,
@@ -2171,8 +2174,8 @@
         }
         select(...columnNames) {
           const nameMap = Object.create(null);
-          for (const name8 of columnNames) {
-            nameMap[name8] = true;
+          for (const name10 of columnNames) {
+            nameMap[name10] = true;
           }
           const selectedFields = this.fields.filter((field) => nameMap[field.name]);
           return new Schema(selectedFields, this.metadata);
@@ -2210,8 +2213,8 @@
   var init_field = __esm({
     "../schema/src/lib/schema/impl/field.ts"() {
       Field = class {
-        constructor(name8, type, nullable = false, metadata = new Map()) {
-          this.name = name8;
+        constructor(name10, type, nullable = false, metadata = new Map()) {
+          this.name = name10;
           this.type = type;
           this.nullable = nullable;
           this.metadata = metadata;
@@ -3134,11 +3137,11 @@
   // src/lib/gltf-utils/gltf-attribute-utils.ts
   function getGLTFAccessors(attributes) {
     const accessors = {};
-    for (const name8 in attributes) {
-      const attribute = attributes[name8];
-      if (name8 !== "indices") {
+    for (const name10 in attributes) {
+      const attribute = attributes[name10];
+      if (name10 !== "indices") {
         const glTFAccessor = getGLTFAccessor(attribute);
-        accessors[name8] = glTFAccessor;
+        accessors[name10] = glTFAccessor;
       }
     }
     return accessors;
@@ -3301,14 +3304,1378 @@
     }
   });
 
+  // ../../node_modules/@math.gl/core/dist/esm/lib/assert.js
+  function assert5(condition, message) {
+    if (!condition) {
+      throw new Error("math.gl assertion ".concat(message));
+    }
+  }
+  var init_assert5 = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/assert.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/lib/common.js
+  function round(value) {
+    return Math.round(value / config.EPSILON) * config.EPSILON;
+  }
+  function formatValue(value, {
+    precision = config.precision || 4
+  } = {}) {
+    value = round(value);
+    return "".concat(parseFloat(value.toPrecision(precision)));
+  }
+  function isArray(value) {
+    return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
+  }
+  function equals(a2, b, epsilon) {
+    const oldEpsilon = config.EPSILON;
+    if (epsilon) {
+      config.EPSILON = epsilon;
+    }
+    try {
+      if (a2 === b) {
+        return true;
+      }
+      if (isArray(a2) && isArray(b)) {
+        if (a2.length !== b.length) {
+          return false;
+        }
+        for (let i2 = 0; i2 < a2.length; ++i2) {
+          if (!equals(a2[i2], b[i2])) {
+            return false;
+          }
+        }
+        return true;
+      }
+      if (a2 && a2.equals) {
+        return a2.equals(b);
+      }
+      if (b && b.equals) {
+        return b.equals(a2);
+      }
+      if (Number.isFinite(a2) && Number.isFinite(b)) {
+        return Math.abs(a2 - b) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b));
+      }
+      return false;
+    } finally {
+      config.EPSILON = oldEpsilon;
+    }
+  }
+  var RADIANS_TO_DEGREES, DEGREES_TO_RADIANS, config;
+  var init_common = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/common.js"() {
+      RADIANS_TO_DEGREES = 1 / Math.PI * 180;
+      DEGREES_TO_RADIANS = 1 / 180 * Math.PI;
+      config = {};
+      config.EPSILON = 1e-12;
+      config.debug = false;
+      config.precision = 4;
+      config.printTypes = false;
+      config.printDegrees = false;
+      config.printRowMajor = true;
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/math-array.js
+  function _extendableBuiltin(cls) {
+    function ExtendableBuiltin() {
+      var instance = Reflect.construct(cls, Array.from(arguments));
+      Object.setPrototypeOf(instance, Object.getPrototypeOf(this));
+      return instance;
+    }
+    ExtendableBuiltin.prototype = Object.create(cls.prototype, {
+      constructor: {
+        value: cls,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    if (Object.setPrototypeOf) {
+      Object.setPrototypeOf(ExtendableBuiltin, cls);
+    } else {
+      ExtendableBuiltin.__proto__ = cls;
+    }
+    return ExtendableBuiltin;
+  }
+  var MathArray;
+  var init_math_array = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/base/math-array.js"() {
+      init_common();
+      init_assert5();
+      MathArray = class extends _extendableBuiltin(Array) {
+        get ELEMENTS() {
+          assert5(false);
+          return 0;
+        }
+        clone() {
+          return new this.constructor().copy(this);
+        }
+        from(arrayOrObject) {
+          return Array.isArray(arrayOrObject) ? this.copy(arrayOrObject) : this.fromObject(arrayOrObject);
+        }
+        fromArray(array, offset = 0) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = array[i2 + offset];
+          }
+          return this.check();
+        }
+        to(arrayOrObject) {
+          if (arrayOrObject === this) {
+            return this;
+          }
+          return isArray(arrayOrObject) ? this.toArray(arrayOrObject) : this.toObject(arrayOrObject);
+        }
+        toTarget(target) {
+          return target ? this.to(target) : this;
+        }
+        toArray(array = [], offset = 0) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            array[offset + i2] = this[i2];
+          }
+          return array;
+        }
+        toFloat32Array() {
+          return new Float32Array(this);
+        }
+        toString() {
+          return this.formatString(config);
+        }
+        formatString(opts) {
+          let string = "";
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            string += (i2 > 0 ? ", " : "") + formatValue(this[i2], opts);
+          }
+          return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
+        }
+        equals(array) {
+          if (!array || this.length !== array.length) {
+            return false;
+          }
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            if (!equals(this[i2], array[i2])) {
+              return false;
+            }
+          }
+          return true;
+        }
+        exactEquals(array) {
+          if (!array || this.length !== array.length) {
+            return false;
+          }
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            if (this[i2] !== array[i2]) {
+              return false;
+            }
+          }
+          return true;
+        }
+        negate() {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = -this[i2];
+          }
+          return this.check();
+        }
+        lerp(a2, b, t2) {
+          if (t2 === void 0) {
+            t2 = b;
+            b = a2;
+            a2 = this;
+          }
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            const ai = a2[i2];
+            this[i2] = ai + t2 * (b[i2] - ai);
+          }
+          return this.check();
+        }
+        min(vector) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.min(vector[i2], this[i2]);
+          }
+          return this.check();
+        }
+        max(vector) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.max(vector[i2], this[i2]);
+          }
+          return this.check();
+        }
+        clamp(minVector, maxVector) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.min(Math.max(this[i2], minVector[i2]), maxVector[i2]);
+          }
+          return this.check();
+        }
+        add(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] += vector[i2];
+            }
+          }
+          return this.check();
+        }
+        subtract(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] -= vector[i2];
+            }
+          }
+          return this.check();
+        }
+        scale(scale2) {
+          if (Array.isArray(scale2)) {
+            return this.multiply(scale2);
+          }
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] *= scale2;
+          }
+          return this.check();
+        }
+        sub(a2) {
+          return this.subtract(a2);
+        }
+        setScalar(a2) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = a2;
+          }
+          return this.check();
+        }
+        addScalar(a2) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] += a2;
+          }
+          return this.check();
+        }
+        subScalar(a2) {
+          return this.addScalar(-a2);
+        }
+        multiplyScalar(scalar) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] *= scalar;
+          }
+          return this.check();
+        }
+        divideScalar(a2) {
+          return this.scale(1 / a2);
+        }
+        clampScalar(min, max) {
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            this[i2] = Math.min(Math.max(this[i2], min), max);
+          }
+          return this.check();
+        }
+        multiplyByScalar(scalar) {
+          return this.scale(scalar);
+        }
+        get elements() {
+          return this;
+        }
+        check() {
+          if (config.debug && !this.validate()) {
+            throw new Error("math.gl: ".concat(this.constructor.name, " some fields set to invalid numbers'"));
+          }
+          return this;
+        }
+        validate() {
+          let valid = this.length === this.ELEMENTS;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            valid = valid && Number.isFinite(this[i2]);
+          }
+          return valid;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/lib/validators.js
+  function validateVector(v, length) {
+    if (v.length !== length) {
+      return false;
+    }
+    for (let i2 = 0; i2 < v.length; ++i2) {
+      if (!Number.isFinite(v[i2])) {
+        return false;
+      }
+    }
+    return true;
+  }
+  function checkNumber(value) {
+    if (!Number.isFinite(value)) {
+      throw new Error("Invalid number ".concat(value));
+    }
+    return value;
+  }
+  function checkVector(v, length, callerName = "") {
+    if (config.debug && !validateVector(v, length)) {
+      throw new Error("math.gl: ".concat(callerName, " some fields set to invalid numbers'"));
+    }
+    return v;
+  }
+  function deprecated(method, version) {
+    if (!map[method]) {
+      map[method] = true;
+      console.warn("".concat(method, " has been removed in version ").concat(version, ", see upgrade guide for more information"));
+    }
+  }
+  var map;
+  var init_validators = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/validators.js"() {
+      init_common();
+      map = {};
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/vector.js
+  var Vector;
+  var init_vector = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/base/vector.js"() {
+      init_math_array();
+      init_validators();
+      init_assert5();
+      Vector = class extends MathArray {
+        get ELEMENTS() {
+          assert5(false);
+          return 0;
+        }
+        copy(vector) {
+          assert5(false);
+          return this;
+        }
+        get x() {
+          return this[0];
+        }
+        set x(value) {
+          this[0] = checkNumber(value);
+        }
+        get y() {
+          return this[1];
+        }
+        set y(value) {
+          this[1] = checkNumber(value);
+        }
+        len() {
+          return Math.sqrt(this.lengthSquared());
+        }
+        magnitude() {
+          return this.len();
+        }
+        lengthSquared() {
+          let length = 0;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            length += this[i2] * this[i2];
+          }
+          return length;
+        }
+        magnitudeSquared() {
+          return this.lengthSquared();
+        }
+        distance(mathArray) {
+          return Math.sqrt(this.distanceSquared(mathArray));
+        }
+        distanceSquared(mathArray) {
+          let length = 0;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            const dist = this[i2] - mathArray[i2];
+            length += dist * dist;
+          }
+          return checkNumber(length);
+        }
+        dot(mathArray) {
+          let product = 0;
+          for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+            product += this[i2] * mathArray[i2];
+          }
+          return checkNumber(product);
+        }
+        normalize() {
+          const length = this.magnitude();
+          if (length !== 0) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] /= length;
+            }
+          }
+          return this.check();
+        }
+        multiply(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] *= vector[i2];
+            }
+          }
+          return this.check();
+        }
+        divide(...vectors) {
+          for (const vector of vectors) {
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              this[i2] /= vector[i2];
+            }
+          }
+          return this.check();
+        }
+        lengthSq() {
+          return this.lengthSquared();
+        }
+        distanceTo(vector) {
+          return this.distance(vector);
+        }
+        distanceToSquared(vector) {
+          return this.distanceSquared(vector);
+        }
+        getComponent(i2) {
+          assert5(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+          return checkNumber(this[i2]);
+        }
+        setComponent(i2, value) {
+          assert5(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
+          this[i2] = value;
+          return this.check();
+        }
+        addVectors(a2, b) {
+          return this.copy(a2).add(b);
+        }
+        subVectors(a2, b) {
+          return this.copy(a2).subtract(b);
+        }
+        multiplyVectors(a2, b) {
+          return this.copy(a2).multiply(b);
+        }
+        addScaledVector(a2, b) {
+          return this.add(new this.constructor(a2).multiplyScalar(b));
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/common.js
+  var ARRAY_TYPE, degree;
+  var init_common2 = __esm({
+    "../../node_modules/gl-matrix/esm/common.js"() {
+      ARRAY_TYPE = typeof Float32Array !== "undefined" ? Float32Array : Array;
+      degree = Math.PI / 180;
+      if (!Math.hypot)
+        Math.hypot = function() {
+          var y = 0, i2 = arguments.length;
+          while (i2--) {
+            y += arguments[i2] * arguments[i2];
+          }
+          return Math.sqrt(y);
+        };
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/vec2.js
+  function create() {
+    var out = new ARRAY_TYPE(2);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+    }
+    return out;
+  }
+  function transformMat3(out, a2, m) {
+    var x = a2[0], y = a2[1];
+    out[0] = m[0] * x + m[3] * y + m[6];
+    out[1] = m[1] * x + m[4] * y + m[7];
+    return out;
+  }
+  var forEach;
+  var init_vec2 = __esm({
+    "../../node_modules/gl-matrix/esm/vec2.js"() {
+      init_common2();
+      forEach = function() {
+        var vec = create();
+        return function(a2, stride, offset, count, fn, arg) {
+          var i2, l2;
+          if (!stride) {
+            stride = 2;
+          }
+          if (!offset) {
+            offset = 0;
+          }
+          if (count) {
+            l2 = Math.min(count * stride + offset, a2.length);
+          } else {
+            l2 = a2.length;
+          }
+          for (i2 = offset; i2 < l2; i2 += stride) {
+            vec[0] = a2[i2];
+            vec[1] = a2[i2 + 1];
+            fn(vec, vec, arg);
+            a2[i2] = vec[0];
+            a2[i2 + 1] = vec[1];
+          }
+          return a2;
+        };
+      }();
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js
+  function vec3_transformMat4AsVector(out, a2, m) {
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[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, a2, m) {
+    const x = a2[0];
+    const y = a2[1];
+    out[0] = m[0] * x + m[2] * y;
+    out[1] = m[1] * x + m[3] * y;
+    out[2] = a2[2];
+    return out;
+  }
+  function vec4_transformMat3(out, a2, m) {
+    const x = a2[0];
+    const y = a2[1];
+    const z = a2[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] = a2[3];
+    return out;
+  }
+  var init_gl_matrix_extras = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/lib/gl-matrix-extras.js"() {
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/vec3.js
+  function create2() {
+    var out = new ARRAY_TYPE(3);
+    if (ARRAY_TYPE != Float32Array) {
+      out[0] = 0;
+      out[1] = 0;
+      out[2] = 0;
+    }
+    return out;
+  }
+  function dot(a2, b) {
+    return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
+  }
+  function cross(out, a2, b) {
+    var ax = a2[0], ay = a2[1], az = a2[2];
+    var bx = b[0], by = b[1], bz = b[2];
+    out[0] = ay * bz - az * by;
+    out[1] = az * bx - ax * bz;
+    out[2] = ax * by - ay * bx;
+    return out;
+  }
+  function transformMat4(out, a2, m) {
+    var x = a2[0], y = a2[1], z = a2[2];
+    var w = m[3] * x + m[7] * y + m[11] * z + m[15];
+    w = w || 1;
+    out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;
+    out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;
+    out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
+    return out;
+  }
+  function transformMat32(out, a2, m) {
+    var x = a2[0], y = a2[1], z = a2[2];
+    out[0] = x * m[0] + y * m[3] + z * m[6];
+    out[1] = x * m[1] + y * m[4] + z * m[7];
+    out[2] = x * m[2] + y * m[5] + z * m[8];
+    return out;
+  }
+  function transformQuat(out, a2, q) {
+    var qx = q[0], qy = q[1], qz = q[2], qw = q[3];
+    var x = a2[0], y = a2[1], z = a2[2];
+    var uvx = qy * z - qz * y, uvy = qz * x - qx * z, uvz = qx * y - qy * x;
+    var uuvx = qy * uvz - qz * uvy, uuvy = qz * uvx - qx * uvz, uuvz = qx * uvy - qy * uvx;
+    var w2 = qw * 2;
+    uvx *= w2;
+    uvy *= w2;
+    uvz *= w2;
+    uuvx *= 2;
+    uuvy *= 2;
+    uuvz *= 2;
+    out[0] = x + uvx + uuvx;
+    out[1] = y + uvy + uuvy;
+    out[2] = z + uvz + uuvz;
+    return out;
+  }
+  function rotateX(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[0];
+    r2[1] = p2[1] * Math.cos(rad) - p2[2] * Math.sin(rad);
+    r2[2] = p2[1] * Math.sin(rad) + p2[2] * Math.cos(rad);
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function rotateY(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[2] * Math.sin(rad) + p2[0] * Math.cos(rad);
+    r2[1] = p2[1];
+    r2[2] = p2[2] * Math.cos(rad) - p2[0] * Math.sin(rad);
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function rotateZ(out, a2, b, rad) {
+    var p2 = [], r2 = [];
+    p2[0] = a2[0] - b[0];
+    p2[1] = a2[1] - b[1];
+    p2[2] = a2[2] - b[2];
+    r2[0] = p2[0] * Math.cos(rad) - p2[1] * Math.sin(rad);
+    r2[1] = p2[0] * Math.sin(rad) + p2[1] * Math.cos(rad);
+    r2[2] = p2[2];
+    out[0] = r2[0] + b[0];
+    out[1] = r2[1] + b[1];
+    out[2] = r2[2] + b[2];
+    return out;
+  }
+  function angle(a2, b) {
+    var ax = a2[0], ay = a2[1], az = a2[2], bx = b[0], by = b[1], bz = b[2], mag1 = Math.sqrt(ax * ax + ay * ay + az * az), mag2 = Math.sqrt(bx * bx + by * by + bz * bz), mag = mag1 * mag2, cosine = mag && dot(a2, b) / mag;
+    return Math.acos(Math.min(Math.max(cosine, -1), 1));
+  }
+  var forEach2;
+  var init_vec3 = __esm({
+    "../../node_modules/gl-matrix/esm/vec3.js"() {
+      init_common2();
+      forEach2 = function() {
+        var vec = create2();
+        return function(a2, stride, offset, count, fn, arg) {
+          var i2, l2;
+          if (!stride) {
+            stride = 3;
+          }
+          if (!offset) {
+            offset = 0;
+          }
+          if (count) {
+            l2 = Math.min(count * stride + offset, a2.length);
+          } else {
+            l2 = a2.length;
+          }
+          for (i2 = offset; i2 < l2; i2 += stride) {
+            vec[0] = a2[i2];
+            vec[1] = a2[i2 + 1];
+            vec[2] = a2[i2 + 2];
+            fn(vec, vec, arg);
+            a2[i2] = vec[0];
+            a2[i2 + 1] = vec[1];
+            a2[i2 + 2] = vec[2];
+          }
+          return a2;
+        };
+      }();
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/vector3.js
+  var ORIGIN, constants, Vector3;
+  var init_vector3 = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/vector3.js"() {
+      init_vector();
+      init_common();
+      init_validators();
+      init_vec3();
+      init_gl_matrix_extras();
+      ORIGIN = [0, 0, 0];
+      constants = {};
+      Vector3 = class extends Vector {
+        static get ZERO() {
+          return constants.ZERO = constants.ZERO || Object.freeze(new Vector3(0, 0, 0, 0));
+        }
+        constructor(x = 0, y = 0, z = 0) {
+          super(-0, -0, -0);
+          if (arguments.length === 1 && isArray(x)) {
+            this.copy(x);
+          } else {
+            if (config.debug) {
+              checkNumber(x);
+              checkNumber(y);
+              checkNumber(z);
+            }
+            this[0] = x;
+            this[1] = y;
+            this[2] = z;
+          }
+        }
+        set(x, y, z) {
+          this[0] = x;
+          this[1] = y;
+          this[2] = z;
+          return this.check();
+        }
+        copy(array) {
+          this[0] = array[0];
+          this[1] = array[1];
+          this[2] = array[2];
+          return this.check();
+        }
+        fromObject(object) {
+          if (config.debug) {
+            checkNumber(object.x);
+            checkNumber(object.y);
+            checkNumber(object.z);
+          }
+          this[0] = object.x;
+          this[1] = object.y;
+          this[2] = object.z;
+          return this.check();
+        }
+        toObject(object) {
+          object.x = this[0];
+          object.y = this[1];
+          object.z = this[2];
+          return object;
+        }
+        get ELEMENTS() {
+          return 3;
+        }
+        get z() {
+          return this[2];
+        }
+        set z(value) {
+          this[2] = checkNumber(value);
+        }
+        angle(vector) {
+          return angle(this, vector);
+        }
+        cross(vector) {
+          cross(this, this, vector);
+          return this.check();
+        }
+        rotateX({
+          radians,
+          origin = ORIGIN
+        }) {
+          rotateX(this, this, origin, radians);
+          return this.check();
+        }
+        rotateY({
+          radians,
+          origin = ORIGIN
+        }) {
+          rotateY(this, this, origin, radians);
+          return this.check();
+        }
+        rotateZ({
+          radians,
+          origin = ORIGIN
+        }) {
+          rotateZ(this, this, origin, radians);
+          return this.check();
+        }
+        transform(matrix4) {
+          return this.transformAsPoint(matrix4);
+        }
+        transformAsPoint(matrix4) {
+          transformMat4(this, this, matrix4);
+          return this.check();
+        }
+        transformAsVector(matrix4) {
+          vec3_transformMat4AsVector(this, this, matrix4);
+          return this.check();
+        }
+        transformByMatrix3(matrix3) {
+          transformMat32(this, this, matrix3);
+          return this.check();
+        }
+        transformByMatrix2(matrix2) {
+          vec3_transformMat2(this, this, matrix2);
+          return this.check();
+        }
+        transformByQuaternion(quaternion) {
+          transformQuat(this, this, quaternion);
+          return this.check();
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js
+  var Matrix;
+  var init_matrix = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/base/matrix.js"() {
+      init_math_array();
+      init_validators();
+      init_common();
+      init_assert5();
+      Matrix = class extends MathArray {
+        get ELEMENTS() {
+          assert5(false);
+          return 0;
+        }
+        get RANK() {
+          assert5(false);
+          return 0;
+        }
+        toString() {
+          let string = "[";
+          if (config.printRowMajor) {
+            string += "row-major:";
+            for (let row = 0; row < this.RANK; ++row) {
+              for (let col = 0; col < this.RANK; ++col) {
+                string += " ".concat(this[col * this.RANK + row]);
+              }
+            }
+          } else {
+            string += "column-major:";
+            for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
+              string += " ".concat(this[i2]);
+            }
+          }
+          string += "]";
+          return string;
+        }
+        getElementIndex(row, col) {
+          return col * this.RANK + row;
+        }
+        getElement(row, col) {
+          return this[col * this.RANK + row];
+        }
+        setElement(row, col, value) {
+          this[col * this.RANK + row] = checkNumber(value);
+          return this;
+        }
+        getColumn(columnIndex, result = new Array(this.RANK).fill(-0)) {
+          const firstIndex = columnIndex * this.RANK;
+          for (let i2 = 0; i2 < this.RANK; ++i2) {
+            result[i2] = this[firstIndex + i2];
+          }
+          return result;
+        }
+        setColumn(columnIndex, columnVector) {
+          const firstIndex = columnIndex * this.RANK;
+          for (let i2 = 0; i2 < this.RANK; ++i2) {
+            this[firstIndex + i2] = columnVector[i2];
+          }
+          return this;
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/gl-matrix/esm/mat3.js
+  function transpose(out, a2) {
+    if (out === a2) {
+      var a01 = a2[1], a02 = a2[2], a12 = a2[5];
+      out[1] = a2[3];
+      out[2] = a2[6];
+      out[3] = a01;
+      out[5] = a2[7];
+      out[6] = a02;
+      out[7] = a12;
+    } else {
+      out[0] = a2[0];
+      out[1] = a2[3];
+      out[2] = a2[6];
+      out[3] = a2[1];
+      out[4] = a2[4];
+      out[5] = a2[7];
+      out[6] = a2[2];
+      out[7] = a2[5];
+      out[8] = a2[8];
+    }
+    return out;
+  }
+  function invert(out, a2) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2];
+    var a10 = a2[3], a11 = a2[4], a12 = a2[5];
+    var a20 = a2[6], a21 = a2[7], a22 = a2[8];
+    var b01 = a22 * a11 - a12 * a21;
+    var b11 = -a22 * a10 + a12 * a20;
+    var b21 = a21 * a10 - a11 * a20;
+    var det = a00 * b01 + a01 * b11 + a02 * b21;
+    if (!det) {
+      return null;
+    }
+    det = 1 / det;
+    out[0] = b01 * det;
+    out[1] = (-a22 * a01 + a02 * a21) * det;
+    out[2] = (a12 * a01 - a02 * a11) * det;
+    out[3] = b11 * det;
+    out[4] = (a22 * a00 - a02 * a20) * det;
+    out[5] = (-a12 * a00 + a02 * a10) * det;
+    out[6] = b21 * det;
+    out[7] = (-a21 * a00 + a01 * a20) * det;
+    out[8] = (a11 * a00 - a01 * a10) * det;
+    return out;
+  }
+  function determinant(a2) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2];
+    var a10 = a2[3], a11 = a2[4], a12 = a2[5];
+    var a20 = a2[6], a21 = a2[7], a22 = a2[8];
+    return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
+  }
+  function multiply(out, a2, b) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2];
+    var a10 = a2[3], a11 = a2[4], a12 = a2[5];
+    var a20 = a2[6], a21 = a2[7], a22 = a2[8];
+    var b00 = b[0], b01 = b[1], b02 = b[2];
+    var b10 = b[3], b11 = b[4], b12 = b[5];
+    var b20 = b[6], b21 = b[7], b22 = b[8];
+    out[0] = b00 * a00 + b01 * a10 + b02 * a20;
+    out[1] = b00 * a01 + b01 * a11 + b02 * a21;
+    out[2] = b00 * a02 + b01 * a12 + b02 * a22;
+    out[3] = b10 * a00 + b11 * a10 + b12 * a20;
+    out[4] = b10 * a01 + b11 * a11 + b12 * a21;
+    out[5] = b10 * a02 + b11 * a12 + b12 * a22;
+    out[6] = b20 * a00 + b21 * a10 + b22 * a20;
+    out[7] = b20 * a01 + b21 * a11 + b22 * a21;
+    out[8] = b20 * a02 + b21 * a12 + b22 * a22;
+    return out;
+  }
+  function translate(out, a2, v) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a10 = a2[3], a11 = a2[4], a12 = a2[5], a20 = a2[6], a21 = a2[7], a22 = a2[8], x = v[0], y = v[1];
+    out[0] = a00;
+    out[1] = a01;
+    out[2] = a02;
+    out[3] = a10;
+    out[4] = a11;
+    out[5] = a12;
+    out[6] = x * a00 + y * a10 + a20;
+    out[7] = x * a01 + y * a11 + a21;
+    out[8] = x * a02 + y * a12 + a22;
+    return out;
+  }
+  function rotate(out, a2, rad) {
+    var a00 = a2[0], a01 = a2[1], a02 = a2[2], a10 = a2[3], a11 = a2[4], a12 = a2[5], a20 = a2[6], a21 = a2[7], a22 = a2[8], s2 = Math.sin(rad), c = Math.cos(rad);
+    out[0] = c * a00 + s2 * a10;
+    out[1] = c * a01 + s2 * a11;
+    out[2] = c * a02 + s2 * a12;
+    out[3] = c * a10 - s2 * a00;
+    out[4] = c * a11 - s2 * a01;
+    out[5] = c * a12 - s2 * a02;
+    out[6] = a20;
+    out[7] = a21;
+    out[8] = a22;
+    return out;
+  }
+  function scale(out, a2, v) {
+    var x = v[0], y = v[1];
+    out[0] = x * a2[0];
+    out[1] = x * a2[1];
+    out[2] = x * a2[2];
+    out[3] = y * a2[3];
+    out[4] = y * a2[4];
+    out[5] = y * a2[5];
+    out[6] = a2[6];
+    out[7] = a2[7];
+    out[8] = a2[8];
+    return out;
+  }
+  function fromQuat(out, q) {
+    var x = q[0], y = q[1], z = q[2], w = q[3];
+    var x2 = x + x;
+    var y2 = y + y;
+    var z2 = z + z;
+    var xx = x * x2;
+    var yx = y * x2;
+    var yy = y * y2;
+    var zx = z * x2;
+    var zy = z * y2;
+    var zz = z * z2;
+    var wx = w * x2;
+    var wy = w * y2;
+    var wz = w * z2;
+    out[0] = 1 - yy - zz;
+    out[3] = yx - wz;
+    out[6] = zx + wy;
+    out[1] = yx + wz;
+    out[4] = 1 - xx - zz;
+    out[7] = zy - wx;
+    out[2] = zx - wy;
+    out[5] = zy + wx;
+    out[8] = 1 - xx - yy;
+    return out;
+  }
+  var init_mat3 = __esm({
+    "../../node_modules/gl-matrix/esm/mat3.js"() {
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/classes/matrix3.js
+  var IDENTITY, ZERO, INDICES, constants2, Matrix3;
+  var init_matrix3 = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/classes/matrix3.js"() {
+      init_matrix();
+      init_validators();
+      init_gl_matrix_extras();
+      init_mat3();
+      init_vec2();
+      init_vec3();
+      IDENTITY = Object.freeze([1, 0, 0, 0, 1, 0, 0, 0, 1]);
+      ZERO = Object.freeze([0, 0, 0, 0, 0, 0, 0, 0, 0]);
+      INDICES = Object.freeze({
+        COL0ROW0: 0,
+        COL0ROW1: 1,
+        COL0ROW2: 2,
+        COL1ROW0: 3,
+        COL1ROW1: 4,
+        COL1ROW2: 5,
+        COL2ROW0: 6,
+        COL2ROW1: 7,
+        COL2ROW2: 8
+      });
+      constants2 = {};
+      Matrix3 = class extends Matrix {
+        static get IDENTITY() {
+          constants2.IDENTITY = constants2.IDENTITY || Object.freeze(new Matrix3(IDENTITY));
+          return constants2.IDENTITY;
+        }
+        static get ZERO() {
+          constants2.ZERO = constants2.ZERO || Object.freeze(new Matrix3(ZERO));
+          return constants2.ZERO;
+        }
+        get ELEMENTS() {
+          return 9;
+        }
+        get RANK() {
+          return 3;
+        }
+        get INDICES() {
+          return INDICES;
+        }
+        constructor(array) {
+          super(-0, -0, -0, -0, -0, -0, -0, -0, -0);
+          if (arguments.length === 1 && Array.isArray(array)) {
+            this.copy(array);
+          } else {
+            this.identity();
+          }
+        }
+        copy(array) {
+          this[0] = array[0];
+          this[1] = array[1];
+          this[2] = array[2];
+          this[3] = array[3];
+          this[4] = array[4];
+          this[5] = array[5];
+          this[6] = array[6];
+          this[7] = array[7];
+          this[8] = array[8];
+          return this.check();
+        }
+        set(m00, m10, m20, m01, m11, m21, m02, m12, m22) {
+          this[0] = m00;
+          this[1] = m10;
+          this[2] = m20;
+          this[3] = m01;
+          this[4] = m11;
+          this[5] = m21;
+          this[6] = m02;
+          this[7] = m12;
+          this[8] = m22;
+          return this.check();
+        }
+        setRowMajor(m00, m01, m02, m10, m11, m12, m20, m21, m22) {
+          this[0] = m00;
+          this[1] = m10;
+          this[2] = m20;
+          this[3] = m01;
+          this[4] = m11;
+          this[5] = m21;
+          this[6] = m02;
+          this[7] = m12;
+          this[8] = m22;
+          return this.check();
+        }
+        determinant() {
+          return determinant(this);
+        }
+        identity() {
+          return this.copy(IDENTITY);
+        }
+        fromQuaternion(q) {
+          fromQuat(this, q);
+          return this.check();
+        }
+        transpose() {
+          transpose(this, this);
+          return this.check();
+        }
+        invert() {
+          invert(this, this);
+          return this.check();
+        }
+        multiplyLeft(a2) {
+          multiply(this, a2, this);
+          return this.check();
+        }
+        multiplyRight(a2) {
+          multiply(this, this, a2);
+          return this.check();
+        }
+        rotate(radians) {
+          rotate(this, this, radians);
+          return this.check();
+        }
+        scale(factor) {
+          if (Array.isArray(factor)) {
+            scale(this, this, factor);
+          } else {
+            scale(this, this, [factor, factor, factor]);
+          }
+          return this.check();
+        }
+        translate(vec) {
+          translate(this, this, vec);
+          return this.check();
+        }
+        transform(vector, result) {
+          switch (vector.length) {
+            case 2:
+              result = transformMat3(result || [-0, -0], vector, this);
+              break;
+            case 3:
+              result = transformMat32(result || [-0, -0, -0], vector, this);
+              break;
+            case 4:
+              result = vec4_transformMat3(result || [-0, -0, -0, -0], vector, this);
+              break;
+            default:
+              throw new Error("Illegal vector");
+          }
+          checkVector(result, vector.length);
+          return result;
+        }
+        transformVector(vector, result) {
+          deprecated("Matrix3.transformVector");
+          return this.transform(vector, result);
+        }
+        transformVector2(vector, result) {
+          deprecated("Matrix3.transformVector");
+          return this.transform(vector, result);
+        }
+        transformVector3(vector, result) {
+          deprecated("Matrix3.transformVector");
+          return this.transform(vector, result);
+        }
+      };
+    }
+  });
+
+  // ../../node_modules/@math.gl/core/dist/esm/index.js
+  var globals3, global_3;
+  var init_esm = __esm({
+    "../../node_modules/@math.gl/core/dist/esm/index.js"() {
+      init_common();
+      init_vector3();
+      init_matrix3();
+      globals3 = {
+        self: typeof self !== "undefined" && self,
+        window: typeof window !== "undefined" && window,
+        global: typeof global !== "undefined" && global
+      };
+      global_3 = globals3.global || globals3.self || globals3.window;
+      global_3.mathgl = {
+        config
+      };
+    }
+  });
+
+  // src/lib/gltf-utils/gltf-constants.ts
+  var COMPONENTS, BYTES;
+  var init_gltf_constants = __esm({
+    "src/lib/gltf-utils/gltf-constants.ts"() {
+      COMPONENTS = {
+        SCALAR: 1,
+        VEC2: 2,
+        VEC3: 3,
+        VEC4: 4,
+        MAT2: 4,
+        MAT3: 9,
+        MAT4: 16
+      };
+      BYTES = {
+        5120: 1,
+        5121: 1,
+        5122: 2,
+        5123: 2,
+        5125: 4,
+        5126: 4
+      };
+    }
+  });
+
+  // src/lib/extensions/KHR_texture_transform.ts
+  var KHR_texture_transform_exports = {};
+  __export(KHR_texture_transform_exports, {
+    decode: () => decode4,
+    name: () => name5
+  });
+  async function decode4(gltfData, options) {
+    const gltfScenegraph = new GLTFScenegraph(gltfData);
+    const extension = gltfScenegraph.getExtension(EXT_MESHOPT_TRANSFORM);
+    if (!extension) {
+      return;
+    }
+    const materials = gltfData.json.materials || [];
+    for (let i2 = 0; i2 < materials.length; i2++) {
+      transformTexCoords(i2, gltfData);
+    }
+  }
+  function transformTexCoords(materialIndex, gltfData) {
+    const processedTexCoords = [];
+    const material = gltfData.json.materials?.[materialIndex];
+    const baseColorTexture = material?.pbrMetallicRoughness?.baseColorTexture;
+    if (baseColorTexture) {
+      transformPrimitives(gltfData, materialIndex, baseColorTexture, processedTexCoords);
+    }
+    const emisiveTexture = material?.emissiveTexture;
+    if (emisiveTexture) {
+      transformPrimitives(gltfData, materialIndex, emisiveTexture, processedTexCoords);
+    }
+    const normalTexture = material?.normalTexture;
+    if (normalTexture) {
+      transformPrimitives(gltfData, materialIndex, normalTexture, processedTexCoords);
+    }
+    const occlusionTexture = material?.occlusionTexture;
+    if (occlusionTexture) {
+      transformPrimitives(gltfData, materialIndex, occlusionTexture, processedTexCoords);
+    }
+    const metallicRoughnessTexture = material?.pbrMetallicRoughness?.metallicRoughnessTexture;
+    if (metallicRoughnessTexture) {
+      transformPrimitives(gltfData, materialIndex, metallicRoughnessTexture, processedTexCoords);
+    }
+  }
+  function transformPrimitives(gltfData, materialIndex, texture, processedTexCoords) {
+    const transformParameters = getTransformParameters(texture, processedTexCoords);
+    if (!transformParameters) {
+      return;
+    }
+    const meshes = gltfData.json.meshes || [];
+    for (const mesh of meshes) {
+      for (const primitive of mesh.primitives) {
+        const material = primitive.material;
+        if (Number.isFinite(material) && materialIndex === material) {
+          transformPrimitive(gltfData, primitive, transformParameters);
+        }
+      }
+    }
+  }
+  function getTransformParameters(texture, processedTexCoords) {
+    const textureInfo = texture.extensions?.[EXT_MESHOPT_TRANSFORM];
+    const { texCoord: originalTexCoord = 0 } = texture;
+    const { texCoord = originalTexCoord } = textureInfo;
+    const isProcessed = processedTexCoords.findIndex(([original, newTexCoord]) => original === originalTexCoord && newTexCoord === texCoord) !== -1;
+    if (!isProcessed) {
+      const matrix = makeTransformationMatrix(textureInfo);
+      if (originalTexCoord !== texCoord) {
+        texture.texCoord = texCoord;
+      }
+      processedTexCoords.push([originalTexCoord, texCoord]);
+      return { originalTexCoord, texCoord, matrix };
+    }
+    return null;
+  }
+  function transformPrimitive(gltfData, primitive, transformParameters) {
+    const { originalTexCoord, texCoord, matrix } = transformParameters;
+    const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];
+    if (Number.isFinite(texCoordAccessor)) {
+      const accessor = gltfData.json.accessors?.[texCoordAccessor];
+      if (accessor && accessor.bufferView) {
+        const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
+        if (bufferView) {
+          const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
+          const byteOffset = (bufferByteOffset || 0) + (accessor.byteOffset || 0) + (bufferView.byteOffset || 0);
+          const { ArrayType, length } = getAccessorArrayTypeAndLength(accessor, bufferView);
+          const bytes = BYTES[accessor.componentType];
+          const components = COMPONENTS[accessor.type];
+          const elementAddressScale = bufferView.byteStride || bytes * components;
+          const result = new Float32Array(length);
+          for (let i2 = 0; i2 < accessor.count; i2++) {
+            const uv = new ArrayType(arrayBuffer, byteOffset + i2 * elementAddressScale, 2);
+            scratchVector.set(uv[0], uv[1], 1);
+            scratchVector.transformByMatrix3(matrix);
+            result.set([scratchVector[0], scratchVector[1]], i2 * components);
+          }
+          if (originalTexCoord === texCoord) {
+            updateGltf(accessor, bufferView, gltfData.buffers, result);
+          } else {
+            createAttribute(texCoord, accessor, primitive, gltfData, result);
+          }
+        }
+      }
+    }
+  }
+  function updateGltf(accessor, bufferView, buffers, newTexCoordArray) {
+    accessor.componentType = 5126;
+    buffers.push({
+      arrayBuffer: newTexCoordArray.buffer,
+      byteOffset: 0,
+      byteLength: newTexCoordArray.buffer.byteLength
+    });
+    bufferView.buffer = buffers.length - 1;
+    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+    bufferView.byteOffset = 0;
+    delete bufferView.byteStride;
+  }
+  function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, newTexCoordArray) {
+    gltfData.buffers.push({
+      arrayBuffer: newTexCoordArray.buffer,
+      byteOffset: 0,
+      byteLength: newTexCoordArray.buffer.byteLength
+    });
+    const bufferViews = gltfData.json.bufferViews;
+    if (!bufferViews) {
+      return;
+    }
+    bufferViews.push({
+      buffer: gltfData.buffers.length - 1,
+      byteLength: newTexCoordArray.buffer.byteLength,
+      byteOffset: 0
+    });
+    const accessors = gltfData.json.accessors;
+    if (!accessors) {
+      return;
+    }
+    accessors.push({
+      bufferView: bufferViews?.length - 1,
+      byteOffset: 0,
+      componentType: 5126,
+      count: originalAccessor.count,
+      type: "VEC2"
+    });
+    primitive.attributes[`TEXCOORD_${newTexCoord}`] = accessors.length - 1;
+  }
+  function makeTransformationMatrix(extensionData) {
+    const { offset = [0, 0], rotation = 0, scale: scale2 = [1, 1] } = extensionData;
+    const translationMatirx = new Matrix3().set(1, 0, 0, 0, 1, 0, offset[0], offset[1], 1);
+    const rotationMatirx = scratchRotationMatrix.set(Math.cos(rotation), Math.sin(rotation), 0, -Math.sin(rotation), Math.cos(rotation), 0, 0, 0, 1);
+    const scaleMatrix = scratchScaleMatrix.set(scale2[0], 0, 0, 0, scale2[1], 0, 0, 0, 1);
+    return translationMatirx.multiplyRight(rotationMatirx).multiplyRight(scaleMatrix);
+  }
+  var EXT_MESHOPT_TRANSFORM, name5, scratchVector, scratchRotationMatrix, scratchScaleMatrix;
+  var init_KHR_texture_transform = __esm({
+    "src/lib/extensions/KHR_texture_transform.ts"() {
+      init_esm();
+      init_gltf_utils();
+      init_gltf_constants();
+      init_gltf_scenegraph();
+      EXT_MESHOPT_TRANSFORM = "KHR_texture_transform";
+      name5 = EXT_MESHOPT_TRANSFORM;
+      scratchVector = new Vector3();
+      scratchRotationMatrix = new Matrix3();
+      scratchScaleMatrix = new Matrix3();
+    }
+  });
+
   // src/lib/extensions/deprecated/KHR_lights_punctual.ts
   var KHR_lights_punctual_exports = {};
   __export(KHR_lights_punctual_exports, {
-    decode: () => decode4,
+    decode: () => decode5,
     encode: () => encode2,
-    name: () => name5
+    name: () => name6
   });
-  async function decode4(gltfData) {
+  async function decode5(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     const extension = gltfScenegraph.getExtension(KHR_LIGHTS_PUNCTUAL);
@@ -3341,24 +4708,24 @@
       delete gltfScenegraph.json.lights;
     }
   }
-  var KHR_LIGHTS_PUNCTUAL, name5;
+  var KHR_LIGHTS_PUNCTUAL, name6;
   var init_KHR_lights_punctual = __esm({
     "src/lib/extensions/deprecated/KHR_lights_punctual.ts"() {
       init_assert3();
       init_gltf_scenegraph();
       KHR_LIGHTS_PUNCTUAL = "KHR_lights_punctual";
-      name5 = KHR_LIGHTS_PUNCTUAL;
+      name6 = KHR_LIGHTS_PUNCTUAL;
     }
   });
 
   // src/lib/extensions/deprecated/KHR_materials_unlit.ts
   var KHR_materials_unlit_exports = {};
   __export(KHR_materials_unlit_exports, {
-    decode: () => decode5,
+    decode: () => decode6,
     encode: () => encode3,
-    name: () => name6
+    name: () => name7
   });
-  async function decode5(gltfData) {
+  async function decode6(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     gltfScenegraph.removeExtension(KHR_MATERIALS_UNLIT);
@@ -3383,23 +4750,23 @@
       }
     }
   }
-  var KHR_MATERIALS_UNLIT, name6;
+  var KHR_MATERIALS_UNLIT, name7;
   var init_KHR_materials_unlit = __esm({
     "src/lib/extensions/deprecated/KHR_materials_unlit.ts"() {
       init_gltf_scenegraph();
       KHR_MATERIALS_UNLIT = "KHR_materials_unlit";
-      name6 = KHR_MATERIALS_UNLIT;
+      name7 = KHR_MATERIALS_UNLIT;
     }
   });
 
   // src/lib/extensions/deprecated/KHR_techniques_webgl.ts
   var KHR_techniques_webgl_exports = {};
   __export(KHR_techniques_webgl_exports, {
-    decode: () => decode6,
+    decode: () => decode7,
     encode: () => encode4,
-    name: () => name7
+    name: () => name8
   });
-  async function decode6(gltfData) {
+  async function decode7(gltfData) {
     const gltfScenegraph = new GLTFScenegraph(gltfData);
     const { json } = gltfScenegraph;
     const extension = gltfScenegraph.getExtension(KHR_TECHNIQUES_WEBGL);
@@ -3451,12 +4818,97 @@
     });
     return values;
   }
-  var KHR_TECHNIQUES_WEBGL, name7;
+  var KHR_TECHNIQUES_WEBGL, name8;
   var init_KHR_techniques_webgl = __esm({
     "src/lib/extensions/deprecated/KHR_techniques_webgl.ts"() {
       init_gltf_scenegraph();
       KHR_TECHNIQUES_WEBGL = "KHR_techniques_webgl";
-      name7 = KHR_TECHNIQUES_WEBGL;
+      name8 = KHR_TECHNIQUES_WEBGL;
+    }
+  });
+
+  // src/lib/extensions/deprecated/EXT_feature_metadata.ts
+  var EXT_feature_metadata_exports = {};
+  __export(EXT_feature_metadata_exports, {
+    decode: () => decode8,
+    name: () => name9
+  });
+  async function decode8(gltfData) {
+    const scenegraph = new GLTFScenegraph(gltfData);
+    decodeExtFeatureMetadata(scenegraph);
+  }
+  function decodeExtFeatureMetadata(scenegraph) {
+    const extension = scenegraph.getExtension(EXT_FEATURE_METADATA);
+    const schemaClasses = extension?.schema?.classes;
+    const featureTables = extension?.featureTables;
+    const featureTextures = extension?.featureTextures;
+    if (featureTextures) {
+      console.warn('featureTextures is not yet supported in the "EXT_feature_metadata" extension.');
+    }
+    if (schemaClasses && featureTables) {
+      for (const schemaName in schemaClasses) {
+        const schemaClass = schemaClasses[schemaName];
+        const featureTable = findFeatureTableByName(featureTables, schemaName);
+        if (featureTable) {
+          handleFeatureTableProperties(scenegraph, featureTable, schemaClass);
+        }
+      }
+    }
+  }
+  function handleFeatureTableProperties(scenegraph, featureTable, schemaClass) {
+    for (const propertyName in schemaClass.properties) {
+      const schemaProperty = schemaClass.properties[propertyName];
+      const featureTableProperty = featureTable?.properties?.[propertyName];
+      const numberOfFeatures = featureTable.count;
+      if (featureTableProperty) {
+        const data = getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty);
+        featureTableProperty.data = data;
+      }
+    }
+  }
+  function getPropertyDataFromBinarySource(scenegraph, schemaProperty, numberOfFeatures, featureTableProperty) {
+    const bufferView = featureTableProperty.bufferView;
+    let data = scenegraph.getTypedArrayForBufferView(bufferView);
+    switch (schemaProperty.type) {
+      case "STRING": {
+        const stringOffsetBufferView = featureTableProperty.stringOffsetBufferView;
+        const offsetsData = scenegraph.getTypedArrayForBufferView(stringOffsetBufferView);
+        data = getStringAttributes(data, offsetsData, numberOfFeatures);
+        break;
+      }
+      default:
+    }
+    return data;
+  }
+  function findFeatureTableByName(featureTables, schemaClassName) {
+    for (const featureTableName in featureTables) {
+      const featureTable = featureTables[featureTableName];
+      if (featureTable.class === schemaClassName) {
+        return featureTable;
+      }
+    }
+    return null;
+  }
+  function getStringAttributes(data, offsetsData, stringsCount) {
+    const stringsArray = [];
+    const textDecoder = new TextDecoder("utf8");
+    let stringOffset = 0;
+    const bytesPerStringSize = 4;
+    for (let index = 0; index < stringsCount; index++) {
+      const stringByteSize = offsetsData[(index + 1) * bytesPerStringSize] - offsetsData[index * bytesPerStringSize];
+      const stringData = data.subarray(stringOffset, stringByteSize + stringOffset);
+      const stringAttribute = textDecoder.decode(stringData);
+      stringsArray.push(stringAttribute);
+      stringOffset += stringByteSize;
+    }
+    return stringsArray;
+  }
+  var EXT_FEATURE_METADATA, name9;
+  var init_EXT_feature_metadata = __esm({
+    "src/lib/extensions/deprecated/EXT_feature_metadata.ts"() {
+      init_gltf_scenegraph();
+      EXT_FEATURE_METADATA = "EXT_feature_metadata";
+      name9 = EXT_FEATURE_METADATA;
     }
   });
 
@@ -3485,9 +4937,11 @@
       init_EXT_texture_webp();
       init_KHR_texture_basisu();
       init_KHR_draco_mesh_compression();
+      init_KHR_texture_transform();
       init_KHR_lights_punctual();
       init_KHR_materials_unlit();
       init_KHR_techniques_webgl();
+      init_EXT_feature_metadata();
       EXTENSIONS2 = [
         EXT_meshopt_compression_exports,
         EXT_texture_webp_exports,
@@ -3495,7 +4949,9 @@
         KHR_draco_mesh_compression_exports,
         KHR_lights_punctual_exports,
         KHR_materials_unlit_exports,
-        KHR_techniques_webgl_exports
+        KHR_techniques_webgl_exports,
+        KHR_texture_transform_exports,
+        EXT_feature_metadata_exports
       ];
     }
   });
@@ -3726,20 +5182,20 @@
 
   // src/lib/api/post-process-gltf.ts
   function getBytesFromComponentType(componentType) {
-    return BYTES[componentType];
+    return BYTES2[componentType];
   }
   function getSizeFromAccessorType(type) {
-    return COMPONENTS[type];
+    return COMPONENTS2[type];
   }
   function postProcessGLTF(gltf, options) {
     return new GLTFPostProcessor().postProcess(gltf, options);
   }
-  var COMPONENTS, BYTES, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER, GLTFPostProcessor;
+  var COMPONENTS2, BYTES2, GL_SAMPLER, SAMPLER_PARAMETER_GLTF_TO_GL, DEFAULT_SAMPLER, GLTFPostProcessor;
   var init_post_process_gltf = __esm({
     "src/lib/api/post-process-gltf.ts"() {
       init_assert3();
       init_gltf_utils();
-      COMPONENTS = {
+      COMPONENTS2 = {
         SCALAR: 1,
         VEC2: 2,
         VEC3: 3,
@@ -3748,7 +5204,7 @@
         MAT3: 9,
         MAT4: 16
       };
-      BYTES = {
+      BYTES2 = {
         5120: 1,
         5121: 1,
         5122: 2,