@loaders.gl/textures 4.3.0-alpha.2 → 4.3.0-alpha.4

package/dist/dist.dev.js

@@ -224,7 +224,7 @@ var __exports__ = (() => {
     script.id = id;
     try {
       script.appendChild(document.createTextNode(scriptSource));
-    } catch (e2) {
+    } catch (e) {
       script.text = scriptSource;
     }
     document.body.appendChild(script);
@@ -453,99 +453,255 @@ var __exports__ = (() => {
   }
 
   // ../../node_modules/ktx-parse/dist/ktx-parse.modern.js
-  var t = new Uint8Array([0]);
-  var e = [171, 75, 84, 88, 32, 50, 48, 187, 13, 10, 26, 10];
-  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 = {}));
-  var U = class {
+  var KHR_SUPERCOMPRESSION_NONE = 0;
+  var KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT = 0;
+  var KHR_DF_VENDORID_KHRONOS = 0;
+  var KHR_DF_VERSION = 2;
+  var KHR_DF_MODEL_UNSPECIFIED = 0;
+  var KHR_DF_FLAG_ALPHA_STRAIGHT = 0;
+  var KHR_DF_TRANSFER_SRGB = 2;
+  var KHR_DF_PRIMARIES_BT709 = 1;
+  var KHR_DF_SAMPLE_DATATYPE_SIGNED = 64;
+  var VK_FORMAT_UNDEFINED = 0;
+  var KTX2Container = class {
     constructor() {
-      this.vkFormat = 0, this.typeSize = 1, this.pixelWidth = 0, this.pixelHeight = 0, this.pixelDepth = 0, this.layerCount = 0, this.faceCount = 1, this.supercompressionScheme = n.NONE, this.levels = [], this.dataFormatDescriptor = [{ vendorId: 0, descriptorType: i.BASICFORMAT, versionNumber: 2, descriptorBlockSize: 40, colorModel: s.UNSPECIFIED, colorPrimaries: a.SRGB, transferFunction: a.SRGB, flags: o.ALPHA_STRAIGHT, texelBlockDimension: { x: 4, y: 4, z: 1, w: 1 }, bytesPlane: [], samples: [] }], this.keyValue = {}, this.globalData = null;
+      this.vkFormat = VK_FORMAT_UNDEFINED;
+      this.typeSize = 1;
+      this.pixelWidth = 0;
+      this.pixelHeight = 0;
+      this.pixelDepth = 0;
+      this.layerCount = 0;
+      this.faceCount = 1;
+      this.supercompressionScheme = KHR_SUPERCOMPRESSION_NONE;
+      this.levels = [];
+      this.dataFormatDescriptor = [{
+        vendorId: KHR_DF_VENDORID_KHRONOS,
+        descriptorType: KHR_DF_KHR_DESCRIPTORTYPE_BASICFORMAT,
+        descriptorBlockSize: 0,
+        versionNumber: KHR_DF_VERSION,
+        colorModel: KHR_DF_MODEL_UNSPECIFIED,
+        colorPrimaries: KHR_DF_PRIMARIES_BT709,
+        transferFunction: KHR_DF_TRANSFER_SRGB,
+        flags: KHR_DF_FLAG_ALPHA_STRAIGHT,
+        texelBlockDimension: [0, 0, 0, 0],
+        bytesPlane: [0, 0, 0, 0, 0, 0, 0, 0],
+        samples: []
+      }];
+      this.keyValue = {};
+      this.globalData = null;
     }
   };
-  var c = class {
-    constructor(t2, e2, n2, i2) {
-      this._dataView = new DataView(t2.buffer, t2.byteOffset + e2, n2), this._littleEndian = i2, this._offset = 0;
+  var BufferReader = class {
+    constructor(data, byteOffset, byteLength, littleEndian) {
+      this._dataView = void 0;
+      this._littleEndian = void 0;
+      this._offset = void 0;
+      this._dataView = new DataView(data.buffer, data.byteOffset + byteOffset, byteLength);
+      this._littleEndian = littleEndian;
+      this._offset = 0;
     }
     _nextUint8() {
-      const t2 = this._dataView.getUint8(this._offset);
-      return this._offset += 1, t2;
+      const value = this._dataView.getUint8(this._offset);
+      this._offset += 1;
+      return value;
     }
     _nextUint16() {
-      const t2 = this._dataView.getUint16(this._offset, this._littleEndian);
-      return this._offset += 2, t2;
+      const value = this._dataView.getUint16(this._offset, this._littleEndian);
+      this._offset += 2;
+      return value;
     }
     _nextUint32() {
-      const t2 = this._dataView.getUint32(this._offset, this._littleEndian);
-      return this._offset += 4, t2;
+      const value = this._dataView.getUint32(this._offset, this._littleEndian);
+      this._offset += 4;
+      return value;
     }
     _nextUint64() {
-      const t2 = this._dataView.getUint32(this._offset, this._littleEndian) + 2 ** 32 * this._dataView.getUint32(this._offset + 4, this._littleEndian);
-      return this._offset += 8, t2;
-    }
-    _skip(t2) {
-      return this._offset += t2, this;
-    }
-    _scan(t2, e2 = 0) {
-      const n2 = this._offset;
-      let i2 = 0;
-      for (; this._dataView.getUint8(this._offset) !== e2 && i2 < t2; )
-        i2++, this._offset++;
-      return i2 < t2 && this._offset++, new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + n2, i2);
+      const left = this._dataView.getUint32(this._offset, this._littleEndian);
+      const right = this._dataView.getUint32(this._offset + 4, this._littleEndian);
+      const value = left + 2 ** 32 * right;
+      this._offset += 8;
+      return value;
+    }
+    _nextInt32() {
+      const value = this._dataView.getInt32(this._offset, this._littleEndian);
+      this._offset += 4;
+      return value;
+    }
+    _nextUint8Array(len) {
+      const value = new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + this._offset, len);
+      this._offset += len;
+      return value;
+    }
+    _skip(bytes) {
+      this._offset += bytes;
+      return this;
+    }
+    _scan(maxByteLength, term = 0) {
+      const byteOffset = this._offset;
+      let byteLength = 0;
+      while (this._dataView.getUint8(this._offset) !== term && byteLength < maxByteLength) {
+        byteLength++;
+        this._offset++;
+      }
+      if (byteLength < maxByteLength)
+        this._offset++;
+      return new Uint8Array(this._dataView.buffer, this._dataView.byteOffset + byteOffset, byteLength);
     }
   };
-  function _(t2) {
-    return "undefined" != typeof TextDecoder ? new TextDecoder().decode(t2) : Buffer.from(t2).toString("utf8");
+  var NUL = new Uint8Array([0]);
+  var KTX2_ID = [
+    // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
+    171,
+    75,
+    84,
+    88,
+    32,
+    50,
+    48,
+    187,
+    13,
+    10,
+    26,
+    10
+  ];
+  function decodeText(buffer) {
+    if (typeof TextDecoder !== "undefined") {
+      return new TextDecoder().decode(buffer);
+    }
+    return Buffer.from(buffer).toString("utf8");
   }
-  function p(t2) {
-    const n2 = new Uint8Array(t2.buffer, t2.byteOffset, e.length);
-    if (n2[0] !== e[0] || n2[1] !== e[1] || n2[2] !== e[2] || n2[3] !== e[3] || n2[4] !== e[4] || n2[5] !== e[5] || n2[6] !== e[6] || n2[7] !== e[7] || n2[8] !== e[8] || n2[9] !== e[9] || n2[10] !== e[10] || n2[11] !== e[11])
+  function read(data) {
+    const id = new Uint8Array(data.buffer, data.byteOffset, KTX2_ID.length);
+    if (id[0] !== KTX2_ID[0] || // '´'
+    id[1] !== KTX2_ID[1] || // 'K'
+    id[2] !== KTX2_ID[2] || // 'T'
+    id[3] !== KTX2_ID[3] || // 'X'
+    id[4] !== KTX2_ID[4] || // ' '
+    id[5] !== KTX2_ID[5] || // '2'
+    id[6] !== KTX2_ID[6] || // '0'
+    id[7] !== KTX2_ID[7] || // 'ª'
+    id[8] !== KTX2_ID[8] || // '\r'
+    id[9] !== KTX2_ID[9] || // '\n'
+    id[10] !== KTX2_ID[10] || // '\x1A'
+    id[11] !== KTX2_ID[11]) {
       throw new Error("Missing KTX 2.0 identifier.");
-    const i2 = new U(), s2 = 17 * Uint32Array.BYTES_PER_ELEMENT, a3 = new c(t2, e.length, s2, true);
-    i2.vkFormat = a3._nextUint32(), i2.typeSize = a3._nextUint32(), i2.pixelWidth = a3._nextUint32(), i2.pixelHeight = a3._nextUint32(), i2.pixelDepth = a3._nextUint32(), i2.layerCount = a3._nextUint32(), i2.faceCount = a3._nextUint32();
-    const r2 = a3._nextUint32();
-    i2.supercompressionScheme = a3._nextUint32();
-    const o2 = a3._nextUint32(), l2 = a3._nextUint32(), f2 = a3._nextUint32(), h = a3._nextUint32(), g = a3._nextUint64(), p2 = a3._nextUint64(), x = new c(t2, e.length + s2, 3 * r2 * 8, true);
-    for (let e2 = 0; e2 < r2; e2++)
-      i2.levels.push({ levelData: new Uint8Array(t2.buffer, t2.byteOffset + x._nextUint64(), x._nextUint64()), uncompressedByteLength: x._nextUint64() });
-    const u = new c(t2, o2, l2, true), y = { vendorId: u._skip(4)._nextUint16(), descriptorType: u._nextUint16(), versionNumber: u._nextUint16(), descriptorBlockSize: u._nextUint16(), colorModel: u._nextUint8(), colorPrimaries: u._nextUint8(), transferFunction: u._nextUint8(), flags: u._nextUint8(), texelBlockDimension: { x: u._nextUint8() + 1, y: u._nextUint8() + 1, z: u._nextUint8() + 1, w: u._nextUint8() + 1 }, bytesPlane: [u._nextUint8(), u._nextUint8(), u._nextUint8(), u._nextUint8(), u._nextUint8(), u._nextUint8(), u._nextUint8(), u._nextUint8()], samples: [] }, D = (y.descriptorBlockSize / 4 - 6) / 4;
-    for (let t3 = 0; t3 < D; t3++)
-      y.samples[t3] = { bitOffset: u._nextUint16(), bitLength: u._nextUint8(), channelID: u._nextUint8(), samplePosition: [u._nextUint8(), u._nextUint8(), u._nextUint8(), u._nextUint8()], sampleLower: u._nextUint32(), sampleUpper: u._nextUint32() };
-    i2.dataFormatDescriptor.length = 0, i2.dataFormatDescriptor.push(y);
-    const b2 = new c(t2, f2, h, true);
-    for (; b2._offset < h; ) {
-      const t3 = b2._nextUint32(), e2 = b2._scan(t3), n3 = _(e2), s3 = b2._scan(t3 - e2.byteLength);
-      i2.keyValue[n3] = n3.match(/^ktx/i) ? _(s3) : s3, t3 % 4 && b2._skip(4 - t3 % 4);
-    }
-    if (p2 <= 0)
-      return i2;
-    const d = new c(t2, g, p2, true), B = d._nextUint16(), w = d._nextUint16(), A = d._nextUint32(), S = d._nextUint32(), m = d._nextUint32(), L = d._nextUint32(), I = [];
-    for (let t3 = 0; t3 < r2; t3++)
-      I.push({ imageFlags: d._nextUint32(), rgbSliceByteOffset: d._nextUint32(), rgbSliceByteLength: d._nextUint32(), alphaSliceByteOffset: d._nextUint32(), alphaSliceByteLength: d._nextUint32() });
-    const R = g + d._offset, E = R + A, T = E + S, O = T + m, P = new Uint8Array(t2.buffer, t2.byteOffset + R, A), C = new Uint8Array(t2.buffer, t2.byteOffset + E, S), F = new Uint8Array(t2.buffer, t2.byteOffset + T, m), G = new Uint8Array(t2.buffer, t2.byteOffset + O, L);
-    return i2.globalData = { endpointCount: B, selectorCount: w, imageDescs: I, endpointsData: P, selectorsData: C, tablesData: F, extendedData: G }, i2;
+    }
+    const container = new KTX2Container();
+    const headerByteLength = 17 * Uint32Array.BYTES_PER_ELEMENT;
+    const headerReader = new BufferReader(data, KTX2_ID.length, headerByteLength, true);
+    container.vkFormat = headerReader._nextUint32();
+    container.typeSize = headerReader._nextUint32();
+    container.pixelWidth = headerReader._nextUint32();
+    container.pixelHeight = headerReader._nextUint32();
+    container.pixelDepth = headerReader._nextUint32();
+    container.layerCount = headerReader._nextUint32();
+    container.faceCount = headerReader._nextUint32();
+    const levelCount = headerReader._nextUint32();
+    container.supercompressionScheme = headerReader._nextUint32();
+    const dfdByteOffset = headerReader._nextUint32();
+    const dfdByteLength = headerReader._nextUint32();
+    const kvdByteOffset = headerReader._nextUint32();
+    const kvdByteLength = headerReader._nextUint32();
+    const sgdByteOffset = headerReader._nextUint64();
+    const sgdByteLength = headerReader._nextUint64();
+    const levelByteLength = levelCount * 3 * 8;
+    const levelReader = new BufferReader(data, KTX2_ID.length + headerByteLength, levelByteLength, true);
+    for (let i = 0; i < levelCount; i++) {
+      container.levels.push({
+        levelData: new Uint8Array(data.buffer, data.byteOffset + levelReader._nextUint64(), levelReader._nextUint64()),
+        uncompressedByteLength: levelReader._nextUint64()
+      });
+    }
+    const dfdReader = new BufferReader(data, dfdByteOffset, dfdByteLength, true);
+    const dfd = {
+      vendorId: dfdReader._skip(
+        4
+        /* totalSize */
+      )._nextUint16(),
+      descriptorType: dfdReader._nextUint16(),
+      versionNumber: dfdReader._nextUint16(),
+      descriptorBlockSize: dfdReader._nextUint16(),
+      colorModel: dfdReader._nextUint8(),
+      colorPrimaries: dfdReader._nextUint8(),
+      transferFunction: dfdReader._nextUint8(),
+      flags: dfdReader._nextUint8(),
+      texelBlockDimension: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
+      bytesPlane: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
+      samples: []
+    };
+    const sampleStart = 6;
+    const sampleWords = 4;
+    const numSamples = (dfd.descriptorBlockSize / 4 - sampleStart) / sampleWords;
+    for (let i = 0; i < numSamples; i++) {
+      const sample = {
+        bitOffset: dfdReader._nextUint16(),
+        bitLength: dfdReader._nextUint8(),
+        channelType: dfdReader._nextUint8(),
+        samplePosition: [dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8(), dfdReader._nextUint8()],
+        sampleLower: -Infinity,
+        sampleUpper: Infinity
+      };
+      if (sample.channelType & KHR_DF_SAMPLE_DATATYPE_SIGNED) {
+        sample.sampleLower = dfdReader._nextInt32();
+        sample.sampleUpper = dfdReader._nextInt32();
+      } else {
+        sample.sampleLower = dfdReader._nextUint32();
+        sample.sampleUpper = dfdReader._nextUint32();
+      }
+      dfd.samples[i] = sample;
+    }
+    container.dataFormatDescriptor.length = 0;
+    container.dataFormatDescriptor.push(dfd);
+    const kvdReader = new BufferReader(data, kvdByteOffset, kvdByteLength, true);
+    while (kvdReader._offset < kvdByteLength) {
+      const keyValueByteLength = kvdReader._nextUint32();
+      const keyData = kvdReader._scan(keyValueByteLength);
+      const key = decodeText(keyData);
+      container.keyValue[key] = kvdReader._nextUint8Array(keyValueByteLength - keyData.byteLength - 1);
+      if (key.match(/^ktx/i)) {
+        const text = decodeText(container.keyValue[key]);
+        container.keyValue[key] = text.substring(0, text.lastIndexOf("\0"));
+      }
+      const kvPadding = keyValueByteLength % 4 ? 4 - keyValueByteLength % 4 : 0;
+      kvdReader._skip(kvPadding);
+    }
+    if (sgdByteLength <= 0)
+      return container;
+    const sgdReader = new BufferReader(data, sgdByteOffset, sgdByteLength, true);
+    const endpointCount = sgdReader._nextUint16();
+    const selectorCount = sgdReader._nextUint16();
+    const endpointsByteLength = sgdReader._nextUint32();
+    const selectorsByteLength = sgdReader._nextUint32();
+    const tablesByteLength = sgdReader._nextUint32();
+    const extendedByteLength = sgdReader._nextUint32();
+    const imageDescs = [];
+    for (let i = 0; i < levelCount; i++) {
+      imageDescs.push({
+        imageFlags: sgdReader._nextUint32(),
+        rgbSliceByteOffset: sgdReader._nextUint32(),
+        rgbSliceByteLength: sgdReader._nextUint32(),
+        alphaSliceByteOffset: sgdReader._nextUint32(),
+        alphaSliceByteLength: sgdReader._nextUint32()
+      });
+    }
+    const endpointsByteOffset = sgdByteOffset + sgdReader._offset;
+    const selectorsByteOffset = endpointsByteOffset + endpointsByteLength;
+    const tablesByteOffset = selectorsByteOffset + selectorsByteLength;
+    const extendedByteOffset = tablesByteOffset + tablesByteLength;
+    const endpointsData = new Uint8Array(data.buffer, data.byteOffset + endpointsByteOffset, endpointsByteLength);
+    const selectorsData = new Uint8Array(data.buffer, data.byteOffset + selectorsByteOffset, selectorsByteLength);
+    const tablesData = new Uint8Array(data.buffer, data.byteOffset + tablesByteOffset, tablesByteLength);
+    const extendedData = new Uint8Array(data.buffer, data.byteOffset + extendedByteOffset, extendedByteLength);
+    container.globalData = {
+      endpointCount,
+      selectorCount,
+      imageDescs,
+      endpointsData,
+      selectorsData,
+      tablesData,
+      extendedData
+    };
+    return container;
   }
 
   // src/lib/utils/extract-mipmap-images.ts
@@ -554,10 +710,10 @@ var __exports__ = (() => {
     let levelWidth = options.width;
     let levelHeight = options.height;
     let offset = 0;
-    for (let i2 = 0; i2 < options.mipMapLevels; ++i2) {
-      const levelSize = getLevelSize(options, levelWidth, levelHeight, data, i2);
-      const levelData = getLevelData(data, i2, offset, levelSize);
-      images[i2] = {
+    for (let i = 0; i < options.mipMapLevels; ++i) {
+      const levelSize = getLevelSize(options, levelWidth, levelHeight, data, i);
+      const levelData = getLevelData(data, i, offset, levelSize);
+      images[i] = {
         compressed: true,
         format: options.internalFormat,
         data: levelData,
@@ -700,7 +856,7 @@ var __exports__ = (() => {
   }
 
   // src/lib/parsers/parse-ktx.ts
-  var KTX2_ID = [
+  var KTX2_ID2 = [
     // '´', 'K', 'T', 'X', '2', '0', 'ª', '\r', '\n', '\x1A', '\n'
     171,
     75,
@@ -717,23 +873,23 @@ var __exports__ = (() => {
   ];
   function isKTX(data) {
     const id = new Uint8Array(data);
-    const notKTX = id.byteLength < KTX2_ID.length || id[0] !== KTX2_ID[0] || // '´'
-    id[1] !== KTX2_ID[1] || // 'K'
-    id[2] !== KTX2_ID[2] || // 'T'
-    id[3] !== KTX2_ID[3] || // 'X'
-    id[4] !== KTX2_ID[4] || // ' '
-    id[5] !== KTX2_ID[5] || // '2'
-    id[6] !== KTX2_ID[6] || // '0'
-    id[7] !== KTX2_ID[7] || // 'ª'
-    id[8] !== KTX2_ID[8] || // '\r'
-    id[9] !== KTX2_ID[9] || // '\n'
-    id[10] !== KTX2_ID[10] || // '\x1A'
-    id[11] !== KTX2_ID[11];
+    const notKTX = id.byteLength < KTX2_ID2.length || id[0] !== KTX2_ID2[0] || // '´'
+    id[1] !== KTX2_ID2[1] || // 'K'
+    id[2] !== KTX2_ID2[2] || // 'T'
+    id[3] !== KTX2_ID2[3] || // 'X'
+    id[4] !== KTX2_ID2[4] || // ' '
+    id[5] !== KTX2_ID2[5] || // '2'
+    id[6] !== KTX2_ID2[6] || // '0'
+    id[7] !== KTX2_ID2[7] || // 'ª'
+    id[8] !== KTX2_ID2[8] || // '\r'
+    id[9] !== KTX2_ID2[9] || // '\n'
+    id[10] !== KTX2_ID2[10] || // '\x1A'
+    id[11] !== KTX2_ID2[11];
     return !notKTX;
   }
   function parseKTX(arrayBuffer) {
     const uint8Array = new Uint8Array(arrayBuffer);
-    const ktx = p(uint8Array);
+    const ktx = read(uint8Array);
     const mipMapLevels = Math.max(1, ktx.levels.length);
     const width = ktx.pixelWidth;
     const height = ktx.pixelHeight;
@@ -872,7 +1028,6 @@ var __exports__ = (() => {
       const levels = [];
       for (let levelIndex = 0; levelIndex < levelsCount; levelIndex++) {
         levels.push(transcodeKTX2Image(ktx2File, levelIndex, options));
-        break;
       }
       return [levels];
     } finally {
@@ -1338,8 +1493,8 @@ var __exports__ = (() => {
   };
 
   // src/lib/parsers/parse-npy.ts
-  var a2 = new Uint32Array([305419896]);
-  var b = new Uint8Array(a2.buffer, a2.byteOffset, a2.byteLength);
+  var a = new Uint32Array([305419896]);
+  var b = new Uint8Array(a.buffer, a.byteOffset, a.byteLength);
   var isLittleEndian = !(b[0] === 18);
   var LITTLE_ENDIAN_OS = isLittleEndian;
   var DTYPES = {
@@ -1360,7 +1515,7 @@ var __exports__ = (() => {
     if (!ArrayType) {
       throw new Error(`Unimplemented type ${numpyType}`);
     }
-    const nArrayElements = header.shape?.reduce((a3, b2) => a3 * b2);
+    const nArrayElements = header.shape?.reduce((a2, b2) => a2 * b2);
     const arrayByteLength = nArrayElements * ArrayType.BYTES_PER_ELEMENT;
     if (arrayBuffer.byteLength < headerEndOffset + arrayByteLength) {
       throw new Error("Buffer overflow");
@@ -1727,8 +1882,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;
       }
     }
@@ -1798,30 +1953,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,
@@ -2049,7 +2204,7 @@ var __exports__ = (() => {
     const urls = {};
     const promises = [];
     let index = 0;
-    for (let i2 = 0; i2 < CUBE_FACES.length; ++i2) {
+    for (let i = 0; i < CUBE_FACES.length; ++i) {
       const face = CUBE_FACES[index];
       const promise = getImageUrls(getUrl, options, { ...face, index: index++ }).then((url) => {
         urls[face.face] = url;