@loaders.gl/gltf 4.3.4 → 4.4.0-alpha.10

package/dist/dist.dev.js

@@ -105,6 +105,9 @@ var __exports__ = (() => {
   var matches = typeof process !== "undefined" && process.version && /v([0-9]*)/.exec(process.version);
   var nodeVersion = matches && parseFloat(matches[1]) || 0;
 
+  // ../loader-utils/src/lib/javascript-utils/is-type.ts
+  var isSharedArrayBuffer = (value) => typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+
   // ../loader-utils/src/lib/module-utils/js-module-utils.ts
   function registerJSModules(modules) {
     globalThis.loaders ||= {};
@@ -116,16 +119,20 @@ var __exports__ = (() => {
     return module || null;
   }
 
+  // ../worker-utils/src/lib/npm-tag.ts
+  var NPM_TAG = "beta";
+
   // ../worker-utils/src/lib/env-utils/version.ts
-  var NPM_TAG = "latest";
+  var warningIssued = false;
   function getVersion() {
     if (!globalThis._loadersgl_?.version) {
       globalThis._loadersgl_ = globalThis._loadersgl_ || {};
-      if (typeof __VERSION__ === "undefined") {
+      if (typeof __VERSION__ === "undefined" && !warningIssued) {
         console.warn(
           "loaders.gl: The __VERSION__ variable is not injected using babel plugin. Latest unstable workers would be fetched from the CDN."
         );
         globalThis._loadersgl_.version = NPM_TAG;
+        warningIssued = true;
       } else {
         globalThis._loadersgl_.version = __VERSION__;
       }
@@ -172,6 +179,9 @@ var __exports__ = (() => {
     return await loadLibraryPromises[libraryUrl];
   }
   function getLibraryUrl(library, moduleName, options = {}, libraryName = null) {
+    if (options?.core) {
+      throw new Error("loadLibrary: options.core must be pre-normalized");
+    }
     if (!options.useLocalLibraries && library.startsWith("http")) {
       return library;
     }
@@ -197,10 +207,20 @@ var __exports__ = (() => {
       return await loadAsArrayBuffer(libraryUrl);
     }
     if (!isBrowser2) {
+      const { requireFromFile } = globalThis.loaders || {};
       try {
-        const { requireFromFile } = globalThis.loaders || {};
-        return await requireFromFile?.(libraryUrl);
+        const result = await requireFromFile?.(libraryUrl);
+        if (result || !libraryUrl.includes("/dist/libs/")) {
+          return result;
+        }
+        return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
       } catch (error) {
+        if (libraryUrl.includes("/dist/libs/")) {
+          try {
+            return await requireFromFile?.(libraryUrl.replace("/dist/libs/", "/src/libs/"));
+          } catch {
+          }
+        }
         console.error(error);
         return null;
       }
@@ -236,7 +256,14 @@ var __exports__ = (() => {
       const response = await fetch(url);
       return await response.arrayBuffer();
     }
-    return await readFileAsArrayBuffer(url);
+    try {
+      return await readFileAsArrayBuffer(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsArrayBuffer(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load ArrayBuffer from ${url}`);
+    }
   }
   async function loadAsText(url) {
     const { readFileAsText } = globalThis.loaders || {};
@@ -244,7 +271,14 @@ var __exports__ = (() => {
       const response = await fetch(url);
       return await response.text();
     }
-    return await readFileAsText(url);
+    try {
+      return await readFileAsText(url);
+    } catch {
+      if (url.includes("/dist/libs/")) {
+        return await readFileAsText(url.replace("/dist/libs/", "/src/libs/"));
+      }
+      throw new Error(`Failed to load text from ${url}`);
+    }
   }
 
   // ../loader-utils/src/lib/binary-utils/get-first-characters.ts
@@ -332,6 +366,27 @@ var __exports__ = (() => {
     return byteOffset;
   }
 
+  // ../loader-utils/src/lib/binary-utils/memory-conversion-utils.ts
+  function ensureArrayBuffer(bufferSource) {
+    if (bufferSource instanceof ArrayBuffer) {
+      return bufferSource;
+    }
+    if (isSharedArrayBuffer(bufferSource)) {
+      return copyToArrayBuffer(bufferSource);
+    }
+    const { buffer, byteOffset, byteLength } = bufferSource;
+    if (buffer instanceof ArrayBuffer && byteOffset === 0 && byteLength === buffer.byteLength) {
+      return buffer;
+    }
+    return copyToArrayBuffer(buffer, byteOffset, byteLength);
+  }
+  function copyToArrayBuffer(buffer, byteOffset = 0, byteLength = buffer.byteLength - byteOffset) {
+    const view = new Uint8Array(buffer, byteOffset, byteLength);
+    const copy = new Uint8Array(view.length);
+    copy.set(view);
+    return copy.buffer;
+  }
+
   // ../images/src/lib/category-api/image-type.ts
   var parseImageNode = globalThis.loaders?.parseImageNode;
   var IMAGE_SUPPORTED = typeof Image !== "undefined";
@@ -468,7 +523,6 @@ var __exports__ = (() => {
   }
 
   // ../images/src/lib/parsers/parse-to-image-bitmap.ts
-  var EMPTY_OBJECT = {};
   var imagebitmapOptionsSupported = true;
   async function parseToImageBitmap(arrayBuffer, options, url) {
     let blob;
@@ -496,8 +550,13 @@ var __exports__ = (() => {
     return await createImageBitmap(blob);
   }
   function isEmptyObject(object) {
-    for (const key in object || EMPTY_OBJECT) {
-      return false;
+    if (!object) {
+      return true;
+    }
+    for (const key in object) {
+      if (Object.prototype.hasOwnProperty.call(object, key)) {
+        return false;
+      }
     }
     return true;
   }
@@ -1518,7 +1577,7 @@ var __exports__ = (() => {
       buffer = bufferArray.slice(offset, offset + byteLength).buffer;
       offset = 0;
     }
-    return new ArrayType(buffer, offset, length);
+    return new ArrayType(ensureArrayBuffer(buffer), offset, length);
   }
   function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
     const texCoordAccessorKey = `TEXCOORD_${textureInfo.texCoord || 0}`;
@@ -2276,7 +2335,7 @@ var __exports__ = (() => {
   }
   function createBufferView(typedArray, scenegraph) {
     scenegraph.gltf.buffers.push({
-      arrayBuffer: typedArray.buffer,
+      arrayBuffer: ensureArrayBuffer(typedArray.buffer),
       byteOffset: typedArray.byteOffset,
       byteLength: typedArray.byteLength
     });
@@ -2799,18 +2858,18 @@ var __exports__ = (() => {
     bgr565: { basisFormat: 15, compressed: false },
     rgba4444: { basisFormat: 16, compressed: false }
   };
-  async function parseBasis(data, options) {
-    if (options.basis.containerFormat === "auto") {
+  async function parseBasis(data, options = {}) {
+    if (!options.basis?.containerFormat || options.basis.containerFormat === "auto") {
       if (isKTX(data)) {
-        const fileConstructors = await loadBasisEncoderModule(options);
+        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
         return parseKTX2File(fileConstructors.KTX2File, data, options);
       }
-      const { BasisFile } = await loadBasisTranscoderModule(options);
+      const { BasisFile } = await loadBasisTranscoderModule(options?.core || {});
       return parseBasisFile(BasisFile, data, options);
     }
     switch (options.basis.module) {
       case "encoder":
-        const fileConstructors = await loadBasisEncoderModule(options);
+        const fileConstructors = await loadBasisEncoderModule(options?.core || {});
         switch (options.basis.containerFormat) {
           case "ktx2":
             return parseKTX2File(fileConstructors.KTX2File, data, options);
@@ -2820,7 +2879,7 @@ var __exports__ = (() => {
         }
       case "transcoder":
       default:
-        const { BasisFile } = await loadBasisTranscoderModule(options);
+        const { BasisFile } = await loadBasisTranscoderModule(options.core || {});
         return parseBasisFile(BasisFile, data, options);
     }
   }
@@ -2923,7 +2982,7 @@ var __exports__ = (() => {
     };
   }
   function getBasisOptions(options, hasAlpha) {
-    let format = options && options.basis && options.basis.format;
+    let format = options.basis?.format;
     if (format === "auto") {
       format = selectSupportedBasisFormat();
     }
@@ -3098,7 +3157,7 @@ var __exports__ = (() => {
     if (absolute) {
       return url;
     }
-    const baseUrl = options.baseUri || options.uri;
+    const baseUrl = options?.core?.baseUri || options.baseUri || options.uri;
     if (!baseUrl) {
       throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
     }
@@ -3416,35 +3475,126 @@ var __exports__ = (() => {
     preprocess: () => preprocess3
   });
 
-  // ../draco/src/lib/utils/version.ts
-  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-
-  // ../draco/src/draco-loader.ts
-  var DracoLoader = {
-    dataType: null,
-    batchType: null,
-    name: "Draco",
-    id: "draco",
-    module: "draco",
-    // shapes: ['mesh'],
-    version: VERSION5,
-    worker: true,
-    extensions: ["drc"],
-    mimeTypes: ["application/octet-stream"],
-    binary: true,
-    tests: ["DRACO"],
-    options: {
-      draco: {
-        decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
-        // 'js' for IE11
-        libraryPath: "libs/",
-        extraAttributes: {},
-        attributeNameEntry: void 0
+  // ../draco/src/lib/draco-module-loader.ts
+  var DRACO_DECODER_VERSION = "1.5.6";
+  var DRACO_ENCODER_VERSION = "1.4.1";
+  var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
+  var DRACO_EXTERNAL_LIBRARIES = {
+    /** The primary Draco3D encoder, javascript wrapper part */
+    DECODER: "draco_wasm_wrapper.js",
+    /** The primary draco decoder, compiled web assembly part */
+    DECODER_WASM: "draco_decoder.wasm",
+    /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
+    FALLBACK_DECODER: "draco_decoder.js",
+    /** Draco encoder */
+    ENCODER: "draco_encoder.js"
+  };
+  var DRACO_EXTERNAL_LIBRARY_URLS = {
+    [DRACO_EXTERNAL_LIBRARIES.DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER}`,
+    [DRACO_EXTERNAL_LIBRARIES.DECODER_WASM]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER_WASM}`,
+    [DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER}`,
+    [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
+  };
+  var loadDecoderPromise;
+  async function loadDracoDecoderModule(options = {}, type) {
+    const modules = options.modules || {};
+    if (modules.draco3d) {
+      loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
+        return { draco };
+      });
+    } else {
+      loadDecoderPromise ||= loadDracoDecoder(options, type);
+    }
+    return await loadDecoderPromise;
+  }
+  function getLibraryExport(library, exportName) {
+    if (library && typeof library === "object") {
+      if (library.default) {
+        return library.default;
+      }
+      if (library[exportName]) {
+        return library[exportName];
       }
     }
-  };
+    return library;
+  }
+  async function loadDracoDecoder(options, type) {
+    let DracoDecoderModule;
+    let wasmBinary;
+    switch (type) {
+      case "js":
+        DracoDecoderModule = await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
+          "draco",
+          options,
+          DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER
+        );
+        break;
+      case "wasm":
+      default:
+        try {
+          [DracoDecoderModule, wasmBinary] = await Promise.all([
+            await loadLibrary(
+              DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+              "draco",
+              options,
+              DRACO_EXTERNAL_LIBRARIES.DECODER
+            ),
+            await loadLibrary(
+              DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+              "draco",
+              options,
+              DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+            )
+          ]);
+        } catch {
+          DracoDecoderModule = null;
+          wasmBinary = null;
+        }
+    }
+    DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
+    DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+    if (!DracoDecoderModule && !isBrowser2) {
+      [DracoDecoderModule, wasmBinary] = await Promise.all([
+        await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
+          "draco",
+          { ...options, useLocalLibraries: true },
+          DRACO_EXTERNAL_LIBRARIES.DECODER
+        ),
+        await loadLibrary(
+          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
+          "draco",
+          { ...options, useLocalLibraries: true },
+          DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
+        )
+      ]);
+      DracoDecoderModule = getLibraryExport(DracoDecoderModule, "DracoDecoderModule");
+      DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
+    }
+    return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
+  }
+  function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
+    if (typeof DracoDecoderModule !== "function") {
+      throw new Error("DracoDecoderModule could not be loaded");
+    }
+    const options = {};
+    if (wasmBinary) {
+      options.wasmBinary = wasmBinary;
+    }
+    return new Promise((resolve) => {
+      DracoDecoderModule({
+        ...options,
+        onModuleLoaded: (draco) => resolve({ draco })
+        // Module is Promise-like. Wrap in object to avoid loop.
+      });
+    });
+  }
 
-  // ../schema/src/lib/table/simple-table/data-type.ts
+  // ../draco/src/lib/utils/version.ts
+  var VERSION5 = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
+
+  // ../schema-utils/src/lib/schema/data-type.ts
   function getDataTypeFromTypedArray(array) {
     switch (array.constructor) {
       case Int8Array:
@@ -3469,7 +3619,7 @@ var __exports__ = (() => {
     }
   }
 
-  // ../schema/src/lib/mesh/mesh-utils.ts
+  // ../schema-utils/src/lib/mesh/mesh-utils.ts
   function getMeshBoundingBox(attributes) {
     let minX = Infinity;
     let minY = Infinity;
@@ -3496,7 +3646,7 @@ var __exports__ = (() => {
     ];
   }
 
-  // ../schema/src/lib/mesh/deduce-mesh-schema.ts
+  // ../schema-utils/src/lib/mesh/deduce-mesh-schema.ts
   function deduceMeshField(name12, attribute, optionalMetadata) {
     const type = getDataTypeFromTypedArray(attribute.value);
     const metadata = optionalMetadata ? optionalMetadata : makeMeshAttributeMetadata(attribute);
@@ -3720,6 +3870,7 @@ var __exports__ = (() => {
           case "triangle-strip":
             return {
               topology: "triangle-strip",
+              // TODO - mode is wrong?
               mode: 4,
               // GL.TRIANGLES
               attributes,
@@ -3732,6 +3883,7 @@ var __exports__ = (() => {
           default:
             return {
               topology: "triangle-list",
+              // TODO - mode is wrong?
               mode: 5,
               // GL.TRIANGLE_STRIP
               attributes,
@@ -4016,91 +4168,39 @@ var __exports__ = (() => {
     return intArray;
   }
 
-  // ../draco/src/lib/draco-module-loader.ts
-  var DRACO_DECODER_VERSION = "1.5.6";
-  var DRACO_ENCODER_VERSION = "1.4.1";
-  var STATIC_DECODER_URL = `https://www.gstatic.com/draco/versioned/decoders/${DRACO_DECODER_VERSION}`;
-  var DRACO_EXTERNAL_LIBRARIES = {
-    /** The primary Draco3D encoder, javascript wrapper part */
-    DECODER: "draco_wasm_wrapper.js",
-    /** The primary draco decoder, compiled web assembly part */
-    DECODER_WASM: "draco_decoder.wasm",
-    /** Fallback decoder for non-webassebly environments. Very big bundle, lower performance */
-    FALLBACK_DECODER: "draco_decoder.js",
-    /** Draco encoder */
-    ENCODER: "draco_encoder.js"
-  };
-  var DRACO_EXTERNAL_LIBRARY_URLS = {
-    [DRACO_EXTERNAL_LIBRARIES.DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER}`,
-    [DRACO_EXTERNAL_LIBRARIES.DECODER_WASM]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.DECODER_WASM}`,
-    [DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER]: `${STATIC_DECODER_URL}/${DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER}`,
-    [DRACO_EXTERNAL_LIBRARIES.ENCODER]: `https://raw.githubusercontent.com/google/draco/${DRACO_ENCODER_VERSION}/javascript/${DRACO_EXTERNAL_LIBRARIES.ENCODER}`
-  };
-  var loadDecoderPromise;
-  async function loadDracoDecoderModule(options) {
-    const modules = options.modules || {};
-    if (modules.draco3d) {
-      loadDecoderPromise ||= modules.draco3d.createDecoderModule({}).then((draco) => {
-        return { draco };
-      });
-    } else {
-      loadDecoderPromise ||= loadDracoDecoder(options);
-    }
-    return await loadDecoderPromise;
-  }
-  async function loadDracoDecoder(options) {
-    let DracoDecoderModule;
-    let wasmBinary;
-    switch (options.draco && options.draco.decoderType) {
-      case "js":
-        DracoDecoderModule = await loadLibrary(
-          DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER],
-          "draco",
-          options,
-          DRACO_EXTERNAL_LIBRARIES.FALLBACK_DECODER
-        );
-        break;
-      case "wasm":
-      default:
-        [DracoDecoderModule, wasmBinary] = await Promise.all([
-          await loadLibrary(
-            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER],
-            "draco",
-            options,
-            DRACO_EXTERNAL_LIBRARIES.DECODER
-          ),
-          await loadLibrary(
-            DRACO_EXTERNAL_LIBRARY_URLS[DRACO_EXTERNAL_LIBRARIES.DECODER_WASM],
-            "draco",
-            options,
-            DRACO_EXTERNAL_LIBRARIES.DECODER_WASM
-          )
-        ]);
-    }
-    DracoDecoderModule = DracoDecoderModule || globalThis.DracoDecoderModule;
-    return await initializeDracoDecoder(DracoDecoderModule, wasmBinary);
-  }
-  function initializeDracoDecoder(DracoDecoderModule, wasmBinary) {
-    const options = {};
-    if (wasmBinary) {
-      options.wasmBinary = wasmBinary;
+  // ../draco/src/draco-loader.ts
+  var DracoWorkerLoader = {
+    dataType: null,
+    batchType: null,
+    name: "Draco",
+    id: "draco",
+    module: "draco",
+    // shapes: ['mesh'],
+    version: VERSION5,
+    worker: true,
+    extensions: ["drc"],
+    mimeTypes: ["application/octet-stream"],
+    binary: true,
+    tests: ["DRACO"],
+    options: {
+      draco: {
+        decoderType: typeof WebAssembly === "object" ? "wasm" : "js",
+        // 'js' for IE11
+        libraryPath: "libs/",
+        extraAttributes: {},
+        attributeNameEntry: void 0
+      }
     }
-    return new Promise((resolve) => {
-      DracoDecoderModule({
-        ...options,
-        onModuleLoaded: (draco) => resolve({ draco })
-        // Module is Promise-like. Wrap in object to avoid loop.
-      });
-    });
-  }
-
-  // ../draco/src/index.ts
-  var DracoLoader2 = {
-    ...DracoLoader,
+  };
+  var DracoLoader = {
+    ...DracoWorkerLoader,
     parse
   };
   async function parse(arrayBuffer, options) {
-    const { draco } = await loadDracoDecoderModule(options);
+    const { draco } = await loadDracoDecoderModule(
+      options?.core,
+      options?.draco?.decoderType || "wasm"
+    );
     const dracoParser = new DracoParser(draco);
     try {
       return dracoParser.parseSync(arrayBuffer, options?.draco);
@@ -4211,7 +4311,7 @@ var __exports__ = (() => {
     const bufferCopy = sliceArrayBuffer(buffer.buffer, buffer.byteOffset);
     const dracoOptions = { ...options };
     delete dracoOptions["3d-tiles"];
-    const decodedData = await parseFromContext(bufferCopy, DracoLoader2, dracoOptions, context);
+    const decodedData = await parseFromContext(bufferCopy, DracoLoader, dracoOptions, context);
     const decodedAttributes = getGLTFAccessors(decodedData.attributes);
     for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
       if (attributeName in primitive.attributes) {
@@ -5564,7 +5664,7 @@ var __exports__ = (() => {
     const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];
     if (Number.isFinite(texCoordAccessor)) {
       const accessor = gltfData.json.accessors?.[texCoordAccessor];
-      if (accessor && accessor.bufferView) {
+      if (accessor && accessor.bufferView !== void 0) {
         const bufferView = gltfData.json.bufferViews?.[accessor.bufferView];
         if (bufferView) {
           const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
@@ -5581,7 +5681,7 @@ var __exports__ = (() => {
             result.set([scratchVector[0], scratchVector[1]], i * components);
           }
           if (originalTexCoord === texCoord) {
-            updateGltf(accessor, bufferView, gltfData.buffers, result);
+            updateGltf(accessor, gltfData, result, accessor.bufferView);
           } else {
             createAttribute(texCoord, accessor, primitive, gltfData, result);
           }
@@ -5589,28 +5689,49 @@ var __exports__ = (() => {
       }
     }
   }
-  function updateGltf(accessor, bufferView, buffers, newTexCoordArray) {
+  function updateGltf(accessor, gltfData, newTexCoordArray, originalBufferViewIndex) {
     accessor.componentType = 5126;
-    buffers.push({
-      arrayBuffer: newTexCoordArray.buffer,
+    accessor.byteOffset = 0;
+    const accessors = gltfData.json.accessors || [];
+    const bufferViewReferenceCount = accessors.reduce((count, currentAccessor) => {
+      return currentAccessor.bufferView === originalBufferViewIndex ? count + 1 : count;
+    }, 0);
+    const shouldCreateNewBufferView = bufferViewReferenceCount > 1;
+    gltfData.buffers.push({
+      arrayBuffer: ensureArrayBuffer(newTexCoordArray.buffer),
       byteOffset: 0,
       byteLength: newTexCoordArray.buffer.byteLength
     });
-    bufferView.buffer = buffers.length - 1;
-    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+    const newBufferIndex = gltfData.buffers.length - 1;
+    gltfData.json.bufferViews = gltfData.json.bufferViews || [];
+    if (shouldCreateNewBufferView) {
+      gltfData.json.bufferViews.push({
+        buffer: newBufferIndex,
+        byteLength: newTexCoordArray.buffer.byteLength,
+        byteOffset: 0
+      });
+      accessor.bufferView = gltfData.json.bufferViews.length - 1;
+      return;
+    }
+    const bufferView = gltfData.json.bufferViews[originalBufferViewIndex];
+    if (!bufferView) {
+      return;
+    }
+    bufferView.buffer = newBufferIndex;
     bufferView.byteOffset = 0;
-    delete bufferView.byteStride;
+    bufferView.byteLength = newTexCoordArray.buffer.byteLength;
+    if (bufferView.byteStride !== void 0) {
+      delete bufferView.byteStride;
+    }
   }
   function createAttribute(newTexCoord, originalAccessor, primitive, gltfData, newTexCoordArray) {
     gltfData.buffers.push({
-      arrayBuffer: newTexCoordArray.buffer,
+      arrayBuffer: ensureArrayBuffer(newTexCoordArray.buffer),
       byteOffset: 0,
       byteLength: newTexCoordArray.buffer.byteLength
     });
+    gltfData.json.bufferViews = gltfData.json.bufferViews || [];
     const bufferViews = gltfData.json.bufferViews;
-    if (!bufferViews) {
-      return;
-    }
     bufferViews.push({
       buffer: gltfData.buffers.length - 1,
       byteLength: newTexCoordArray.buffer.byteLength,
@@ -6086,10 +6207,10 @@ var __exports__ = (() => {
     return gltf;
   }
   function parseGLTFContainerSync(gltf, data, byteOffset, options) {
-    if (options.uri) {
-      gltf.baseUri = options.uri;
+    if (options.core?.baseUri) {
+      gltf.baseUri = options.core?.baseUri;
     }
-    if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options)) {
+    if (data instanceof ArrayBuffer && !isGLB(data, byteOffset, options.glb)) {
       const textDecoder = new TextDecoder();
       data = textDecoder.decode(data);
     }
@@ -6177,14 +6298,16 @@ var __exports__ = (() => {
       arrayBuffer = sliceArrayBuffer(array.buffer, array.byteOffset, array.byteLength);
     }
     assert3(arrayBuffer, "glTF image has no data");
+    const strictOptions = options;
+    const gltfOptions = {
+      ...strictOptions,
+      core: { ...strictOptions?.core, mimeType: image.mimeType },
+      basis: strictOptions.basis || { format: selectSupportedBasisFormat() }
+    };
     let parsedImage = await parseFromContext(
       arrayBuffer,
       [ImageLoader, BasisLoader],
-      {
-        ...options,
-        mimeType: image.mimeType,
-        basis: options.basis || { format: selectSupportedBasisFormat() }
-      },
+      gltfOptions,
       context
     );
     if (parsedImage && parsedImage[0]) {
@@ -6225,18 +6348,15 @@ var __exports__ = (() => {
         // Create image objects
         decompressMeshes: true
         // Decompress Draco encoded meshes
-      },
-      // common?
-      log: console
-      // eslint-disable-line
+      }
     }
   };
   async function parse2(arrayBuffer, options = {}, context) {
-    options = { ...GLTFLoader.options, ...options };
-    options.gltf = { ...GLTFLoader.options.gltf, ...options.gltf };
-    const { byteOffset = 0 } = options;
+    const mergedOptions = { ...GLTFLoader.options, ...options };
+    mergedOptions.gltf = { ...GLTFLoader.options.gltf, ...mergedOptions.gltf };
+    const byteOffset = options?.glb?.byteOffset || 0;
     const gltf = {};
-    return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
+    return await parseGLTF(gltf, arrayBuffer, byteOffset, mergedOptions, context);
   }
 
   // src/lib/encoders/encode-glb.ts
@@ -6350,9 +6470,8 @@ var __exports__ = (() => {
     return parseSync(arrayBuffer, options);
   }
   function parseSync(arrayBuffer, options) {
-    const { byteOffset = 0 } = options || {};
     const glb = {};
-    parseGLBSync(glb, arrayBuffer, byteOffset, options?.glb);
+    parseGLBSync(glb, arrayBuffer, options?.glb?.byteOffset || 0, options?.glb);
     return glb;
   }
 
@@ -6683,7 +6802,7 @@ var __exports__ = (() => {
         const buffer = accessor.bufferView.buffer;
         const { ArrayType, byteLength } = getAccessorArrayTypeAndLength(accessor, accessor.bufferView);
         const byteOffset = (accessor.bufferView.byteOffset || 0) + (accessor.byteOffset || 0) + buffer.byteOffset;
-        let cutBuffer = buffer.arrayBuffer.slice(byteOffset, byteOffset + byteLength);
+        let cutBuffer = copyToArrayBuffer(buffer.arrayBuffer, byteOffset, byteLength);
         if (accessor.bufferView.byteStride) {
           cutBuffer = this._getValueFromInterleavedBuffer(
             buffer,