@loaders.gl/gltf 4.4.0-alpha.2 → 4.4.0

package/dist/gltf-loader.d.ts

@@ -1,4 +1,4 @@
-import type { LoaderOptions } from '@loaders.gl/loader-utils';
+import type { StrictLoaderOptions } from '@loaders.gl/loader-utils';
 import type { DracoLoaderOptions } from '@loaders.gl/draco';
 import type { ImageLoaderOptions } from '@loaders.gl/images';
 import type { TextureLoaderOptions } from '@loaders.gl/textures';
@@ -8,7 +8,7 @@ import type { GLBLoaderOptions } from "./glb-loader.js";
 /**
  * GLTF loader options
  */
-export type GLTFLoaderOptions = LoaderOptions & ImageLoaderOptions & TextureLoaderOptions & GLBLoaderOptions & DracoLoaderOptions & {
+export type GLTFLoaderOptions = StrictLoaderOptions & ImageLoaderOptions & TextureLoaderOptions & GLBLoaderOptions & DracoLoaderOptions & {
     gltf?: ParseGLTFOptions;
 };
 /**
@@ -34,7 +34,6 @@ export declare const GLTFLoader: {
             readonly loadImages: true;
             readonly decompressMeshes: true;
         };
-        readonly log: Console;
     };
 };
 export declare function parse(arrayBuffer: any, options: GLTFLoaderOptions | undefined, context: any): Promise<GLTFWithBuffers>;

package/dist/gltf-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gltf-loader.d.ts","sourceRoot":"","sources":["../src/gltf-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAC9E,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAE1D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAC,gBAAgB,EAAC,oCAAiC;AAC/D,OAAO,KAAK,EAAC,eAAe,EAAC,kCAA+B;AAC5D,OAAO,KAAK,EAAC,gBAAgB,EAAC,wBAAqB;AAGnD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,aAAa,GAC3C,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,GAChB,kBAAkB,GAAG;IACnB,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,UAAU;uBACQ,eAAe;wBACzB,KAAK;;;;;;;;;;;;;;;;;;;;CAwBqD,CAAC;AAEhF,wBAAsB,KAAK,CACzB,WAAW,KAAA,EACX,OAAO,EAAE,iBAAiB,YAAK,EAC/B,OAAO,KAAA,GACN,OAAO,CAAC,eAAe,CAAC,CAS1B"}
+{"version":3,"file":"gltf-loader.d.ts","sourceRoot":"","sources":["../src/gltf-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,mBAAmB,EAAC,MAAM,0BAA0B,CAAC;AACpF,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,mBAAmB,CAAC;AAE1D,OAAO,KAAK,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,KAAK,EAAC,oBAAoB,EAAC,MAAM,sBAAsB,CAAC;AAC/D,OAAO,KAAK,EAAC,gBAAgB,EAAC,oCAAiC;AAC/D,OAAO,KAAK,EAAC,eAAe,EAAC,kCAA+B;AAC5D,OAAO,KAAK,EAAC,gBAAgB,EAAC,wBAAqB;AAGnD;;GAEG;AACH,MAAM,MAAM,iBAAiB,GAAG,mBAAmB,GACjD,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,GAChB,kBAAkB,GAAG;IACnB,IAAI,CAAC,EAAE,gBAAgB,CAAC;CACzB,CAAC;AAEJ;;GAEG;AACH,eAAO,MAAM,UAAU;uBACQ,eAAe;wBACzB,KAAK;;;;;;;;;;;;;;;;;;;CAqBsD,CAAC;AAEjF,wBAAsB,KAAK,CACzB,WAAW,KAAA,EACX,OAAO,EAAE,iBAAiB,YAAK,EAC/B,OAAO,KAAA,GACN,OAAO,CAAC,eAAe,CAAC,CAQ1B"}

package/dist/gltf-loader.js

@@ -22,17 +22,15 @@ export const GLTFLoader = {
             loadBuffers: true, // Fetch any linked .BIN buffers, decode base64
             loadImages: true, // Create image objects
             decompressMeshes: true // Decompress Draco encoded meshes
-        },
-        // common?
-        log: console // eslint-disable-line
+        }
     }
 };
 export async function parse(arrayBuffer, options = {}, context) {
     // Apps can call the parse method directly, we so apply default options here
-    options = { ...GLTFLoader.options, ...options };
-    // @ts-ignore
-    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);
 }
+//# sourceMappingURL=gltf-loader.js.map

package/dist/gltf-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-loader.js","sourceRoot":"","sources":["../src/gltf-loader.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,OAAO,EAAC,+BAA4B;AAM5C,OAAO,EAAC,SAAS,EAAC,oCAAiC;AAanD;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,QAAQ,EAAE,IAAkC;IAC5C,SAAS,EAAE,IAAa;IACxB,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,MAAM;IACV,MAAM,EAAE,MAAM;IACd,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC;IAC3B,SAAS,EAAE,CAAC,iBAAiB,EAAE,mBAAmB,CAAC;IAEnD,IAAI,EAAE,IAAI;IACV,MAAM,EAAE,IAAI;IACZ,KAAK,EAAE,CAAC,MAAM,CAAC;IACf,KAAK;IAEL,OAAO,EAAE;QACP,IAAI,EAAE;YACJ,SAAS,EAAE,IAAI,EAAE,uDAAuD;YACxE,WAAW,EAAE,IAAI,EAAE,+CAA+C;YAClE,UAAU,EAAE,IAAI,EAAE,uBAAuB;YACzC,gBAAgB,EAAE,IAAI,CAAC,kCAAkC;SAC1D;KACF;CAC6E,CAAC;AAEjF,MAAM,CAAC,KAAK,UAAU,KAAK,CACzB,WAAW,EACX,UAA6B,EAAE,EAC/B,OAAO;IAEP,4EAA4E;IAC5E,MAAM,aAAa,GAAG,EAAC,GAAG,UAAU,CAAC,OAAO,EAAE,GAAG,OAAO,EAAC,CAAC;IAC1D,aAAa,CAAC,IAAI,GAAG,EAAC,GAAG,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,GAAG,aAAa,CAAC,IAAI,EAAC,CAAC;IAEzE,MAAM,UAAU,GAAG,OAAO,EAAE,GAAG,EAAE,UAAU,IAAI,CAAC,CAAC;IACjD,MAAM,IAAI,GAAG,EAAE,CAAC;IAChB,OAAO,MAAM,SAAS,CAAC,IAAuB,EAAE,WAAW,EAAE,UAAU,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;AACnG,CAAC"}

package/dist/gltf-writer.js

@@ -30,3 +30,4 @@ function encodeSync(gltf, options = {}) {
     encodeGLTFSync(gltfToEncode, dataView, byteOffset, options);
     return arrayBuffer;
 }
+//# sourceMappingURL=gltf-writer.js.map

package/dist/gltf-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gltf-writer.js","sourceRoot":"","sources":["../src/gltf-writer.ts"],"names":[],"mappings":"AACA,OAAO,EAAC,OAAO,EAAC,+BAA4B;AAC5C,OAAO,EAAC,cAAc,EAAC,sCAAmC;AAE1D,OAAO,EAAC,gBAAgB,EAAC,qCAAkC;AAO3D;;GAEG;AACH,MAAM,CAAC,MAAM,UAAU,GAAG;IACxB,QAAQ,EAAE,IAAsB;IAChC,SAAS,EAAE,IAAa;IAExB,IAAI,EAAE,MAAM;IACZ,EAAE,EAAE,MAAM;IACV,MAAM,EAAE,MAAM;IACd,OAAO,EAAE,OAAO;IAEhB,UAAU,EAAE,CAAC,KAAK,CAAC,EAAE,2DAA2D;IAChF,SAAS,EAAE,CAAC,mBAAmB,CAAC,EAAE,qBAAqB;IACvD,MAAM,EAAE,IAAI;IACZ,OAAO,EAAE;QACP,IAAI,EAAE,EAAE;KACT;IAED,MAAM,EAAE,KAAK,EAAE,IAAqB,EAAE,UAA6B,EAAE,EAAE,EAAE,CACvE,UAAU,CAAC,IAAI,EAAE,OAAO,CAAC;IAC3B,UAAU;CACyC,CAAC;AAEtD,SAAS,UAAU,CAAC,IAAqB,EAAE,UAA6B,EAAE;IACxE,MAAM,EAAC,UAAU,GAAG,CAAC,EAAC,GAAG,OAAO,CAAC;IACjC,MAAM,YAAY,GAAG,gBAAgB,CAAC,IAAI,CAAC,CAAC;IAE5C,uDAAuD;IACvD,MAAM,UAAU,GAAG,cAAc,CAAC,YAAY,EAAE,IAAI,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAC3E,MAAM,WAAW,GAAG,IAAI,WAAW,CAAC,UAAU,CAAC,CAAC;IAChD,MAAM,QAAQ,GAAG,IAAI,QAAQ,CAAC,WAAW,CAAC,CAAC;IAC3C,cAAc,CAAC,YAAY,EAAE,QAAQ,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC;IAE5D,OAAO,WAAW,CAAC;AACrB,CAAC"}

package/dist/index.cjs

@@ -720,6 +720,7 @@ var GLTFScenegraph = class {
 
 // dist/lib/extensions/utils/3d-tiles-utils.js
 var import_images2 = require("@loaders.gl/images");
+var import_loader_utils2 = require("@loaders.gl/loader-utils");
 function emod(n) {
   return (n % 1 + 1) % 1;
 }
@@ -793,7 +794,7 @@ function convertRawBufferToMetadataArray(data, attributeType, componentType, ele
     buffer = bufferArray.slice(offset, offset + byteLength).buffer;
     offset = 0;
   }
-  return new ArrayType(buffer, offset, length);
+  return new ArrayType((0, import_loader_utils2.ensureArrayBuffer)(buffer), offset, length);
 }
 function getPrimitiveTextureData(scenegraph, textureInfo, primitive) {
   var _a, _b, _c, _d, _e;
@@ -1055,6 +1056,7 @@ __export(EXT_structural_metadata_exports, {
   encode: () => encode2,
   name: () => name2
 });
+var import_loader_utils3 = require("@loaders.gl/loader-utils");
 var EXT_STRUCTURAL_METADATA_NAME = "EXT_structural_metadata";
 var name2 = EXT_STRUCTURAL_METADATA_NAME;
 async function decode2(gltfData, options) {
@@ -1480,7 +1482,7 @@ function createPropertyDataString(strings) {
 }
 function createBufferView(typedArray, scenegraph) {
   scenegraph.gltf.buffers.push({
-    arrayBuffer: typedArray.buffer,
+    arrayBuffer: (0, import_loader_utils3.ensureArrayBuffer)(typedArray.buffer),
     byteOffset: typedArray.byteOffset,
     byteLength: typedArray.byteLength
   });
@@ -1693,15 +1695,15 @@ function processPrimitiveTextures(scenegraph, attributeName, featureTexturePrope
 }
 
 // dist/lib/utils/version.js
-var VERSION = true ? "4.4.0-alpha.1" : "latest";
+var VERSION = true ? "4.4.0" : "latest";
 
 // dist/lib/parsers/parse-gltf.js
-var import_loader_utils4 = require("@loaders.gl/loader-utils");
+var import_loader_utils7 = require("@loaders.gl/loader-utils");
 var import_images4 = require("@loaders.gl/images");
 var import_textures = require("@loaders.gl/textures");
 
 // dist/lib/parsers/parse-glb.js
-var import_loader_utils2 = require("@loaders.gl/loader-utils");
+var import_loader_utils4 = require("@loaders.gl/loader-utils");
 var LITTLE_ENDIAN = true;
 var MAGIC_glTF = 1735152710;
 var GLB_FILE_HEADER_SIZE = 12;
@@ -1749,18 +1751,18 @@ function parseGLBSync(glb, arrayBuffer, byteOffset = 0, options = {}) {
   }
 }
 function parseGLBV1(glb, dataView, byteOffset) {
-  (0, import_loader_utils2.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+  (0, import_loader_utils4.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
   const contentLength = dataView.getUint32(byteOffset + 0, LITTLE_ENDIAN);
   const contentFormat = dataView.getUint32(byteOffset + 4, LITTLE_ENDIAN);
   byteOffset += GLB_CHUNK_HEADER_SIZE;
-  (0, import_loader_utils2.assert)(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
+  (0, import_loader_utils4.assert)(contentFormat === GLB_V1_CONTENT_FORMAT_JSON);
   parseJSONChunk(glb, dataView, byteOffset, contentLength);
   byteOffset += contentLength;
   byteOffset += parseBINChunk(glb, dataView, byteOffset, glb.header.byteLength);
   return byteOffset;
 }
 function parseGLBV2(glb, dataView, byteOffset, options) {
-  (0, import_loader_utils2.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
+  (0, import_loader_utils4.assert)(glb.header.byteLength > GLB_FILE_HEADER_SIZE + GLB_CHUNK_HEADER_SIZE);
   parseGLBChunksSync(glb, dataView, byteOffset, options);
   return byteOffset + glb.header.byteLength;
 }
@@ -1789,7 +1791,7 @@ function parseGLBChunksSync(glb, dataView, byteOffset, options) {
       default:
         break;
     }
-    byteOffset += (0, import_loader_utils2.padToNBytes)(chunkLength, 4);
+    byteOffset += (0, import_loader_utils4.padToNBytes)(chunkLength, 4);
   }
   return byteOffset;
 }
@@ -1798,7 +1800,7 @@ function parseJSONChunk(glb, dataView, byteOffset, chunkLength) {
   const textDecoder = new TextDecoder("utf8");
   const jsonText = textDecoder.decode(jsonChunk);
   glb.json = JSON.parse(jsonText);
-  return (0, import_loader_utils2.padToNBytes)(chunkLength, 4);
+  return (0, import_loader_utils4.padToNBytes)(chunkLength, 4);
 }
 function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
   glb.header.hasBinChunk = true;
@@ -1808,20 +1810,31 @@ function parseBINChunk(glb, dataView, byteOffset, chunkLength) {
     arrayBuffer: dataView.buffer
     // TODO - copy, or create typed array view?
   });
-  return (0, import_loader_utils2.padToNBytes)(chunkLength, 4);
+  return (0, import_loader_utils4.padToNBytes)(chunkLength, 4);
 }
 
 // dist/lib/gltf-utils/resolve-url.js
-function resolveUrl(url, options) {
+function resolveUrl(url, options, context) {
+  var _a;
   const absolute = url.startsWith("data:") || url.startsWith("http:") || url.startsWith("https:");
   if (absolute) {
     return url;
   }
-  const baseUrl = options.baseUri || options.uri;
+  const baseUrl = (context == null ? void 0 : context.baseUrl) || getResolveBaseUrl((_a = options == null ? void 0 : options.core) == null ? void 0 : _a.baseUrl);
   if (!baseUrl) {
-    throw new Error(`'baseUri' must be provided to resolve relative url ${url}`);
+    throw new Error(`'baseUrl' must be provided to resolve relative url ${url}`);
   }
-  return baseUrl.substr(0, baseUrl.lastIndexOf("/") + 1) + url;
+  return baseUrl.endsWith("/") ? `${baseUrl}${url}` : `${baseUrl}/${url}`;
+}
+function getResolveBaseUrl(baseUrl) {
+  if (!baseUrl) {
+    return void 0;
+  }
+  if (baseUrl.endsWith("/")) {
+    return baseUrl;
+  }
+  const slashIndex = baseUrl.lastIndexOf("/");
+  return slashIndex >= 0 ? baseUrl.slice(0, slashIndex + 1) : "";
 }
 
 // dist/lib/extensions/EXT_meshopt_compression.js
@@ -2107,7 +2120,7 @@ __export(KHR_draco_mesh_compression_exports, {
   name: () => name7,
   preprocess: () => preprocess3
 });
-var import_loader_utils3 = require("@loaders.gl/loader-utils");
+var import_loader_utils5 = require("@loaders.gl/loader-utils");
 var import_draco = require("@loaders.gl/draco");
 
 // dist/lib/gltf-utils/gltf-attribute-utils.js
@@ -2207,10 +2220,10 @@ async function decompressPrimitive(scenegraph, primitive, options, context) {
     return;
   }
   const buffer = scenegraph.getTypedArrayForBufferView(dracoExtension.bufferView);
-  const bufferCopy = (0, import_loader_utils3.sliceArrayBuffer)(buffer.buffer, buffer.byteOffset);
+  const bufferCopy = (0, import_loader_utils5.sliceArrayBuffer)(buffer.buffer, buffer.byteOffset);
   const dracoOptions = { ...options };
   delete dracoOptions["3d-tiles"];
-  const decodedData = await (0, import_loader_utils3.parseFromContext)(bufferCopy, import_draco.DracoLoader, dracoOptions, context);
+  const decodedData = await (0, import_loader_utils5.parseFromContext)(bufferCopy, import_draco.DracoLoader, dracoOptions, context);
   const decodedAttributes = getGLTFAccessors(decodedData.attributes);
   for (const [attributeName, decodedAttribute] of Object.entries(decodedAttributes)) {
     if (attributeName in primitive.attributes) {
@@ -2277,6 +2290,7 @@ __export(KHR_texture_transform_exports, {
   name: () => name8
 });
 var import_core = require("@math.gl/core");
+var import_loader_utils6 = require("@loaders.gl/loader-utils");
 var KHR_TEXTURE_TRANSFORM = "KHR_texture_transform";
 var name8 = KHR_TEXTURE_TRANSFORM;
 var scratchVector = new import_core.Vector3();
@@ -2348,7 +2362,7 @@ function transformPrimitive(gltfData, primitive, transformParameters) {
   const texCoordAccessor = primitive.attributes[`TEXCOORD_${originalTexCoord}`];
   if (Number.isFinite(texCoordAccessor)) {
     const accessor = (_a = gltfData.json.accessors) == null ? void 0 : _a[texCoordAccessor];
-    if (accessor && accessor.bufferView) {
+    if (accessor && accessor.bufferView !== void 0) {
       const bufferView = (_b = gltfData.json.bufferViews) == null ? void 0 : _b[accessor.bufferView];
       if (bufferView) {
         const { arrayBuffer, byteOffset: bufferByteOffset } = gltfData.buffers[bufferView.buffer];
@@ -2365,7 +2379,7 @@ function transformPrimitive(gltfData, primitive, transformParameters) {
           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);
         }
@@ -2373,28 +2387,49 @@ function transformPrimitive(gltfData, primitive, transformParameters) {
     }
   }
 }
-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: (0, import_loader_utils6.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: (0, import_loader_utils6.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,
@@ -2861,15 +2896,16 @@ async function parseGLTF(gltf, arrayBufferOrString, byteOffset = 0, options, con
   return gltf;
 }
 function parseGLTFContainerSync(gltf, data, byteOffset, options) {
-  if (options.uri) {
-    gltf.baseUri = options.uri;
+  var _a, _b;
+  if ((_a = options.core) == null ? void 0 : _a.baseUrl) {
+    gltf.baseUri = (_b = options.core) == null ? void 0 : _b.baseUrl;
   }
-  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);
   }
   if (typeof data === "string") {
-    gltf.json = (0, import_loader_utils4.parseJSON)(data);
+    gltf.json = (0, import_loader_utils7.parseJSON)(data);
   } else if (data instanceof ArrayBuffer) {
     const glb = {};
     byteOffset = parseGLBSync(glb, data, byteOffset, options.glb);
@@ -2900,7 +2936,7 @@ async function loadBuffers(gltf, options, context) {
     if (buffer.uri) {
       const { fetch } = context;
       assert(fetch);
-      const uri = resolveUrl(buffer.uri, options);
+      const uri = resolveUrl(buffer.uri, options, context);
       const response = await ((_a = context == null ? void 0 : context.fetch) == null ? void 0 : _a.call(context, uri));
       const arrayBuffer = await ((_b = response == null ? void 0 : response.arrayBuffer) == null ? void 0 : _b.call(response));
       gltf.buffers[i] = {
@@ -2940,7 +2976,7 @@ function getReferencesImageIndices(gltf) {
 async function loadImage(gltf, image, index, options, context) {
   let arrayBuffer;
   if (image.uri && !image.hasOwnProperty("bufferView")) {
-    const uri = resolveUrl(image.uri, options);
+    const uri = resolveUrl(image.uri, options, context);
     const { fetch } = context;
     const response = await fetch(uri);
     arrayBuffer = await response.arrayBuffer();
@@ -2950,14 +2986,15 @@ async function loadImage(gltf, image, index, options, context) {
   }
   if (Number.isFinite(image.bufferView)) {
     const array = getTypedArrayForBufferView(gltf.json, gltf.buffers, image.bufferView);
-    arrayBuffer = (0, import_loader_utils4.sliceArrayBuffer)(array.buffer, array.byteOffset, array.byteLength);
+    arrayBuffer = (0, import_loader_utils7.sliceArrayBuffer)(array.buffer, array.byteOffset, array.byteLength);
   }
   assert(arrayBuffer, "glTF image has no data");
-  let parsedImage = await (0, import_loader_utils4.parseFromContext)(arrayBuffer, [import_images4.ImageLoader, import_textures.BasisLoader], {
-    ...options,
-    mimeType: image.mimeType,
-    basis: options.basis || { format: (0, import_textures.selectSupportedBasisFormat)() }
-  }, context);
+  const strictOptions = options;
+  const gltfOptions = {
+    ...strictOptions,
+    core: { ...strictOptions == null ? void 0 : strictOptions.core, mimeType: image.mimeType }
+  };
+  let parsedImage = await (0, import_loader_utils7.parseFromContext)(arrayBuffer, [import_images4.ImageLoader, import_textures.BasisLoader], gltfOptions, context);
   if (parsedImage && parsedImage[0]) {
     parsedImage = {
       compressed: true,
@@ -2996,22 +3033,20 @@ var GLTFLoader = {
       // Create image objects
       decompressMeshes: true
       // Decompress Draco encoded meshes
-    },
-    // common?
-    log: console
-    // eslint-disable-line
+    }
   }
 };
 async function parse(arrayBuffer, options = {}, context) {
-  options = { ...GLTFLoader.options, ...options };
-  options.gltf = { ...GLTFLoader.options.gltf, ...options.gltf };
-  const { byteOffset = 0 } = options;
+  var _a;
+  const mergedOptions = { ...GLTFLoader.options, ...options };
+  mergedOptions.gltf = { ...GLTFLoader.options.gltf, ...mergedOptions.gltf };
+  const byteOffset = ((_a = options == null ? void 0 : options.glb) == null ? void 0 : _a.byteOffset) || 0;
   const gltf = {};
-  return await parseGLTF(gltf, arrayBuffer, byteOffset, options, context);
+  return await parseGLTF(gltf, arrayBuffer, byteOffset, mergedOptions, context);
 }
 
 // dist/lib/encoders/encode-glb.js
-var import_loader_utils5 = require("@loaders.gl/loader-utils");
+var import_loader_utils8 = require("@loaders.gl/loader-utils");
 var MAGIC_glTF2 = 1179937895;
 var MAGIC_JSON = 1313821514;
 var MAGIC_BIN = 5130562;
@@ -3033,7 +3068,7 @@ function encodeGLBSync(glb, dataView, byteOffset = 0, options = {}) {
   }
   byteOffset += 8;
   const jsonString = JSON.stringify(json);
-  byteOffset = (0, import_loader_utils5.copyPaddedStringToDataView)(dataView, byteOffset, jsonString, 4);
+  byteOffset = (0, import_loader_utils8.copyPaddedStringToDataView)(dataView, byteOffset, jsonString, 4);
   if (dataView) {
     const jsonByteLength = byteOffset - byteOffsetJsonHeader - 8;
     dataView.setUint32(byteOffsetJsonHeader + 0, jsonByteLength, LE);
@@ -3045,7 +3080,7 @@ function encodeGLBSync(glb, dataView, byteOffset = 0, options = {}) {
       dataView.setUint32(byteOffset + 4, MAGIC_BIN, LE);
     }
     byteOffset += 8;
-    byteOffset = (0, import_loader_utils5.copyPaddedArrayBufferToDataView)(dataView, byteOffset, binary, 4);
+    byteOffset = (0, import_loader_utils8.copyPaddedArrayBufferToDataView)(dataView, byteOffset, binary, 4);
     if (dataView) {
       const binByteLength = byteOffset - byteOffsetBinHeader - 8;
       dataView.setUint32(byteOffsetBinHeader + 0, binByteLength, LE);
@@ -3122,9 +3157,9 @@ async function parse2(arrayBuffer, options) {
   return parseSync(arrayBuffer, options);
 }
 function parseSync(arrayBuffer, options) {
-  const { byteOffset = 0 } = options || {};
+  var _a;
   const glb = {};
-  parseGLBSync(glb, arrayBuffer, byteOffset, options == null ? void 0 : options.glb);
+  parseGLBSync(glb, arrayBuffer, ((_a = options == null ? void 0 : options.glb) == null ? void 0 : _a.byteOffset) || 0, options == null ? void 0 : options.glb);
   return glb;
 }
 
@@ -3153,6 +3188,7 @@ function encodeSync2(glb, options) {
 }
 
 // dist/lib/api/post-process-gltf.js
+var import_loader_utils9 = require("@loaders.gl/loader-utils");
 var COMPONENTS2 = {
   SCALAR: 1,
   VEC2: 2,
@@ -3452,7 +3488,7 @@ var GLTFPostProcessor = class {
       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 = (0, import_loader_utils9.copyToArrayBuffer)(buffer.arrayBuffer, byteOffset, byteLength);
       if (accessor.bufferView.byteStride) {
         cutBuffer = this._getValueFromInterleavedBuffer(buffer, byteOffset, accessor.bufferView.byteStride, accessor.bytesPerElement, accessor.count);
       }