@loaders.gl/gltf 4.3.0-alpha.3 → 4.3.0-alpha.4

package/dist/dist.dev.js

@@ -261,8 +261,8 @@ var __exports__ = (() => {
     }
     const dataView = new DataView(arrayBuffer);
     let magic = "";
-    for (let i2 = 0; i2 < length; i2++) {
-      magic += String.fromCharCode(dataView.getUint8(byteOffset + i2));
+    for (let i = 0; i < length; i++) {
+      magic += String.fromCharCode(dataView.getUint8(byteOffset + i));
     }
     return magic;
   }
@@ -314,8 +314,8 @@ var __exports__ = (() => {
       );
       const sourceArray = new Uint8Array(sourceBuffer);
       targetArray.set(sourceArray);
-      for (let i2 = 0; i2 < padLength; ++i2) {
-        dataView.setUint8(byteOffset + sourceBuffer.byteLength + i2, 32);
+      for (let i = 0; i < padLength; ++i) {
+        dataView.setUint8(byteOffset + sourceBuffer.byteLength + i, 32);
       }
     }
     byteOffset += paddedLength;
@@ -526,8 +526,8 @@ var __exports__ = (() => {
   }
   function checkString(buffer, header, offset = 0) {
     const headerBytes = stringToBytes(header);
-    for (let i2 = 0; i2 < headerBytes.length; ++i2) {
-      if (headerBytes[i2] !== buffer[i2 + offset]) {
+    for (let i = 0; i < headerBytes.length; ++i) {
+      if (headerBytes[i] !== buffer[i + offset]) {
         return false;
       }
     }
@@ -597,30 +597,30 @@ var __exports__ = (() => {
       return null;
     }
     const { tableMarkers, sofMarkers } = getJpegMarkers();
-    let i2 = 2;
-    while (i2 + 9 < dataView.byteLength) {
-      const marker = dataView.getUint16(i2, BIG_ENDIAN);
+    let i = 2;
+    while (i + 9 < dataView.byteLength) {
+      const marker = dataView.getUint16(i, BIG_ENDIAN);
       if (sofMarkers.has(marker)) {
         return {
           mimeType: "image/jpeg",
-          height: dataView.getUint16(i2 + 5, BIG_ENDIAN),
+          height: dataView.getUint16(i + 5, BIG_ENDIAN),
           // Number of lines
-          width: dataView.getUint16(i2 + 7, BIG_ENDIAN)
+          width: dataView.getUint16(i + 7, BIG_ENDIAN)
           // Number of pixels per line
         };
       }
       if (!tableMarkers.has(marker)) {
         return null;
       }
-      i2 += 2;
-      i2 += dataView.getUint16(i2, BIG_ENDIAN);
+      i += 2;
+      i += dataView.getUint16(i, BIG_ENDIAN);
     }
     return null;
   }
   function getJpegMarkers() {
     const tableMarkers = /* @__PURE__ */ new Set([65499, 65476, 65484, 65501, 65534]);
-    for (let i2 = 65504; i2 < 65520; ++i2) {
-      tableMarkers.add(i2);
+    for (let i = 65504; i < 65520; ++i) {
+      tableMarkers.add(i);
     }
     const sofMarkers = /* @__PURE__ */ new Set([
       65472,
@@ -865,7 +865,7 @@ var __exports__ = (() => {
     let { images, bufferViews } = gltf;
     images = images || [];
     bufferViews = bufferViews || [];
-    const imageBufferViews = images.map((i2) => i2.bufferView);
+    const imageBufferViews = images.map((i) => i.bufferView);
     bufferViews = bufferViews.filter((view) => !imageBufferViews.includes(view));
     const bufferMemory = bufferViews.reduce((acc, view) => acc + view.byteLength, 0);
     const pixelCount = images.reduce((acc, image) => {
@@ -904,13 +904,13 @@ var __exports__ = (() => {
       return result2;
     }
     const result = new ArrayType(length);
-    for (let i2 = 0; i2 < gltfAccessor.count; i2++) {
+    for (let i = 0; i < gltfAccessor.count; i++) {
       const values = new ArrayType(
         arrayBuffer,
-        byteOffset + i2 * elementAddressScale,
+        byteOffset + i * elementAddressScale,
         numberOfComponentsInElement
       );
-      result.set(values, i2 * numberOfComponentsInElement);
+      result.set(values, i * numberOfComponentsInElement);
     }
     return result;
   }
@@ -1441,8 +1441,8 @@ var __exports__ = (() => {
   };
 
   // src/lib/extensions/utils/3d-tiles-utils.ts
-  function emod(n2) {
-    return (n2 % 1 + 1) % 1;
+  function emod(n) {
+    return (n % 1 + 1) % 1;
   }
   var ATTRIBUTE_TYPE_TO_COMPONENTS2 = {
     SCALAR: 1,
@@ -2013,11 +2013,11 @@ var __exports__ = (() => {
   }
   function getEnumsArray(valuesData, offset, count, enumEntry) {
     const array = [];
-    for (let i2 = 0; i2 < count; i2++) {
+    for (let i = 0; i < count; i++) {
       if (valuesData instanceof BigInt64Array || valuesData instanceof BigUint64Array) {
         array.push("");
       } else {
-        const value = valuesData[offset + i2];
+        const value = valuesData[offset + i];
         const enumObject = getEnumByValue(enumEntry, value);
         if (enumObject) {
           array.push(enumObject.name);
@@ -2476,34 +2476,6 @@ var __exports__ = (() => {
     }
   }
 
-  // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
-  var t = new Uint8Array([0]);
-  var n;
-  var i;
-  var s;
-  var a;
-  var r;
-  var o;
-  var l;
-  var f;
-  !function(t2) {
-    t2[t2.NONE = 0] = "NONE", t2[t2.BASISLZ = 1] = "BASISLZ", t2[t2.ZSTD = 2] = "ZSTD", t2[t2.ZLIB = 3] = "ZLIB";
-  }(n || (n = {})), function(t2) {
-    t2[t2.BASICFORMAT = 0] = "BASICFORMAT";
-  }(i || (i = {})), function(t2) {
-    t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.ETC1S = 163] = "ETC1S", t2[t2.UASTC = 166] = "UASTC";
-  }(s || (s = {})), function(t2) {
-    t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.SRGB = 1] = "SRGB";
-  }(a || (a = {})), function(t2) {
-    t2[t2.UNSPECIFIED = 0] = "UNSPECIFIED", t2[t2.LINEAR = 1] = "LINEAR", t2[t2.SRGB = 2] = "SRGB", t2[t2.ITU = 3] = "ITU", t2[t2.NTSC = 4] = "NTSC", t2[t2.SLOG = 5] = "SLOG", t2[t2.SLOG2 = 6] = "SLOG2";
-  }(r || (r = {})), function(t2) {
-    t2[t2.ALPHA_STRAIGHT = 0] = "ALPHA_STRAIGHT", t2[t2.ALPHA_PREMULTIPLIED = 1] = "ALPHA_PREMULTIPLIED";
-  }(o || (o = {})), function(t2) {
-    t2[t2.RGB = 0] = "RGB", t2[t2.RRR = 3] = "RRR", t2[t2.GGG = 4] = "GGG", t2[t2.AAA = 15] = "AAA";
-  }(l || (l = {})), function(t2) {
-    t2[t2.RGB = 0] = "RGB", t2[t2.RGBA = 3] = "RGBA", t2[t2.RRR = 4] = "RRR", t2[t2.RRRG = 5] = "RRRG";
-  }(f || (f = {}));
-
   // ../textures/src/lib/parsers/parse-ktx.ts
   var KTX2_ID = [
     // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
@@ -2662,7 +2634,6 @@ var __exports__ = (() => {
       const levels = [];
       for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
         levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
-        break;
       }
       return [levels];
     } finally {
@@ -3066,13 +3037,13 @@ var __exports__ = (() => {
   }
   function unpack(data) {
     const result = new Uint8Array(data.length);
-    for (let i2 = 0; i2 < data.length; ++i2) {
-      const ch = data.charCodeAt(i2);
-      result[i2] = ch > 96 ? ch - 71 : ch > 64 ? ch - 65 : ch > 47 ? ch + 4 : ch > 46 ? 63 : 62;
+    for (let i = 0; i < data.length; ++i) {
+      const ch = data.charCodeAt(i);
+      result[i] = ch > 96 ? ch - 71 : ch > 64 ? ch - 65 : ch > 47 ? ch + 4 : ch > 46 ? 63 : 62;
     }
     let write = 0;
-    for (let i2 = 0; i2 < data.length; ++i2) {
-      result[write++] = result[i2] < 60 ? wasmpack[result[i2]] : (result[i2] - 60) * 64 + result[++i2];
+    for (let i = 0; i < data.length; ++i) {
+      result[write++] = result[i] < 60 ? wasmpack[result[i]] : (result[i] - 60) * 64 + result[++i];
     }
     return result.buffer.slice(0, write);
   }
@@ -3262,10 +3233,10 @@ var __exports__ = (() => {
     let maxZ = -Infinity;
     const positions = attributes.POSITION ? attributes.POSITION.value : [];
     const len = positions && positions.length;
-    for (let i2 = 0; i2 < len; i2 += 3) {
-      const x = positions[i2];
-      const y = positions[i2 + 1];
-      const z = positions[i2 + 2];
+    for (let i = 0; i < len; i += 3) {
+      const x = positions[i];
+      const y = positions[i + 1];
+      const z = positions[i + 2];
       minX = x < minX ? x : minX;
       minY = y < minY ? y : minY;
       minZ = z < minZ ? z : minZ;
@@ -3733,7 +3704,7 @@ var __exports__ = (() => {
             return {
               quantization_bits: transform.quantization_bits(),
               range: transform.range(),
-              min_values: new Float32Array([1, 2, 3]).map((i2) => transform.min_value(i2))
+              min_values: new Float32Array([1, 2, 3]).map((i) => transform.min_value(i))
             };
           }
         } finally {
@@ -3785,16 +3756,16 @@ var __exports__ = (() => {
   function getInt32Array(dracoArray) {
     const numValues = dracoArray.size();
     const intArray = new Int32Array(numValues);
-    for (let i2 = 0; i2 < numValues; i2++) {
-      intArray[i2] = dracoArray.GetValue(i2);
+    for (let i = 0; i < numValues; i++) {
+      intArray[i] = dracoArray.GetValue(i);
     }
     return intArray;
   }
   function getUint32Array(dracoArray) {
     const numValues = dracoArray.size();
     const intArray = new Int32Array(numValues);
-    for (let i2 = 0; i2 < numValues; i2++) {
-      intArray[i2] = dracoArray.GetValue(i2);
+    for (let i = 0; i < numValues; i++) {
+      intArray[i] = dracoArray.GetValue(i);
     }
     return intArray;
   }
@@ -4087,34 +4058,34 @@ var __exports__ = (() => {
   function isArray(value) {
     return Array.isArray(value) || ArrayBuffer.isView(value) && !(value instanceof DataView);
   }
-  function equals(a2, b, epsilon) {
+  function equals(a, b, epsilon) {
     const oldEpsilon = config.EPSILON;
     if (epsilon) {
       config.EPSILON = epsilon;
     }
     try {
-      if (a2 === b) {
+      if (a === b) {
         return true;
       }
-      if (isArray(a2) && isArray(b)) {
-        if (a2.length !== b.length) {
+      if (isArray(a) && isArray(b)) {
+        if (a.length !== b.length) {
           return false;
         }
-        for (let i2 = 0; i2 < a2.length; ++i2) {
-          if (!equals(a2[i2], b[i2])) {
+        for (let i = 0; i < a.length; ++i) {
+          if (!equals(a[i], b[i])) {
             return false;
           }
         }
         return true;
       }
-      if (a2 && a2.equals) {
-        return a2.equals(b);
+      if (a && a.equals) {
+        return a.equals(b);
       }
       if (b && b.equals) {
-        return b.equals(a2);
+        return b.equals(a);
       }
-      if (typeof a2 === "number" && typeof b === "number") {
-        return Math.abs(a2 - b) <= config.EPSILON * Math.max(1, Math.abs(a2), Math.abs(b));
+      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 {
@@ -4152,14 +4123,14 @@ var __exports__ = (() => {
       return new this.constructor().copy(this);
     }
     fromArray(array, offset = 0) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = array[i2 + offset];
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = array[i + offset];
       }
       return this.check();
     }
     toArray(targetArray = [], offset = 0) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        targetArray[offset + i2] = this[i2];
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        targetArray[offset + i] = this[i];
       }
       return targetArray;
     }
@@ -4186,8 +4157,8 @@ var __exports__ = (() => {
     }
     formatString(opts) {
       let string = "";
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        string += (i2 > 0 ? ", " : "") + formatValue(this[i2], opts);
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        string += (i > 0 ? ", " : "") + formatValue(this[i], opts);
       }
       return "".concat(opts.printTypes ? this.constructor.name : "", "[").concat(string, "]");
     }
@@ -4195,8 +4166,8 @@ var __exports__ = (() => {
       if (!array || this.length !== array.length) {
         return false;
       }
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        if (!equals(this[i2], array[i2])) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        if (!equals(this[i], array[i])) {
           return false;
         }
       }
@@ -4206,79 +4177,79 @@ var __exports__ = (() => {
       if (!array || this.length !== array.length) {
         return false;
       }
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        if (this[i2] !== array[i2]) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        if (this[i] !== array[i]) {
           return false;
         }
       }
       return true;
     }
     negate() {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = -this[i2];
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = -this[i];
       }
       return this.check();
     }
-    lerp(a2, b, t2) {
-      if (t2 === void 0) {
-        return this.lerp(this, a2, b);
+    lerp(a, b, t) {
+      if (t === void 0) {
+        return this.lerp(this, a, b);
       }
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        const ai = a2[i2];
-        const endValue = typeof b === "number" ? b : b[i2];
-        this[i2] = ai + t2 * (endValue - ai);
+      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();
     }
     min(vector) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = Math.min(vector[i2], this[i2]);
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = Math.min(vector[i], this[i]);
       }
       return this.check();
     }
     max(vector) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = Math.max(vector[i2], this[i2]);
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = Math.max(vector[i], this[i]);
       }
       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]);
+      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 i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          this[i2] += vector[i2];
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] += vector[i];
         }
       }
       return this.check();
     }
     subtract(...vectors) {
       for (const vector of vectors) {
-        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          this[i2] -= vector[i2];
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] -= vector[i];
         }
       }
       return this.check();
     }
     scale(scale2) {
       if (typeof scale2 === "number") {
-        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          this[i2] *= scale2;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] *= scale2;
         }
       } else {
-        for (let i2 = 0; i2 < this.ELEMENTS && i2 < scale2.length; ++i2) {
-          this[i2] *= scale2[i2];
+        for (let i = 0; i < this.ELEMENTS && i < scale2.length; ++i) {
+          this[i] *= scale2[i];
         }
       }
       return this.check();
     }
     multiplyByScalar(scalar) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] *= scalar;
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] *= scalar;
       }
       return this.check();
     }
@@ -4290,41 +4261,41 @@ var __exports__ = (() => {
     }
     validate() {
       let valid = this.length === this.ELEMENTS;
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        valid = valid && Number.isFinite(this[i2]);
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        valid = valid && Number.isFinite(this[i]);
       }
       return valid;
     }
-    sub(a2) {
-      return this.subtract(a2);
+    sub(a) {
+      return this.subtract(a);
     }
-    setScalar(a2) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = a2;
+    setScalar(a) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = a;
       }
       return this.check();
     }
-    addScalar(a2) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] += a2;
+    addScalar(a) {
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] += a;
       }
       return this.check();
     }
-    subScalar(a2) {
-      return this.addScalar(-a2);
+    subScalar(a) {
+      return this.addScalar(-a);
     }
     multiplyScalar(scalar) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] *= scalar;
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] *= scalar;
       }
       return this.check();
     }
-    divideScalar(a2) {
-      return this.multiplyByScalar(1 / a2);
+    divideScalar(a) {
+      return this.multiplyByScalar(1 / a);
     }
     clampScalar(min, max) {
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        this[i2] = Math.min(Math.max(this[i2], min), max);
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        this[i] = Math.min(Math.max(this[i], min), max);
       }
       return this.check();
     }
@@ -4338,8 +4309,8 @@ var __exports__ = (() => {
     if (v.length !== length) {
       return false;
     }
-    for (let i2 = 0; i2 < v.length; ++i2) {
-      if (!Number.isFinite(v[i2])) {
+    for (let i = 0; i < v.length; ++i) {
+      if (!Number.isFinite(v[i])) {
         return false;
       }
     }
@@ -4387,8 +4358,8 @@ var __exports__ = (() => {
     }
     lengthSquared() {
       let length = 0;
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        length += this[i2] * this[i2];
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        length += this[i] * this[i];
       }
       return length;
     }
@@ -4400,40 +4371,40 @@ var __exports__ = (() => {
     }
     distanceSquared(mathArray) {
       let length = 0;
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        const dist = this[i2] - mathArray[i2];
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        const dist = this[i] - mathArray[i];
         length += dist * dist;
       }
       return checkNumber(length);
     }
     dot(mathArray) {
       let product = 0;
-      for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-        product += this[i2] * mathArray[i2];
+      for (let i = 0; i < this.ELEMENTS; ++i) {
+        product += this[i] * mathArray[i];
       }
       return checkNumber(product);
     }
     normalize() {
       const length = this.magnitude();
       if (length !== 0) {
-        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          this[i2] /= length;
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] /= length;
         }
       }
       return this.check();
     }
     multiply(...vectors) {
       for (const vector of vectors) {
-        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          this[i2] *= vector[i2];
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] *= vector[i];
         }
       }
       return this.check();
     }
     divide(...vectors) {
       for (const vector of vectors) {
-        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          this[i2] /= vector[i2];
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          this[i] /= vector[i];
         }
       }
       return this.check();
@@ -4447,26 +4418,26 @@ var __exports__ = (() => {
     distanceToSquared(vector) {
       return this.distanceSquared(vector);
     }
-    getComponent(i2) {
-      assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
-      return checkNumber(this[i2]);
+    getComponent(i) {
+      assert4(i >= 0 && i < this.ELEMENTS, "index is out of range");
+      return checkNumber(this[i]);
     }
-    setComponent(i2, value) {
-      assert4(i2 >= 0 && i2 < this.ELEMENTS, "index is out of range");
-      this[i2] = value;
+    setComponent(i, value) {
+      assert4(i >= 0 && i < this.ELEMENTS, "index is out of range");
+      this[i] = value;
       return this.check();
     }
-    addVectors(a2, b) {
-      return this.copy(a2).add(b);
+    addVectors(a, b) {
+      return this.copy(a).add(b);
     }
-    subVectors(a2, b) {
-      return this.copy(a2).subtract(b);
+    subVectors(a, b) {
+      return this.copy(a).subtract(b);
     }
-    multiplyVectors(a2, b) {
-      return this.copy(a2).multiply(b);
+    multiplyVectors(a, b) {
+      return this.copy(a).multiply(b);
     }
-    addScaledVector(a2, b) {
-      return this.add(new this.constructor(a2).multiplyScalar(b));
+    addScaledVector(a, b) {
+      return this.add(new this.constructor(a).multiplyScalar(b));
     }
   };
 
@@ -4483,18 +4454,18 @@ var __exports__ = (() => {
     }
     return out;
   }
-  function transformMat3(out, a2, m) {
-    const x = a2[0];
-    const y = a2[1];
+  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;
   }
   var forEach = function() {
     const vec = create();
-    return function(a2, stride, offset, count, fn, arg) {
-      let i2;
-      let l2;
+    return function(a, stride, offset, count, fn, arg) {
+      let i;
+      let l;
       if (!stride) {
         stride = 2;
       }
@@ -4502,48 +4473,48 @@ var __exports__ = (() => {
         offset = 0;
       }
       if (count) {
-        l2 = Math.min(count * stride + offset, a2.length);
+        l = Math.min(count * stride + offset, a.length);
       } else {
-        l2 = a2.length;
+        l = a.length;
       }
-      for (i2 = offset; i2 < l2; i2 += stride) {
-        vec[0] = a2[i2];
-        vec[1] = a2[i2 + 1];
+      for (i = offset; i < l; i += stride) {
+        vec[0] = a[i];
+        vec[1] = a[i + 1];
         fn(vec, vec, arg);
-        a2[i2] = vec[0];
-        a2[i2 + 1] = vec[1];
+        a[i] = vec[0];
+        a[i + 1] = vec[1];
       }
-      return a2;
+      return a;
     };
   }();
 
   // ../../node_modules/@math.gl/core/dist/lib/gl-matrix-extras.js
-  function vec3_transformMat4AsVector(out, a2, m) {
-    const x = a2[0];
-    const y = a2[1];
-    const z = a2[2];
+  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, a2, m) {
-    const x = a2[0];
-    const y = a2[1];
+  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] = a2[2];
+    out[2] = a[2];
     return out;
   }
-  function vec4_transformMat3(out, a2, m) {
-    const x = a2[0];
-    const y = a2[1];
-    const z = a2[2];
+  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] = a2[3];
+    out[3] = a[3];
     return out;
   }
 
@@ -4557,13 +4528,13 @@ var __exports__ = (() => {
     }
     return out;
   }
-  function dot(a2, b) {
-    return a2[0] * b[0] + a2[1] * b[1] + a2[2] * b[2];
+  function dot(a, b) {
+    return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
   }
-  function cross(out, a2, b) {
-    const ax = a2[0];
-    const ay = a2[1];
-    const az = a2[2];
+  function cross(out, a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
     const bx = b[0];
     const by = b[1];
     const bz = b[2];
@@ -4572,10 +4543,10 @@ var __exports__ = (() => {
     out[2] = ax * by - ay * bx;
     return out;
   }
-  function transformMat4(out, a2, m) {
-    const x = a2[0];
-    const y = a2[1];
-    const z = a2[2];
+  function transformMat4(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
     let 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;
@@ -4583,23 +4554,23 @@ var __exports__ = (() => {
     out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;
     return out;
   }
-  function transformMat32(out, a2, m) {
-    const x = a2[0];
-    const y = a2[1];
-    const z = a2[2];
+  function transformMat32(out, a, m) {
+    const x = a[0];
+    const y = a[1];
+    const z = a[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) {
+  function transformQuat(out, a, q) {
     const qx = q[0];
     const qy = q[1];
     const qz = q[2];
     const qw = q[3];
-    const x = a2[0];
-    const y = a2[1];
-    const z = a2[2];
+    const x = a[0];
+    const y = a[1];
+    const z = a[2];
     let uvx = qy * z - qz * y;
     let uvy = qz * x - qx * z;
     let uvz = qx * y - qy * x;
@@ -4618,64 +4589,64 @@ var __exports__ = (() => {
     out[2] = z + uvz + uuvz;
     return out;
   }
-  function rotateX(out, a2, b, rad) {
-    const p2 = [];
-    const 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];
+  function rotateX(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[0];
+    r[1] = p[1] * Math.cos(rad) - p[2] * Math.sin(rad);
+    r[2] = p[1] * Math.sin(rad) + p[2] * Math.cos(rad);
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
     return out;
   }
-  function rotateY(out, a2, b, rad) {
-    const p2 = [];
-    const 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];
+  function rotateY(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[2] * Math.sin(rad) + p[0] * Math.cos(rad);
+    r[1] = p[1];
+    r[2] = p[2] * Math.cos(rad) - p[0] * Math.sin(rad);
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
     return out;
   }
-  function rotateZ(out, a2, b, rad) {
-    const p2 = [];
-    const 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];
+  function rotateZ(out, a, b, rad) {
+    const p = [];
+    const r = [];
+    p[0] = a[0] - b[0];
+    p[1] = a[1] - b[1];
+    p[2] = a[2] - b[2];
+    r[0] = p[0] * Math.cos(rad) - p[1] * Math.sin(rad);
+    r[1] = p[0] * Math.sin(rad) + p[1] * Math.cos(rad);
+    r[2] = p[2];
+    out[0] = r[0] + b[0];
+    out[1] = r[1] + b[1];
+    out[2] = r[2] + b[2];
     return out;
   }
-  function angle(a2, b) {
-    const ax = a2[0];
-    const ay = a2[1];
-    const az = a2[2];
+  function angle(a, b) {
+    const ax = a[0];
+    const ay = a[1];
+    const az = a[2];
     const bx = b[0];
     const by = b[1];
     const bz = b[2];
     const mag = Math.sqrt((ax * ax + ay * ay + az * az) * (bx * bx + by * by + bz * bz));
-    const cosine = mag && dot(a2, b) / mag;
+    const cosine = mag && dot(a, b) / mag;
     return Math.acos(Math.min(Math.max(cosine, -1), 1));
   }
   var forEach2 = function() {
     const vec = create2();
-    return function(a2, stride, offset, count, fn, arg) {
-      let i2;
-      let l2;
+    return function(a, stride, offset, count, fn, arg) {
+      let i;
+      let l;
       if (!stride) {
         stride = 3;
       }
@@ -4683,20 +4654,20 @@ var __exports__ = (() => {
         offset = 0;
       }
       if (count) {
-        l2 = Math.min(count * stride + offset, a2.length);
+        l = Math.min(count * stride + offset, a.length);
       } else {
-        l2 = a2.length;
+        l = a.length;
       }
-      for (i2 = offset; i2 < l2; i2 += stride) {
-        vec[0] = a2[i2];
-        vec[1] = a2[i2 + 1];
-        vec[2] = a2[i2 + 2];
+      for (i = offset; i < l; i += stride) {
+        vec[0] = a[i];
+        vec[1] = a[i + 1];
+        vec[2] = a[i + 2];
         fn(vec, vec, arg);
-        a2[i2] = vec[0];
-        a2[i2 + 1] = vec[1];
-        a2[i2 + 2] = vec[2];
+        a[i] = vec[0];
+        a[i + 1] = vec[1];
+        a[i + 2] = vec[2];
       }
-      return a2;
+      return a;
     };
   }();
 
@@ -4830,8 +4801,8 @@ var __exports__ = (() => {
         }
       } else {
         string += "column-major:";
-        for (let i2 = 0; i2 < this.ELEMENTS; ++i2) {
-          string += " ".concat(this[i2]);
+        for (let i = 0; i < this.ELEMENTS; ++i) {
+          string += " ".concat(this[i]);
         }
       }
       string += "]";
@@ -4849,55 +4820,55 @@ var __exports__ = (() => {
     }
     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];
+      for (let i = 0; i < this.RANK; ++i) {
+        result[i] = this[firstIndex + i];
       }
       return result;
     }
     setColumn(columnIndex, columnVector) {
       const firstIndex = columnIndex * this.RANK;
-      for (let i2 = 0; i2 < this.RANK; ++i2) {
-        this[firstIndex + i2] = columnVector[i2];
+      for (let i = 0; i < this.RANK; ++i) {
+        this[firstIndex + i] = columnVector[i];
       }
       return this;
     }
   };
 
   // ../../node_modules/@math.gl/core/dist/gl-matrix/mat3.js
-  function transpose(out, a2) {
-    if (out === a2) {
-      const a01 = a2[1];
-      const a02 = a2[2];
-      const a12 = a2[5];
-      out[1] = a2[3];
-      out[2] = a2[6];
+  function transpose(out, a) {
+    if (out === a) {
+      const a01 = a[1];
+      const a02 = a[2];
+      const a12 = a[5];
+      out[1] = a[3];
+      out[2] = a[6];
       out[3] = a01;
-      out[5] = a2[7];
+      out[5] = a[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];
+      out[0] = a[0];
+      out[1] = a[3];
+      out[2] = a[6];
+      out[3] = a[1];
+      out[4] = a[4];
+      out[5] = a[7];
+      out[6] = a[2];
+      out[7] = a[5];
+      out[8] = a[8];
     }
     return out;
   }
-  function invert(out, a2) {
-    const a00 = a2[0];
-    const a01 = a2[1];
-    const a02 = a2[2];
-    const a10 = a2[3];
-    const a11 = a2[4];
-    const a12 = a2[5];
-    const a20 = a2[6];
-    const a21 = a2[7];
-    const a22 = a2[8];
+  function invert(out, a) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a10 = a[3];
+    const a11 = a[4];
+    const a12 = a[5];
+    const a20 = a[6];
+    const a21 = a[7];
+    const a22 = a[8];
     const b01 = a22 * a11 - a12 * a21;
     const b11 = -a22 * a10 + a12 * a20;
     const b21 = a21 * a10 - a11 * a20;
@@ -4917,28 +4888,28 @@ var __exports__ = (() => {
     out[8] = (a11 * a00 - a01 * a10) * det;
     return out;
   }
-  function determinant(a2) {
-    const a00 = a2[0];
-    const a01 = a2[1];
-    const a02 = a2[2];
-    const a10 = a2[3];
-    const a11 = a2[4];
-    const a12 = a2[5];
-    const a20 = a2[6];
-    const a21 = a2[7];
-    const a22 = a2[8];
+  function determinant(a) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a10 = a[3];
+    const a11 = a[4];
+    const a12 = a[5];
+    const a20 = a[6];
+    const a21 = a[7];
+    const a22 = a[8];
     return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);
   }
-  function multiply(out, a2, b) {
-    const a00 = a2[0];
-    const a01 = a2[1];
-    const a02 = a2[2];
-    const a10 = a2[3];
-    const a11 = a2[4];
-    const a12 = a2[5];
-    const a20 = a2[6];
-    const a21 = a2[7];
-    const a22 = a2[8];
+  function multiply(out, a, b) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a10 = a[3];
+    const a11 = a[4];
+    const a12 = a[5];
+    const a20 = a[6];
+    const a21 = a[7];
+    const a22 = a[8];
     const b00 = b[0];
     const b01 = b[1];
     const b02 = b[2];
@@ -4959,16 +4930,16 @@ var __exports__ = (() => {
     out[8] = b20 * a02 + b21 * a12 + b22 * a22;
     return out;
   }
-  function translate(out, a2, v) {
-    const a00 = a2[0];
-    const a01 = a2[1];
-    const a02 = a2[2];
-    const a10 = a2[3];
-    const a11 = a2[4];
-    const a12 = a2[5];
-    const a20 = a2[6];
-    const a21 = a2[7];
-    const a22 = a2[8];
+  function translate(out, a, v) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a10 = a[3];
+    const a11 = a[4];
+    const a12 = a[5];
+    const a20 = a[6];
+    const a21 = a[7];
+    const a22 = a[8];
     const x = v[0];
     const y = v[1];
     out[0] = a00;
@@ -4982,41 +4953,41 @@ var __exports__ = (() => {
     out[8] = x * a02 + y * a12 + a22;
     return out;
   }
-  function rotate(out, a2, rad) {
-    const a00 = a2[0];
-    const a01 = a2[1];
-    const a02 = a2[2];
-    const a10 = a2[3];
-    const a11 = a2[4];
-    const a12 = a2[5];
-    const a20 = a2[6];
-    const a21 = a2[7];
-    const a22 = a2[8];
-    const s2 = Math.sin(rad);
+  function rotate(out, a, rad) {
+    const a00 = a[0];
+    const a01 = a[1];
+    const a02 = a[2];
+    const a10 = a[3];
+    const a11 = a[4];
+    const a12 = a[5];
+    const a20 = a[6];
+    const a21 = a[7];
+    const a22 = a[8];
+    const s = Math.sin(rad);
     const 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[0] = c * a00 + s * a10;
+    out[1] = c * a01 + s * a11;
+    out[2] = c * a02 + s * a12;
+    out[3] = c * a10 - s * a00;
+    out[4] = c * a11 - s * a01;
+    out[5] = c * a12 - s * a02;
     out[6] = a20;
     out[7] = a21;
     out[8] = a22;
     return out;
   }
-  function scale(out, a2, v) {
+  function scale(out, a, v) {
     const x = v[0];
     const 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];
+    out[0] = x * a[0];
+    out[1] = x * a[1];
+    out[2] = x * a[2];
+    out[3] = y * a[3];
+    out[4] = y * a[4];
+    out[5] = y * a[5];
+    out[6] = a[6];
+    out[7] = a[7];
+    out[8] = a[8];
     return out;
   }
   function fromQuat(out, q) {
@@ -5145,12 +5116,12 @@ var __exports__ = (() => {
       invert(this, this);
       return this.check();
     }
-    multiplyLeft(a2) {
-      multiply(this, a2, this);
+    multiplyLeft(a) {
+      multiply(this, a, this);
       return this.check();
     }
-    multiplyRight(a2) {
-      multiply(this, this, a2);
+    multiplyRight(a) {
+      multiply(this, this, a);
       return this.check();
     }
     rotate(radians) {
@@ -5227,8 +5198,8 @@ var __exports__ = (() => {
       return;
     }
     const materials = gltfData.json.materials || [];
-    for (let i2 = 0; i2 < materials.length; i2++) {
-      transformTexCoords(i2, gltfData);
+    for (let i = 0; i < materials.length; i++) {
+      transformTexCoords(i, gltfData);
     }
   }
   function transformTexCoords(materialIndex, gltfData) {
@@ -5294,11 +5265,11 @@ var __exports__ = (() => {
           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);
+          for (let i = 0; i < accessor.count; i++) {
+            const uv = new ArrayType(arrayBuffer, byteOffset + i * elementAddressScale, 2);
             scratchVector.set(uv[0], uv[1], 1);
             scratchVector.transformByMatrix3(matrix);
-            result.set([scratchVector[0], scratchVector[1]], i2 * components);
+            result.set([scratchVector[0], scratchVector[1]], i * components);
           }
           if (originalTexCoord === texCoord) {
             updateGltf(accessor, bufferView, gltfData.buffers, result);
@@ -5832,22 +5803,22 @@ var __exports__ = (() => {
   }
   async function loadBuffers(gltf, options, context) {
     const buffers = gltf.json.buffers || [];
-    for (let i2 = 0; i2 < buffers.length; ++i2) {
-      const buffer = buffers[i2];
+    for (let i = 0; i < buffers.length; ++i) {
+      const buffer = buffers[i];
       if (buffer.uri) {
         const { fetch: fetch2 } = context;
         assert3(fetch2);
         const uri = resolveUrl(buffer.uri, options);
         const response = await context?.fetch?.(uri);
         const arrayBuffer = await response?.arrayBuffer?.();
-        gltf.buffers[i2] = {
+        gltf.buffers[i] = {
           arrayBuffer,
           byteOffset: 0,
           byteLength: arrayBuffer.byteLength
         };
         delete buffer.uri;
-      } else if (gltf.buffers[i2] === null) {
-        gltf.buffers[i2] = {
+      } else if (gltf.buffers[i] === null) {
+        gltf.buffers[i] = {
           arrayBuffer: new ArrayBuffer(buffer.byteLength),
           byteOffset: 0,
           byteLength: buffer.byteLength
@@ -6177,35 +6148,35 @@ var __exports__ = (() => {
       const json = { ...gltf };
       this.json = json;
       if (gltf.bufferViews) {
-        json.bufferViews = gltf.bufferViews.map((bufView, i2) => this._resolveBufferView(bufView, i2));
+        json.bufferViews = gltf.bufferViews.map((bufView, i) => this._resolveBufferView(bufView, i));
       }
       if (gltf.images) {
-        json.images = gltf.images.map((image, i2) => this._resolveImage(image, i2));
+        json.images = gltf.images.map((image, i) => this._resolveImage(image, i));
       }
       if (gltf.samplers) {
-        json.samplers = gltf.samplers.map((sampler, i2) => this._resolveSampler(sampler, i2));
+        json.samplers = gltf.samplers.map((sampler, i) => this._resolveSampler(sampler, i));
       }
       if (gltf.textures) {
-        json.textures = gltf.textures.map((texture, i2) => this._resolveTexture(texture, i2));
+        json.textures = gltf.textures.map((texture, i) => this._resolveTexture(texture, i));
       }
       if (gltf.accessors) {
-        json.accessors = gltf.accessors.map((accessor, i2) => this._resolveAccessor(accessor, i2));
+        json.accessors = gltf.accessors.map((accessor, i) => this._resolveAccessor(accessor, i));
       }
       if (gltf.materials) {
-        json.materials = gltf.materials.map((material, i2) => this._resolveMaterial(material, i2));
+        json.materials = gltf.materials.map((material, i) => this._resolveMaterial(material, i));
       }
       if (gltf.meshes) {
-        json.meshes = gltf.meshes.map((mesh, i2) => this._resolveMesh(mesh, i2));
+        json.meshes = gltf.meshes.map((mesh, i) => this._resolveMesh(mesh, i));
       }
       if (gltf.nodes) {
-        json.nodes = gltf.nodes.map((node, i2) => this._resolveNode(node, i2));
-        json.nodes = json.nodes.map((node, i2) => this._resolveNodeChildren(node));
+        json.nodes = gltf.nodes.map((node, i) => this._resolveNode(node, i));
+        json.nodes = json.nodes.map((node, i) => this._resolveNodeChildren(node));
       }
       if (gltf.skins) {
-        json.skins = gltf.skins.map((skin, i2) => this._resolveSkin(skin, i2));
+        json.skins = gltf.skins.map((skin, i) => this._resolveSkin(skin, i));
       }
       if (gltf.scenes) {
-        json.scenes = gltf.scenes.map((scene, i2) => this._resolveScene(scene, i2));
+        json.scenes = gltf.scenes.map((scene, i) => this._resolveScene(scene, i));
       }
       if (typeof this.json.scene === "number" && json.scenes) {
         json.scene = json.scenes[this.json.scene];
@@ -6421,11 +6392,11 @@ var __exports__ = (() => {
      */
     _getValueFromInterleavedBuffer(buffer, byteOffset, byteStride, bytesPerElement, count) {
       const result = new Uint8Array(count * bytesPerElement);
-      for (let i2 = 0; i2 < count; i2++) {
-        const elementOffset = byteOffset + i2 * byteStride;
+      for (let i = 0; i < count; i++) {
+        const elementOffset = byteOffset + i * byteStride;
         result.set(
           new Uint8Array(buffer.arrayBuffer.slice(elementOffset, elementOffset + bytesPerElement)),
-          i2 * bytesPerElement
+          i * bytesPerElement
         );
       }
       return result.buffer;