@inweb/viewer-three 26.10.6 → 26.11.0

package/dist/viewer-three.js

@@ -171,6 +171,14 @@
         cancel() {
             this.abortController.abort();
         }
+        extractFileName(file) {
+            const regex = /[^/\\?#:]+(?=\?|#|$)/;
+            if (typeof file === "string")
+                return (file.match(regex) || [])[0];
+            else if (file instanceof globalThis.File)
+                return (file.name.match(regex) || [])[0];
+            return undefined;
+        }
     };
     class Loaders {
         constructor() {
@@ -236,6 +244,7 @@
             enableGestures: true,
             geometryType: "vsfx",
             rulerUnit: "Default",
+            rulerPrecision: 2,
             cameraMode: "perspective",
         };
     }
@@ -492,6 +501,13 @@
             this._data.rulerUnit = value;
             this.change();
         }
+        get rulerPrecision() {
+            return this._data.rulerPrecision;
+        }
+        set rulerPrecision(value) {
+            this._data.rulerPrecision = value;
+            this.change();
+        }
         get cameraMode() {
             return this._data.cameraMode || "perspective";
         }
@@ -9059,7 +9075,7 @@
     	}
     }
     const _offsetMatrix =  new Matrix4();
-    const _identityMatrix$1 =  new Matrix4();
+    const _identityMatrix =  new Matrix4();
     class Skeleton {
     	constructor( bones = [], boneInverses = [] ) {
     		this.uuid = generateUUID();
@@ -9121,7 +9137,7 @@
     		const boneMatrices = this.boneMatrices;
     		const boneTexture = this.boneTexture;
     		for ( let i = 0, il = bones.length; i < il; i ++ ) {
-    			const matrix = bones[ i ] ? bones[ i ].matrixWorld : _identityMatrix$1;
+    			const matrix = bones[ i ] ? bones[ i ].matrixWorld : _identityMatrix;
     			_offsetMatrix.multiplyMatrices( matrix, boneInverses[ i ] );
     			_offsetMatrix.toArray( boneMatrices, i * 16 );
     		}
@@ -18451,7 +18467,7 @@
     	}
     }
     const _position =  new Vector3();
-    const _quaternion$5 =  new Quaternion();
+    const _quaternion =  new Quaternion();
     const _scale =  new Vector3();
     const _orientation =  new Vector3();
     class PositionalAudio extends Audio {
@@ -18511,8 +18527,8 @@
     	updateMatrixWorld( force ) {
     		super.updateMatrixWorld( force );
     		if ( this.hasPlaybackControl === true && this.isPlaying === false ) return;
-    		this.matrixWorld.decompose( _position, _quaternion$5, _scale );
-    		_orientation.set( 0, 0, 1 ).applyQuaternion( _quaternion$5 );
+    		this.matrixWorld.decompose( _position, _quaternion, _scale );
+    		_orientation.set( 0, 0, 1 ).applyQuaternion( _quaternion );
     		const panner = this.panner;
     		if ( panner.positionX ) {
     			const endTime = this.context.currentTime + this.listener.timeDelta;
@@ -33876,116 +33892,91 @@ void main() {
         }
     }
 
-    const PRECISION = 0.01;
-    const DESKTOP_SNAP_DISTANCE = 10;
-    const MOBILE_SNAP_DISTANCE = 50;
-    class MeasureLineDragger extends OrbitDragger {
-        constructor(viewer) {
-            super(viewer);
-            this.onPointerDown = (event) => {
-                if (event.button !== 0)
-                    return;
-                this.line.startPoint = this.snapper.getSnapPoint(event);
-                this.line.render();
-                this.viewer.canvas.setPointerCapture(event.pointerId);
-                this.orbit.enabled = !this.line.startPoint;
-            };
-            this.onPointerMove = (event) => {
-                if (this.orbit.enabled && this.orbit.state !== -1)
-                    return;
-                const snapPoint = this.snapper.getSnapPoint(event);
-                if (snapPoint && this.line.endPoint && snapPoint.equals(this.line.endPoint))
-                    return;
-                this.line.endPoint = snapPoint;
-                this.line.render();
-                if (this.line.startPoint)
-                    this.changed = true;
-            };
-            this.onPointerUp = (event) => {
-                if (this.line.startPoint && this.line.endPoint && this.line.getDistance() >= PRECISION) {
-                    this.line = new MeasureLine(this.overlay);
-                    this.overlay.addLine(this.line);
-                }
-                else {
-                    this.line.startPoint = undefined;
-                    this.line.endPoint = undefined;
-                    this.line.render();
-                }
-                this.viewer.canvas.releasePointerCapture(event.pointerId);
-                this.orbit.enabled = true;
-            };
-            this.onPointerCancel = (event) => {
-                this.viewer.canvas.dispatchEvent(new PointerEvent("pointerup", event));
-            };
-            this.onPointerLeave = () => {
-                this.line.endPoint = undefined;
-                this.line.render();
-            };
-            this.renderOverlay = () => {
-                this.overlay.render();
-            };
-            this.updateSnapper = () => {
-                this.snapper.setFromViewer(this.viewer);
-            };
-            this.updateSnapperCamera = () => {
-                this.snapper.camera = this.viewer.camera;
-                this.overlay.camera = this.viewer.camera;
-            };
-            this.overlay = new MeasureOverlay(viewer.camera, viewer.canvas);
-            this.overlay.attach();
-            this.line = new MeasureLine(this.overlay);
-            this.overlay.addLine(this.line);
-            this.snapper = new MeasureSnapper(viewer.camera, viewer.canvas);
-            this.updateSnapper();
-            this.viewer.canvas.addEventListener("pointerdown", this.onPointerDown);
-            this.viewer.canvas.addEventListener("pointermove", this.onPointerMove);
-            this.viewer.canvas.addEventListener("pointerup", this.onPointerUp);
-            this.viewer.canvas.addEventListener("pointercancel", this.onPointerCancel);
-            this.viewer.canvas.addEventListener("pointerleave", this.onPointerLeave);
-            this.viewer.addEventListener("render", this.renderOverlay);
-            this.viewer.addEventListener("hide", this.updateSnapper);
-            this.viewer.addEventListener("isolate", this.updateSnapper);
-            this.viewer.addEventListener("show", this.updateSnapper);
-            this.viewer.addEventListener("showall", this.updateSnapper);
-            this.viewer.addEventListener("changecameramode", this.updateSnapperCamera);
+    const ModelUnits = {
+        Meters: { name: "Meters", type: "m", scale: 1.0 },
+        Centimeters: { name: "Centimeters", type: "cm", scale: 0.01 },
+        Millimeters: { name: "Millimeters", type: "mm", scale: 0.001 },
+        Feet: { name: "Feet", type: "ft", scale: 0.3048 },
+        Inches: { name: "Inches", type: "in", scale: 0.0254 },
+        Yards: { name: "Yards", type: "yd", scale: 0.9144 },
+        Kilometers: { name: "Kilometers", type: "km", scale: 1000.0 },
+        Miles: { name: "Miles", type: "mi", scale: 1609.344 },
+        Micrometers: { name: "Micrometers", type: "µm", scale: 0.000001 },
+        Mils: { name: "Mils", type: "mil", scale: 0.0000254 },
+        MicroInches: { name: "Micro-inches", type: "µin", scale: 0.0000000254 },
+        Default: { name: "File units", type: "unit", scale: 1.0 },
+    };
+    function convertUnits(fromUnits, toUnits, distance) {
+        const fromFactor = 1 / (ModelUnits[fromUnits] || ModelUnits.Default).scale;
+        const toFactor = (ModelUnits[toUnits] || ModelUnits.Default).scale || 1;
+        return distance * fromFactor * toFactor;
+    }
+
+    function getDisplayUnit(units) {
+        return (ModelUnits[units] || ModelUnits.Default).type;
+    }
+    function calculatePrecision(value) {
+        const distance = Math.abs(value);
+        if (distance >= 1000)
+            return 0;
+        if (distance >= 10)
+            return 1;
+        if (distance >= 0.1)
+            return 2;
+        if (distance >= 0.001)
+            return 3;
+        return distance > 0 ? Math.floor(-Math.log10(distance)) + 1 : 2;
+    }
+    function formatNumber(distance, digits, precision) {
+        let result = distance.toFixed(digits);
+        if (precision === "Auto")
+            result = result.replace(/\.0+$/, "").replace(/\.$/, "");
+        if (+result !== distance)
+            result = "~ " + result;
+        return result;
+    }
+    function formatDistance(distance, units, precision = 2) {
+        let digits;
+        if (precision === "Auto")
+            digits = calculatePrecision(distance);
+        else if (Number.isFinite(precision))
+            digits = precision;
+        else
+            digits = parseFloat(precision);
+        if (!Number.isFinite(digits))
+            digits = 2;
+        else if (digits < 0)
+            digits = 0;
+        else if (digits > 10)
+            digits = 10;
+        if (ModelUnits[units]) {
+            return formatNumber(distance, digits, precision) + " " + ModelUnits[units].type;
+        }
+        else if (units) {
+            return formatNumber(distance, digits, precision) + " " + units;
         }
-        dispose() {
-            this.viewer.canvas.removeEventListener("pointerdown", this.onPointerDown);
-            this.viewer.canvas.removeEventListener("pointermove", this.onPointerMove);
-            this.viewer.canvas.removeEventListener("pointerup", this.onPointerUp);
-            this.viewer.canvas.removeEventListener("pointercancel", this.onPointerCancel);
-            this.viewer.canvas.removeEventListener("pointerleave", this.onPointerLeave);
-            this.viewer.removeEventListener("render", this.renderOverlay);
-            this.viewer.removeEventListener("hide", this.updateSnapper);
-            this.viewer.removeEventListener("isolate", this.updateSnapper);
-            this.viewer.removeEventListener("show", this.updateSnapper);
-            this.viewer.removeEventListener("showall", this.updateSnapper);
-            this.viewer.removeEventListener("changecameramode", this.updateSnapperCamera);
-            this.snapper.dispose();
-            this.overlay.detach();
-            this.overlay.dispose();
-            super.dispose();
+        else {
+            return formatNumber(distance, digits, precision);
         }
     }
+
+    const DESKTOP_SNAP_DISTANCE = 10;
+    const MOBILE_SNAP_DISTANCE = 50;
     const _vertex = new Vector3();
     const _start$1 = new Vector3();
     const _end$1 = new Vector3();
     const _line = new Line3();
     const _center = new Vector3();
     const _projection = new Vector3();
-    class MeasureSnapper {
-        constructor(camera, canvas) {
+    class Snapper {
+        constructor(camera, renderer, canvas) {
             this.camera = camera;
+            this.renderer = renderer;
             this.canvas = canvas;
-            this.objects = [];
-            this.clippingPlanes = [];
             this.raycaster = new Raycaster();
             this.detectRadiusInPixels = this.isMobile() ? MOBILE_SNAP_DISTANCE : DESKTOP_SNAP_DISTANCE;
             this.edgesCache = new WeakMap();
         }
-        dispose() {
-            this.objects = [];
-        }
         isMobile() {
             if (typeof navigator === "undefined")
                 return false;
@@ -33994,7 +33985,7 @@ void main() {
         getMousePosition(event, target) {
             return target.set(event.clientX, event.clientY);
         }
-        getPointerIntersects(mouse) {
+        getPointerIntersects(mouse, objects) {
             const rect = this.canvas.getBoundingClientRect();
             const x = ((mouse.x - rect.left) / rect.width) * 2 - 1;
             const y = (-(mouse.y - rect.top) / rect.height) * 2 + 1;
@@ -34008,8 +33999,8 @@ void main() {
                 Points: { threshold: 0.01 },
                 Sprite: {},
             };
-            let intersects = this.raycaster.intersectObjects(this.objects, false);
-            this.clippingPlanes.forEach((plane) => {
+            let intersects = this.raycaster.intersectObjects(objects, false);
+            (this.renderer.clippingPlanes || []).forEach((plane) => {
                 intersects = intersects.filter((intersect) => plane.distanceToPoint(intersect.point) >= 0);
             });
             return intersects;
@@ -34031,9 +34022,8 @@ void main() {
             }
             return 0.1;
         }
-        getSnapPoint(event) {
-            const mouse = this.getMousePosition(event, new Vector2());
-            const intersections = this.getPointerIntersects(mouse);
+        getSnapPoint(mouse, objects) {
+            const intersections = this.getPointerIntersects(mouse, objects);
             if (intersections.length === 0)
                 return undefined;
             const object = intersections[0].object;
@@ -34081,13 +34071,133 @@ void main() {
                 return object.localToWorld(snapPoint);
             return intersectionPoint.clone();
         }
-        setFromViewer(viewer) {
+    }
+
+    const _downPoint = new Vector2();
+    class MeasureLineDragger extends OrbitDragger {
+        constructor(viewer) {
+            super(viewer);
+            this.scale = 1.0;
+            this.units = "";
+            this.precision = 2;
+            this.onPointerDown = (event) => {
+                if (event.button !== 0)
+                    return;
+                const mouse = this.snapper.getMousePosition(event, _downPoint);
+                this.line.startPoint = this.snapper.getSnapPoint(mouse, this.objects);
+                this.line.render();
+                this.viewer.canvas.setPointerCapture(event.pointerId);
+                this.orbit.enabled = !this.line.startPoint;
+            };
+            this.onPointerMove = (event) => {
+                if (this.orbit.enabled && this.orbit.state !== -1)
+                    return;
+                const mouse = this.snapper.getMousePosition(event, _downPoint);
+                const snapPoint = this.snapper.getSnapPoint(mouse, this.objects);
+                if (snapPoint && this.line.endPoint && snapPoint.equals(this.line.endPoint))
+                    return;
+                this.line.endPoint = snapPoint;
+                this.line.render();
+                if (this.line.startPoint)
+                    this.changed = true;
+            };
+            this.onPointerUp = (event) => {
+                if (this.line.startPoint && this.line.endPoint && this.line.getDistance() > 0) {
+                    this.line = new MeasureLine(this.overlay, this.scale, this.units, this.precision);
+                    this.overlay.addLine(this.line);
+                }
+                else {
+                    this.line.startPoint = undefined;
+                    this.line.endPoint = undefined;
+                    this.line.render();
+                }
+                this.viewer.canvas.releasePointerCapture(event.pointerId);
+                this.orbit.enabled = true;
+            };
+            this.onPointerCancel = (event) => {
+                this.viewer.canvas.dispatchEvent(new PointerEvent("pointerup", event));
+            };
+            this.onPointerLeave = () => {
+                this.line.endPoint = undefined;
+                this.line.render();
+            };
+            this.clearOverlay = () => {
+                this.overlay.clear();
+                this.line = new MeasureLine(this.overlay, this.scale, this.units, this.precision);
+                this.overlay.addLine(this.line);
+            };
+            this.renderOverlay = () => {
+                this.overlay.render();
+            };
+            this.updateObjects = () => {
+                this.objects.length = 0;
+                this.viewer.models.forEach((model) => {
+                    model.getVisibleObjects().forEach((object) => this.objects.push(object));
+                });
+            };
+            this.updateSnapperCamera = () => {
+                this.snapper.camera = this.viewer.camera;
+                this.overlay.camera = this.viewer.camera;
+            };
+            this.updateUnits = () => {
+                var _a, _b;
+                const model = this.viewer.models[0];
+                const units = (_a = this.viewer.options.rulerUnit) !== null && _a !== void 0 ? _a : "Default";
+                const precision = (_b = this.viewer.options.rulerPrecision) !== null && _b !== void 0 ? _b : "Default";
+                if (units === "Default") {
+                    this.scale = model.getUnitScale();
+                    this.units = model.getUnitString();
+                }
+                else {
+                    this.scale = convertUnits(model.getUnits(), units, 1);
+                    this.units = units;
+                }
+                if (precision === "Default") {
+                    this.precision = model.getPrecision();
+                }
+                else {
+                    this.precision = precision;
+                }
+                this.overlay.updateLineUnits(this.scale, this.units, this.precision);
+            };
+            this.overlay = new MeasureOverlay(viewer.camera, viewer.canvas);
+            this.overlay.attach();
+            this.line = new MeasureLine(this.overlay, this.scale, this.units, this.precision);
+            this.overlay.addLine(this.line);
+            this.snapper = new Snapper(viewer.camera, viewer.renderer, viewer.canvas);
+            this.objects = [];
+            this.updateObjects();
+            this.updateUnits();
+            this.viewer.canvas.addEventListener("pointerdown", this.onPointerDown);
+            this.viewer.canvas.addEventListener("pointermove", this.onPointerMove);
+            this.viewer.canvas.addEventListener("pointerup", this.onPointerUp);
+            this.viewer.canvas.addEventListener("pointercancel", this.onPointerCancel);
+            this.viewer.canvas.addEventListener("pointerleave", this.onPointerLeave);
+            this.viewer.addEventListener("render", this.renderOverlay);
+            this.viewer.addEventListener("hide", this.updateObjects);
+            this.viewer.addEventListener("isolate", this.updateObjects);
+            this.viewer.addEventListener("show", this.updateObjects);
+            this.viewer.addEventListener("showall", this.updateObjects);
+            this.viewer.addEventListener("changecameramode", this.updateSnapperCamera);
+            this.viewer.addEventListener("optionschange", this.updateUnits);
+        }
+        dispose() {
+            this.viewer.canvas.removeEventListener("pointerdown", this.onPointerDown);
+            this.viewer.canvas.removeEventListener("pointermove", this.onPointerMove);
+            this.viewer.canvas.removeEventListener("pointerup", this.onPointerUp);
+            this.viewer.canvas.removeEventListener("pointercancel", this.onPointerCancel);
+            this.viewer.canvas.removeEventListener("pointerleave", this.onPointerLeave);
+            this.viewer.removeEventListener("render", this.renderOverlay);
+            this.viewer.removeEventListener("hide", this.updateObjects);
+            this.viewer.removeEventListener("isolate", this.updateObjects);
+            this.viewer.removeEventListener("show", this.updateObjects);
+            this.viewer.removeEventListener("showall", this.updateObjects);
+            this.viewer.removeEventListener("changecameramode", this.updateSnapperCamera);
+            this.viewer.removeEventListener("optionschange", this.updateUnits);
             this.objects.length = 0;
-            viewer.models.forEach((model) => {
-                model.getVisibleObjects().forEach((object) => this.objects.push(object));
-            });
-            this.camera = viewer.camera;
-            this.clippingPlanes = viewer.renderer.clippingPlanes || [];
+            this.overlay.detach();
+            this.overlay.dispose();
+            super.dispose();
         }
     }
     class MeasureOverlay {
@@ -34107,6 +34217,9 @@ void main() {
             this.projector = new MeasureProjector(camera, canvas);
             this.resizeObserver = new ResizeObserver(this.resizeContainer);
         }
+        dispose() {
+            this.clear();
+        }
         attach() {
             this.container = document.createElement("div");
             this.container.id = "measure-container";
@@ -34119,9 +34232,6 @@ void main() {
             this.canvas.parentElement.appendChild(this.container);
             this.resizeObserver.observe(this.canvas);
         }
-        dispose() {
-            this.clear();
-        }
         detach() {
             this.resizeObserver.disconnect();
             this.container.remove();
@@ -34129,7 +34239,7 @@ void main() {
         }
         clear() {
             this.lines.forEach((line) => line.dispose());
-            this.lines = [];
+            this.lines.length = 0;
         }
         render() {
             this.projector.setFromCamera(this.camera);
@@ -34144,13 +34254,18 @@ void main() {
         removeLine(line) {
             this.lines = this.lines.filter((x) => x !== line);
         }
+        updateLineUnits(scale, units, precision) {
+            this.lines.forEach((line) => {
+                line.scale = scale;
+                line.units = units;
+                line.precision = precision;
+            });
+        }
     }
     const _middlePoint = new Vector3();
     class MeasureLine {
-        constructor(overlay) {
+        constructor(overlay, scale, units, precision) {
             this.id = MathUtils.generateUUID();
-            this.unit = "";
-            this.scale = 1.0;
             this.size = 10.0;
             this.lineWidth = 2;
             this.style = {
@@ -34161,6 +34276,9 @@ void main() {
                 font: "1rem system-ui",
             };
             this.overlay = overlay;
+            this.scale = scale;
+            this.units = units;
+            this.precision = precision;
             this.elementStartPoint = overlay.container.appendChild(document.createElement("div"));
             this.elementEndPoint = overlay.container.appendChild(document.createElement("div"));
             this.elementLine = overlay.container.appendChild(document.createElement("div"));
@@ -34215,10 +34333,10 @@ void main() {
                 _middlePoint.lerpVectors(this.startPoint, this.endPoint, 0.5);
                 const { point, visible } = projector.projectPoint(_middlePoint);
                 const distance = this.getDistance();
-                this.elementLabel.style.display = visible && distance >= PRECISION ? "block" : "none";
+                this.elementLabel.style.display = visible && distance > 0 ? "block" : "none";
                 this.elementLabel.style.left = `${point.x}px`;
                 this.elementLabel.style.top = `${point.y}px`;
-                this.elementLabel.innerHTML = `${distance.toFixed(2)} ${this.unit}`;
+                this.elementLabel.innerHTML = formatDistance(distance, this.units, this.precision);
             }
             else {
                 this.elementLabel.style.display = "none";
@@ -35022,7 +35140,8 @@ void main() {
         const selection = viewer.getComponent("SelectionComponent");
         selection.clearSelection();
         viewer.update();
-        viewer.emitEvent({ type: "select", data: undefined, handles: [] });
+        viewer.emitEvent({ type: "select", handles: [] });
+        viewer.emitEvent({ type: "select2", handles: [] });
     }
 
     function clearSlices(viewer) {
@@ -35111,22 +35230,31 @@ void main() {
     }
 
     function getModels(viewer) {
-        return viewer.models.map((model) => model.handle);
+        return viewer.models.map((model) => model.id);
     }
 
     function getSelected(viewer) {
-        const handles = [];
-        viewer.models.forEach((model) => handles.push(...model.getHandlesByObjects(viewer.selected)));
+        const handles2 = viewer.executeCommand("getSelected2");
+        const handles = handles2.map((handle) => handle.slice(handle.indexOf(":") + 1));
         return handles;
     }
 
+    function getSelected2(viewer) {
+        const handles2 = [];
+        viewer.models.forEach((model) => {
+            handles2.push(...model.getHandlesByObjects(viewer.selected));
+        });
+        return handles2;
+    }
+
     function hideSelected(viewer) {
         viewer.models.forEach((model) => model.hideObjects(viewer.selected));
         const selection = viewer.getComponent("SelectionComponent");
         selection.clearSelection();
         viewer.update();
         viewer.emitEvent({ type: "hide" });
-        viewer.emitEvent({ type: "select", data: undefined, handles: [] });
+        viewer.emitEvent({ type: "select", handles: [] });
+        viewer.emitEvent({ type: "select2", handles: [] });
     }
 
     function isolateSelected(viewer) {
@@ -35153,14 +35281,13 @@ void main() {
         viewer.emit({ type: "resetview" });
     }
 
-    function selectModel(viewer, handle) {
+    function selectModel(viewer, id) {
         const selection = viewer.getComponent("SelectionComponent");
         selection.clearSelection();
-        viewer.models
-            .filter((model) => model.handle === handle)
-            .forEach((model) => selection.select(model.getObjects(), model));
+        viewer.models.filter((model) => model.id === id).forEach((model) => selection.select(model.getObjects(), model));
         viewer.update();
-        viewer.emit({ type: "select", data: [] });
+        viewer.emitEvent({ type: "select", handles: viewer.getSelected() });
+        viewer.emitEvent({ type: "select2", handles: viewer.getSelected2() });
     }
 
     function setActiveDragger(viewer, dragger = "") {
@@ -35172,16 +35299,31 @@ void main() {
     }
 
     function setSelected(viewer, handles = []) {
-        const selection = viewer.getComponent("SelectionComponent");
-        selection.clearSelection();
+        const handles2 = [];
+        handles.forEach((handle) => {
+            if (handle.includes(":")) {
+                handles2.push(handle);
+            }
+            else
+                viewer.models.forEach((model) => {
+                    handles2.push(`${model.id}:${handle}`);
+                });
+        });
+        viewer.executeCommand("setSelected2", handles2);
+    }
+
+    function setSelected2(viewer, handles = []) {
+        const selectionComponent = viewer.getComponent("SelectionComponent");
+        selectionComponent.clearSelection();
         viewer.models.forEach((model) => {
             const objects = model.getObjectsByHandles(handles);
             model.showObjects(objects);
-            selection.select(objects, model);
+            selectionComponent.select(objects, model);
         });
         viewer.update();
         viewer.emitEvent({ type: "show" });
-        viewer.emitEvent({ type: "select", data: undefined, handles });
+        viewer.emitEvent({ type: "select", data: undefined, handles: viewer.getSelected() });
+        viewer.emitEvent({ type: "select2", data: undefined, handles });
     }
 
     function showAll(viewer) {
@@ -35195,21 +35337,19 @@ void main() {
     }
 
     function zoomToObjects(viewer, handles = []) {
-        const handleSet = new Set(handles);
-        const objects = [];
-        viewer.scene.traverseVisible((child) => {
-            var _a;
-            if (handleSet.has((_a = child.userData) === null || _a === void 0 ? void 0 : _a.handle))
-                objects.push(child);
+        const extents = new Box3();
+        viewer.models.forEach((model) => {
+            const objects = model.getObjectsByHandles(handles);
+            objects.forEach((object) => extents.expandByObject(object));
         });
-        const extents = objects.reduce((result, object) => result.expandByObject(object), new Box3());
         if (extents.isEmpty())
             extents.copy(viewer.extents);
         zoomTo(viewer, extents);
     }
 
     function zoomToSelected(viewer) {
-        const extents = viewer.selected.reduce((result, object) => result.expandByObject(object), new Box3());
+        const extents = new Box3();
+        viewer.selected.forEach((object) => extents.expandByObject(object));
         if (extents.isEmpty())
             extents.copy(viewer.extents);
         zoomTo(viewer, extents);
@@ -35226,6 +35366,7 @@ void main() {
     commands.registerCommand("getDefaultViewPositions", getDefaultViewPositions);
     commands.registerCommand("getModels", getModels);
     commands.registerCommand("getSelected", getSelected);
+    commands.registerCommand("getSelected2", getSelected2);
     commands.registerCommand("hideSelected", hideSelected);
     commands.registerCommand("isolateSelected", isolateSelected);
     commands.registerCommand("regenerateAll", regenerateAll);
@@ -35235,6 +35376,7 @@ void main() {
     commands.registerCommand("setDefaultViewPosition", setDefaultViewPosition);
     commands.registerCommand("setMarkupColor", setMarkupColor);
     commands.registerCommand("setSelected", setSelected);
+    commands.registerCommand("setSelected2", setSelected2);
     commands.registerCommand("showAll", showAll);
     commands.registerCommand("zoomToExtents", zoomToExtents);
     commands.registerCommand("zoomToObjects", zoomToObjects);
@@ -35287,6 +35429,10 @@ void main() {
                 this.switchCameraMode(this.viewer.options.cameraMode);
             };
             this.geometryEnd = () => {
+                if (this.viewer.models.length > 1) {
+                    this.switchCamera(this.viewer.camera);
+                    return;
+                }
                 let camera;
                 this.viewer.scene.traverse((object) => {
                     if (object.isCamera)
@@ -35384,6 +35530,8 @@ void main() {
                 const extents = new Box3();
                 this.viewer.models.forEach((model) => model.getExtents(extents));
                 this.viewer.extents.copy(extents);
+                if (this.viewer.models.length > 1)
+                    return;
                 this.viewer.extents.getCenter(this.viewer.target);
             };
             this.viewer = viewer;
@@ -36350,10 +36498,11 @@ void main() {
                 const upPosition = this.getMousePosition(event, new Vector2());
                 if (upPosition.distanceTo(this.downPosition) !== 0)
                     return;
+                const snapper = new Snapper(this.viewer.camera, this.viewer.renderer, this.viewer.canvas);
                 let intersections = [];
                 this.viewer.models.forEach((model) => {
                     const objects = model.getVisibleObjects();
-                    const intersects = this.getPointerIntersects(upPosition, objects);
+                    const intersects = snapper.getPointerIntersects(upPosition, objects);
                     if (intersects.length > 0)
                         intersections.push({ ...intersects[0], model });
                 });
@@ -36371,6 +36520,7 @@ void main() {
                 }
                 this.viewer.update();
                 this.viewer.emitEvent({ type: "select", data: undefined, handles: this.viewer.getSelected() });
+                this.viewer.emitEvent({ type: "select2", data: undefined, handles: this.viewer.getSelected2() });
             };
             this.onDoubleClick = (event) => {
                 if (event.button !== 0)
@@ -36381,7 +36531,6 @@ void main() {
                 this.highlighter = this.viewer.getComponent("HighlighterComponent");
             };
             this.viewer = viewer;
-            this.raycaster = new Raycaster();
             this.downPosition = new Vector2();
             this.viewer.addEventListener("pointerdown", this.onPointerDown);
             this.viewer.addEventListener("pointerup", this.onPointerUp);
@@ -36397,26 +36546,6 @@ void main() {
         getMousePosition(event, target) {
             return target.set(event.clientX, event.clientY);
         }
-        getPointerIntersects(mouse, objects) {
-            const rect = this.viewer.canvas.getBoundingClientRect();
-            const x = ((mouse.x - rect.left) / rect.width) * 2 - 1;
-            const y = (-(mouse.y - rect.top) / rect.height) * 2 + 1;
-            const coords = new Vector2(x, y);
-            this.raycaster.setFromCamera(coords, this.viewer.camera);
-            this.raycaster.params = {
-                Mesh: {},
-                Line: { threshold: 0.05 },
-                Line2: { threshold: 0.05 },
-                LOD: {},
-                Points: { threshold: 0.01 },
-                Sprite: {},
-            };
-            let intersects = this.raycaster.intersectObjects(objects, false);
-            (this.viewer.renderer.clippingPlanes || []).forEach((plane) => {
-                intersects = intersects.filter((intersect) => plane.distanceToPoint(intersect.point) >= 0);
-            });
-            return intersects;
-        }
         select(objects, model) {
             if (!model) {
                 this.viewer.models.forEach((model) => this.select(objects, model));
@@ -36615,2616 +36744,8 @@ void main() {
     components.registerComponent("WCSHelperComponent", (viewer) => new WCSHelperComponent(viewer));
     components.registerComponent("ResetComponent", (viewer) => new ResetComponent(viewer));
 
-    function mergeGeometries( geometries, useGroups = false ) {
-    	const isIndexed = geometries[ 0 ].index !== null;
-    	const attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) );
-    	const morphAttributesUsed = new Set( Object.keys( geometries[ 0 ].morphAttributes ) );
-    	const attributes = {};
-    	const morphAttributes = {};
-    	const morphTargetsRelative = geometries[ 0 ].morphTargetsRelative;
-    	const mergedGeometry = new BufferGeometry();
-    	let offset = 0;
-    	for ( let i = 0; i < geometries.length; ++ i ) {
-    		const geometry = geometries[ i ];
-    		let attributesCount = 0;
-    		if ( isIndexed !== ( geometry.index !== null ) ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
-    			return null;
-    		}
-    		for ( const name in geometry.attributes ) {
-    			if ( ! attributesUsed.has( name ) ) {
-    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' );
-    				return null;
-    			}
-    			if ( attributes[ name ] === undefined ) attributes[ name ] = [];
-    			attributes[ name ].push( geometry.attributes[ name ] );
-    			attributesCount ++;
-    		}
-    		if ( attributesCount !== attributesUsed.size ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );
-    			return null;
-    		}
-    		if ( morphTargetsRelative !== geometry.morphTargetsRelative ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' );
-    			return null;
-    		}
-    		for ( const name in geometry.morphAttributes ) {
-    			if ( ! morphAttributesUsed.has( name ) ) {
-    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '.  .morphAttributes must be consistent throughout all geometries.' );
-    				return null;
-    			}
-    			if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];
-    			morphAttributes[ name ].push( geometry.morphAttributes[ name ] );
-    		}
-    		if ( useGroups ) {
-    			let count;
-    			if ( isIndexed ) {
-    				count = geometry.index.count;
-    			} else if ( geometry.attributes.position !== undefined ) {
-    				count = geometry.attributes.position.count;
-    			} else {
-    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' );
-    				return null;
-    			}
-    			mergedGeometry.addGroup( offset, count, i );
-    			offset += count;
-    		}
-    	}
-    	if ( isIndexed ) {
-    		let indexOffset = 0;
-    		const mergedIndex = [];
-    		for ( let i = 0; i < geometries.length; ++ i ) {
-    			const index = geometries[ i ].index;
-    			for ( let j = 0; j < index.count; ++ j ) {
-    				mergedIndex.push( index.getX( j ) + indexOffset );
-    			}
-    			indexOffset += geometries[ i ].attributes.position.count;
-    		}
-    		mergedGeometry.setIndex( mergedIndex );
-    	}
-    	for ( const name in attributes ) {
-    		const mergedAttribute = mergeAttributes( attributes[ name ] );
-    		if ( ! mergedAttribute ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' attribute.' );
-    			return null;
-    		}
-    		mergedGeometry.setAttribute( name, mergedAttribute );
-    	}
-    	for ( const name in morphAttributes ) {
-    		const numMorphTargets = morphAttributes[ name ][ 0 ].length;
-    		if ( numMorphTargets === 0 ) break;
-    		mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
-    		mergedGeometry.morphAttributes[ name ] = [];
-    		for ( let i = 0; i < numMorphTargets; ++ i ) {
-    			const morphAttributesToMerge = [];
-    			for ( let j = 0; j < morphAttributes[ name ].length; ++ j ) {
-    				morphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] );
-    			}
-    			const mergedMorphAttribute = mergeAttributes( morphAttributesToMerge );
-    			if ( ! mergedMorphAttribute ) {
-    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );
-    				return null;
-    			}
-    			mergedGeometry.morphAttributes[ name ].push( mergedMorphAttribute );
-    		}
-    	}
-    	return mergedGeometry;
-    }
-    function mergeAttributes( attributes ) {
-    	let TypedArray;
-    	let itemSize;
-    	let normalized;
-    	let gpuType = -1;
-    	let arrayLength = 0;
-    	for ( let i = 0; i < attributes.length; ++ i ) {
-    		const attribute = attributes[ i ];
-    		if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
-    		if ( TypedArray !== attribute.array.constructor ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' );
-    			return null;
-    		}
-    		if ( itemSize === undefined ) itemSize = attribute.itemSize;
-    		if ( itemSize !== attribute.itemSize ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' );
-    			return null;
-    		}
-    		if ( normalized === undefined ) normalized = attribute.normalized;
-    		if ( normalized !== attribute.normalized ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' );
-    			return null;
-    		}
-    		if ( gpuType === -1 ) gpuType = attribute.gpuType;
-    		if ( gpuType !== attribute.gpuType ) {
-    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' );
-    			return null;
-    		}
-    		arrayLength += attribute.count * itemSize;
-    	}
-    	const array = new TypedArray( arrayLength );
-    	const result = new BufferAttribute( array, itemSize, normalized );
-    	let offset = 0;
-    	for ( let i = 0; i < attributes.length; ++ i ) {
-    		const attribute = attributes[ i ];
-    		if ( attribute.isInterleavedBufferAttribute ) {
-    			const tupleOffset = offset / itemSize;
-    			for ( let j = 0, l = attribute.count; j < l; j ++ ) {
-    				for ( let c = 0; c < itemSize; c ++ ) {
-    					const value = attribute.getComponent( j, c );
-    					result.setComponent( j + tupleOffset, c, value );
-    				}
-    			}
-    		} else {
-    			array.set( attribute.array, offset );
-    		}
-    		offset += attribute.count * itemSize;
-    	}
-    	if ( gpuType !== undefined ) {
-    		result.gpuType = gpuType;
-    	}
-    	return result;
-    }
-    function toTrianglesDrawMode( geometry, drawMode ) {
-    	if ( drawMode === TrianglesDrawMode ) {
-    		console.warn( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.' );
-    		return geometry;
-    	}
-    	if ( drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode ) {
-    		let index = geometry.getIndex();
-    		if ( index === null ) {
-    			const indices = [];
-    			const position = geometry.getAttribute( 'position' );
-    			if ( position !== undefined ) {
-    				for ( let i = 0; i < position.count; i ++ ) {
-    					indices.push( i );
-    				}
-    				geometry.setIndex( indices );
-    				index = geometry.getIndex();
-    			} else {
-    				console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible.' );
-    				return geometry;
-    			}
-    		}
-    		const numberOfTriangles = index.count - 2;
-    		const newIndices = [];
-    		if ( drawMode === TriangleFanDrawMode ) {
-    			for ( let i = 1; i <= numberOfTriangles; i ++ ) {
-    				newIndices.push( index.getX( 0 ) );
-    				newIndices.push( index.getX( i ) );
-    				newIndices.push( index.getX( i + 1 ) );
-    			}
-    		} else {
-    			for ( let i = 0; i < numberOfTriangles; i ++ ) {
-    				if ( i % 2 === 0 ) {
-    					newIndices.push( index.getX( i ) );
-    					newIndices.push( index.getX( i + 1 ) );
-    					newIndices.push( index.getX( i + 2 ) );
-    				} else {
-    					newIndices.push( index.getX( i + 2 ) );
-    					newIndices.push( index.getX( i + 1 ) );
-    					newIndices.push( index.getX( i ) );
-    				}
-    			}
-    		}
-    		if ( ( newIndices.length / 3 ) !== numberOfTriangles ) {
-    			console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.' );
-    		}
-    		const newGeometry = geometry.clone();
-    		newGeometry.setIndex( newIndices );
-    		newGeometry.clearGroups();
-    		return newGeometry;
-    	} else {
-    		console.error( 'THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:', drawMode );
-    		return geometry;
-    	}
-    }
-
-    class GLTFLoader extends Loader {
-    	constructor( manager ) {
-    		super( manager );
-    		this.dracoLoader = null;
-    		this.ktx2Loader = null;
-    		this.meshoptDecoder = null;
-    		this.pluginCallbacks = [];
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsClearcoatExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsDispersionExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFTextureBasisUExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFTextureWebPExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFTextureAVIFExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsSheenExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsTransmissionExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsVolumeExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsIorExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsEmissiveStrengthExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsSpecularExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsIridescenceExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsAnisotropyExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMaterialsBumpExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFLightsExtension( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMeshoptCompression( parser );
-    		} );
-    		this.register( function ( parser ) {
-    			return new GLTFMeshGpuInstancing( parser );
-    		} );
-    	}
-    	load( url, onLoad, onProgress, onError ) {
-    		const scope = this;
-    		let resourcePath;
-    		if ( this.resourcePath !== '' ) {
-    			resourcePath = this.resourcePath;
-    		} else if ( this.path !== '' ) {
-    			const relativeUrl = LoaderUtils.extractUrlBase( url );
-    			resourcePath = LoaderUtils.resolveURL( relativeUrl, this.path );
-    		} else {
-    			resourcePath = LoaderUtils.extractUrlBase( url );
-    		}
-    		this.manager.itemStart( url );
-    		const _onError = function ( e ) {
-    			if ( onError ) {
-    				onError( e );
-    			} else {
-    				console.error( e );
-    			}
-    			scope.manager.itemError( url );
-    			scope.manager.itemEnd( url );
-    		};
-    		const loader = new FileLoader( this.manager );
-    		loader.setPath( this.path );
-    		loader.setResponseType( 'arraybuffer' );
-    		loader.setRequestHeader( this.requestHeader );
-    		loader.setWithCredentials( this.withCredentials );
-    		loader.load( url, function ( data ) {
-    			try {
-    				scope.parse( data, resourcePath, function ( gltf ) {
-    					onLoad( gltf );
-    					scope.manager.itemEnd( url );
-    				}, _onError );
-    			} catch ( e ) {
-    				_onError( e );
-    			}
-    		}, onProgress, _onError );
-    	}
-    	setDRACOLoader( dracoLoader ) {
-    		this.dracoLoader = dracoLoader;
-    		return this;
-    	}
-    	setKTX2Loader( ktx2Loader ) {
-    		this.ktx2Loader = ktx2Loader;
-    		return this;
-    	}
-    	setMeshoptDecoder( meshoptDecoder ) {
-    		this.meshoptDecoder = meshoptDecoder;
-    		return this;
-    	}
-    	register( callback ) {
-    		if ( this.pluginCallbacks.indexOf( callback ) === -1 ) {
-    			this.pluginCallbacks.push( callback );
-    		}
-    		return this;
-    	}
-    	unregister( callback ) {
-    		if ( this.pluginCallbacks.indexOf( callback ) !== -1 ) {
-    			this.pluginCallbacks.splice( this.pluginCallbacks.indexOf( callback ), 1 );
-    		}
-    		return this;
-    	}
-    	parse( data, path, onLoad, onError ) {
-    		let json;
-    		const extensions = {};
-    		const plugins = {};
-    		const textDecoder = new TextDecoder();
-    		if ( typeof data === 'string' ) {
-    			json = JSON.parse( data );
-    		} else if ( data instanceof ArrayBuffer ) {
-    			const magic = textDecoder.decode( new Uint8Array( data, 0, 4 ) );
-    			if ( magic === BINARY_EXTENSION_HEADER_MAGIC ) {
-    				try {
-    					extensions[ EXTENSIONS.KHR_BINARY_GLTF ] = new GLTFBinaryExtension( data );
-    				} catch ( error ) {
-    					if ( onError ) onError( error );
-    					return;
-    				}
-    				json = JSON.parse( extensions[ EXTENSIONS.KHR_BINARY_GLTF ].content );
-    			} else {
-    				json = JSON.parse( textDecoder.decode( data ) );
-    			}
-    		} else {
-    			json = data;
-    		}
-    		if ( json.asset === undefined || json.asset.version[ 0 ] < 2 ) {
-    			if ( onError ) onError( new Error( 'THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported.' ) );
-    			return;
-    		}
-    		const parser = new GLTFParser( json, {
-    			path: path || this.resourcePath || '',
-    			crossOrigin: this.crossOrigin,
-    			requestHeader: this.requestHeader,
-    			manager: this.manager,
-    			ktx2Loader: this.ktx2Loader,
-    			meshoptDecoder: this.meshoptDecoder
-    		} );
-    		parser.fileLoader.setRequestHeader( this.requestHeader );
-    		for ( let i = 0; i < this.pluginCallbacks.length; i ++ ) {
-    			const plugin = this.pluginCallbacks[ i ]( parser );
-    			if ( ! plugin.name ) console.error( 'THREE.GLTFLoader: Invalid plugin found: missing name' );
-    			plugins[ plugin.name ] = plugin;
-    			extensions[ plugin.name ] = true;
-    		}
-    		if ( json.extensionsUsed ) {
-    			for ( let i = 0; i < json.extensionsUsed.length; ++ i ) {
-    				const extensionName = json.extensionsUsed[ i ];
-    				const extensionsRequired = json.extensionsRequired || [];
-    				switch ( extensionName ) {
-    					case EXTENSIONS.KHR_MATERIALS_UNLIT:
-    						extensions[ extensionName ] = new GLTFMaterialsUnlitExtension();
-    						break;
-    					case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
-    						extensions[ extensionName ] = new GLTFDracoMeshCompressionExtension( json, this.dracoLoader );
-    						break;
-    					case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
-    						extensions[ extensionName ] = new GLTFTextureTransformExtension();
-    						break;
-    					case EXTENSIONS.KHR_MESH_QUANTIZATION:
-    						extensions[ extensionName ] = new GLTFMeshQuantizationExtension();
-    						break;
-    					default:
-    						if ( extensionsRequired.indexOf( extensionName ) >= 0 && plugins[ extensionName ] === undefined ) {
-    							console.warn( 'THREE.GLTFLoader: Unknown extension "' + extensionName + '".' );
-    						}
-    				}
-    			}
-    		}
-    		parser.setExtensions( extensions );
-    		parser.setPlugins( plugins );
-    		parser.parse( onLoad, onError );
-    	}
-    	parseAsync( data, path ) {
-    		const scope = this;
-    		return new Promise( function ( resolve, reject ) {
-    			scope.parse( data, path, resolve, reject );
-    		} );
-    	}
-    }
-    function GLTFRegistry() {
-    	let objects = {};
-    	return	{
-    		get: function ( key ) {
-    			return objects[ key ];
-    		},
-    		add: function ( key, object ) {
-    			objects[ key ] = object;
-    		},
-    		remove: function ( key ) {
-    			delete objects[ key ];
-    		},
-    		removeAll: function () {
-    			objects = {};
-    		}
-    	};
-    }
-    const EXTENSIONS = {
-    	KHR_BINARY_GLTF: 'KHR_binary_glTF',
-    	KHR_DRACO_MESH_COMPRESSION: 'KHR_draco_mesh_compression',
-    	KHR_LIGHTS_PUNCTUAL: 'KHR_lights_punctual',
-    	KHR_MATERIALS_CLEARCOAT: 'KHR_materials_clearcoat',
-    	KHR_MATERIALS_DISPERSION: 'KHR_materials_dispersion',
-    	KHR_MATERIALS_IOR: 'KHR_materials_ior',
-    	KHR_MATERIALS_SHEEN: 'KHR_materials_sheen',
-    	KHR_MATERIALS_SPECULAR: 'KHR_materials_specular',
-    	KHR_MATERIALS_TRANSMISSION: 'KHR_materials_transmission',
-    	KHR_MATERIALS_IRIDESCENCE: 'KHR_materials_iridescence',
-    	KHR_MATERIALS_ANISOTROPY: 'KHR_materials_anisotropy',
-    	KHR_MATERIALS_UNLIT: 'KHR_materials_unlit',
-    	KHR_MATERIALS_VOLUME: 'KHR_materials_volume',
-    	KHR_TEXTURE_BASISU: 'KHR_texture_basisu',
-    	KHR_TEXTURE_TRANSFORM: 'KHR_texture_transform',
-    	KHR_MESH_QUANTIZATION: 'KHR_mesh_quantization',
-    	KHR_MATERIALS_EMISSIVE_STRENGTH: 'KHR_materials_emissive_strength',
-    	EXT_MATERIALS_BUMP: 'EXT_materials_bump',
-    	EXT_TEXTURE_WEBP: 'EXT_texture_webp',
-    	EXT_TEXTURE_AVIF: 'EXT_texture_avif',
-    	EXT_MESHOPT_COMPRESSION: 'EXT_meshopt_compression',
-    	EXT_MESH_GPU_INSTANCING: 'EXT_mesh_gpu_instancing'
-    };
-    class GLTFLightsExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
-    		this.cache = { refs: {}, uses: {} };
-    	}
-    	_markDefs() {
-    		const parser = this.parser;
-    		const nodeDefs = this.parser.json.nodes || [];
-    		for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
-    			const nodeDef = nodeDefs[ nodeIndex ];
-    			if ( nodeDef.extensions
-    					&& nodeDef.extensions[ this.name ]
-    					&& nodeDef.extensions[ this.name ].light !== undefined ) {
-    				parser._addNodeRef( this.cache, nodeDef.extensions[ this.name ].light );
-    			}
-    		}
-    	}
-    	_loadLight( lightIndex ) {
-    		const parser = this.parser;
-    		const cacheKey = 'light:' + lightIndex;
-    		let dependency = parser.cache.get( cacheKey );
-    		if ( dependency ) return dependency;
-    		const json = parser.json;
-    		const extensions = ( json.extensions && json.extensions[ this.name ] ) || {};
-    		const lightDefs = extensions.lights || [];
-    		const lightDef = lightDefs[ lightIndex ];
-    		let lightNode;
-    		const color = new Color( 0xffffff );
-    		if ( lightDef.color !== undefined ) color.setRGB( lightDef.color[ 0 ], lightDef.color[ 1 ], lightDef.color[ 2 ], LinearSRGBColorSpace );
-    		const range = lightDef.range !== undefined ? lightDef.range : 0;
-    		switch ( lightDef.type ) {
-    			case 'directional':
-    				lightNode = new DirectionalLight( color );
-    				lightNode.target.position.set( 0, 0, -1 );
-    				lightNode.add( lightNode.target );
-    				break;
-    			case 'point':
-    				lightNode = new PointLight( color );
-    				lightNode.distance = range;
-    				break;
-    			case 'spot':
-    				lightNode = new SpotLight( color );
-    				lightNode.distance = range;
-    				lightDef.spot = lightDef.spot || {};
-    				lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== undefined ? lightDef.spot.innerConeAngle : 0;
-    				lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== undefined ? lightDef.spot.outerConeAngle : Math.PI / 4.0;
-    				lightNode.angle = lightDef.spot.outerConeAngle;
-    				lightNode.penumbra = 1.0 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
-    				lightNode.target.position.set( 0, 0, -1 );
-    				lightNode.add( lightNode.target );
-    				break;
-    			default:
-    				throw new Error( 'THREE.GLTFLoader: Unexpected light type: ' + lightDef.type );
-    		}
-    		lightNode.position.set( 0, 0, 0 );
-    		assignExtrasToUserData( lightNode, lightDef );
-    		if ( lightDef.intensity !== undefined ) lightNode.intensity = lightDef.intensity;
-    		lightNode.name = parser.createUniqueName( lightDef.name || ( 'light_' + lightIndex ) );
-    		dependency = Promise.resolve( lightNode );
-    		parser.cache.add( cacheKey, dependency );
-    		return dependency;
-    	}
-    	getDependency( type, index ) {
-    		if ( type !== 'light' ) return;
-    		return this._loadLight( index );
-    	}
-    	createNodeAttachment( nodeIndex ) {
-    		const self = this;
-    		const parser = this.parser;
-    		const json = parser.json;
-    		const nodeDef = json.nodes[ nodeIndex ];
-    		const lightDef = ( nodeDef.extensions && nodeDef.extensions[ this.name ] ) || {};
-    		const lightIndex = lightDef.light;
-    		if ( lightIndex === undefined ) return null;
-    		return this._loadLight( lightIndex ).then( function ( light ) {
-    			return parser._getNodeRef( self.cache, lightIndex, light );
-    		} );
-    	}
-    }
-    class GLTFMaterialsUnlitExtension {
-    	constructor() {
-    		this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
-    	}
-    	getMaterialType() {
-    		return MeshBasicMaterial;
-    	}
-    	extendParams( materialParams, materialDef, parser ) {
-    		const pending = [];
-    		materialParams.color = new Color( 1.0, 1.0, 1.0 );
-    		materialParams.opacity = 1.0;
-    		const metallicRoughness = materialDef.pbrMetallicRoughness;
-    		if ( metallicRoughness ) {
-    			if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
-    				const array = metallicRoughness.baseColorFactor;
-    				materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
-    				materialParams.opacity = array[ 3 ];
-    			}
-    			if ( metallicRoughness.baseColorTexture !== undefined ) {
-    				pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );
-    			}
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsEmissiveStrengthExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const emissiveStrength = materialDef.extensions[ this.name ].emissiveStrength;
-    		if ( emissiveStrength !== undefined ) {
-    			materialParams.emissiveIntensity = emissiveStrength;
-    		}
-    		return Promise.resolve();
-    	}
-    }
-    class GLTFMaterialsClearcoatExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		const extension = materialDef.extensions[ this.name ];
-    		if ( extension.clearcoatFactor !== undefined ) {
-    			materialParams.clearcoat = extension.clearcoatFactor;
-    		}
-    		if ( extension.clearcoatTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'clearcoatMap', extension.clearcoatTexture ) );
-    		}
-    		if ( extension.clearcoatRoughnessFactor !== undefined ) {
-    			materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
-    		}
-    		if ( extension.clearcoatRoughnessTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'clearcoatRoughnessMap', extension.clearcoatRoughnessTexture ) );
-    		}
-    		if ( extension.clearcoatNormalTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'clearcoatNormalMap', extension.clearcoatNormalTexture ) );
-    			if ( extension.clearcoatNormalTexture.scale !== undefined ) {
-    				const scale = extension.clearcoatNormalTexture.scale;
-    				materialParams.clearcoatNormalScale = new Vector2( scale, scale );
-    			}
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsDispersionExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_DISPERSION;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const extension = materialDef.extensions[ this.name ];
-    		materialParams.dispersion = extension.dispersion !== undefined ? extension.dispersion : 0;
-    		return Promise.resolve();
-    	}
-    }
-    class GLTFMaterialsIridescenceExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		const extension = materialDef.extensions[ this.name ];
-    		if ( extension.iridescenceFactor !== undefined ) {
-    			materialParams.iridescence = extension.iridescenceFactor;
-    		}
-    		if ( extension.iridescenceTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'iridescenceMap', extension.iridescenceTexture ) );
-    		}
-    		if ( extension.iridescenceIor !== undefined ) {
-    			materialParams.iridescenceIOR = extension.iridescenceIor;
-    		}
-    		if ( materialParams.iridescenceThicknessRange === undefined ) {
-    			materialParams.iridescenceThicknessRange = [ 100, 400 ];
-    		}
-    		if ( extension.iridescenceThicknessMinimum !== undefined ) {
-    			materialParams.iridescenceThicknessRange[ 0 ] = extension.iridescenceThicknessMinimum;
-    		}
-    		if ( extension.iridescenceThicknessMaximum !== undefined ) {
-    			materialParams.iridescenceThicknessRange[ 1 ] = extension.iridescenceThicknessMaximum;
-    		}
-    		if ( extension.iridescenceThicknessTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'iridescenceThicknessMap', extension.iridescenceThicknessTexture ) );
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsSheenExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_SHEEN;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		materialParams.sheenColor = new Color( 0, 0, 0 );
-    		materialParams.sheenRoughness = 0;
-    		materialParams.sheen = 1;
-    		const extension = materialDef.extensions[ this.name ];
-    		if ( extension.sheenColorFactor !== undefined ) {
-    			const colorFactor = extension.sheenColorFactor;
-    			materialParams.sheenColor.setRGB( colorFactor[ 0 ], colorFactor[ 1 ], colorFactor[ 2 ], LinearSRGBColorSpace );
-    		}
-    		if ( extension.sheenRoughnessFactor !== undefined ) {
-    			materialParams.sheenRoughness = extension.sheenRoughnessFactor;
-    		}
-    		if ( extension.sheenColorTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'sheenColorMap', extension.sheenColorTexture, SRGBColorSpace ) );
-    		}
-    		if ( extension.sheenRoughnessTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'sheenRoughnessMap', extension.sheenRoughnessTexture ) );
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsTransmissionExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		const extension = materialDef.extensions[ this.name ];
-    		if ( extension.transmissionFactor !== undefined ) {
-    			materialParams.transmission = extension.transmissionFactor;
-    		}
-    		if ( extension.transmissionTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'transmissionMap', extension.transmissionTexture ) );
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsVolumeExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_VOLUME;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		const extension = materialDef.extensions[ this.name ];
-    		materialParams.thickness = extension.thicknessFactor !== undefined ? extension.thicknessFactor : 0;
-    		if ( extension.thicknessTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'thicknessMap', extension.thicknessTexture ) );
-    		}
-    		materialParams.attenuationDistance = extension.attenuationDistance || Infinity;
-    		const colorArray = extension.attenuationColor || [ 1, 1, 1 ];
-    		materialParams.attenuationColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsIorExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_IOR;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const extension = materialDef.extensions[ this.name ];
-    		materialParams.ior = extension.ior !== undefined ? extension.ior : 1.5;
-    		return Promise.resolve();
-    	}
-    }
-    class GLTFMaterialsSpecularExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		const extension = materialDef.extensions[ this.name ];
-    		materialParams.specularIntensity = extension.specularFactor !== undefined ? extension.specularFactor : 1.0;
-    		if ( extension.specularTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'specularIntensityMap', extension.specularTexture ) );
-    		}
-    		const colorArray = extension.specularColorFactor || [ 1, 1, 1 ];
-    		materialParams.specularColor = new Color().setRGB( colorArray[ 0 ], colorArray[ 1 ], colorArray[ 2 ], LinearSRGBColorSpace );
-    		if ( extension.specularColorTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'specularColorMap', extension.specularColorTexture, SRGBColorSpace ) );
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsBumpExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.EXT_MATERIALS_BUMP;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		const extension = materialDef.extensions[ this.name ];
-    		materialParams.bumpScale = extension.bumpFactor !== undefined ? extension.bumpFactor : 1.0;
-    		if ( extension.bumpTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'bumpMap', extension.bumpTexture ) );
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFMaterialsAnisotropyExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY;
-    	}
-    	getMaterialType( materialIndex ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) return null;
-    		return MeshPhysicalMaterial;
-    	}
-    	extendMaterialParams( materialIndex, materialParams ) {
-    		const parser = this.parser;
-    		const materialDef = parser.json.materials[ materialIndex ];
-    		if ( ! materialDef.extensions || ! materialDef.extensions[ this.name ] ) {
-    			return Promise.resolve();
-    		}
-    		const pending = [];
-    		const extension = materialDef.extensions[ this.name ];
-    		if ( extension.anisotropyStrength !== undefined ) {
-    			materialParams.anisotropy = extension.anisotropyStrength;
-    		}
-    		if ( extension.anisotropyRotation !== undefined ) {
-    			materialParams.anisotropyRotation = extension.anisotropyRotation;
-    		}
-    		if ( extension.anisotropyTexture !== undefined ) {
-    			pending.push( parser.assignTexture( materialParams, 'anisotropyMap', extension.anisotropyTexture ) );
-    		}
-    		return Promise.all( pending );
-    	}
-    }
-    class GLTFTextureBasisUExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.KHR_TEXTURE_BASISU;
-    	}
-    	loadTexture( textureIndex ) {
-    		const parser = this.parser;
-    		const json = parser.json;
-    		const textureDef = json.textures[ textureIndex ];
-    		if ( ! textureDef.extensions || ! textureDef.extensions[ this.name ] ) {
-    			return null;
-    		}
-    		const extension = textureDef.extensions[ this.name ];
-    		const loader = parser.options.ktx2Loader;
-    		if ( ! loader ) {
-    			if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {
-    				throw new Error( 'THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures' );
-    			} else {
-    				return null;
-    			}
-    		}
-    		return parser.loadTextureImage( textureIndex, extension.source, loader );
-    	}
-    }
-    class GLTFTextureWebPExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.EXT_TEXTURE_WEBP;
-    	}
-    	loadTexture( textureIndex ) {
-    		const name = this.name;
-    		const parser = this.parser;
-    		const json = parser.json;
-    		const textureDef = json.textures[ textureIndex ];
-    		if ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) {
-    			return null;
-    		}
-    		const extension = textureDef.extensions[ name ];
-    		const source = json.images[ extension.source ];
-    		let loader = parser.textureLoader;
-    		if ( source.uri ) {
-    			const handler = parser.options.manager.getHandler( source.uri );
-    			if ( handler !== null ) loader = handler;
-    		}
-    		return parser.loadTextureImage( textureIndex, extension.source, loader );
-    	}
-    }
-    class GLTFTextureAVIFExtension {
-    	constructor( parser ) {
-    		this.parser = parser;
-    		this.name = EXTENSIONS.EXT_TEXTURE_AVIF;
-    	}
-    	loadTexture( textureIndex ) {
-    		const name = this.name;
-    		const parser = this.parser;
-    		const json = parser.json;
-    		const textureDef = json.textures[ textureIndex ];
-    		if ( ! textureDef.extensions || ! textureDef.extensions[ name ] ) {
-    			return null;
-    		}
-    		const extension = textureDef.extensions[ name ];
-    		const source = json.images[ extension.source ];
-    		let loader = parser.textureLoader;
-    		if ( source.uri ) {
-    			const handler = parser.options.manager.getHandler( source.uri );
-    			if ( handler !== null ) loader = handler;
-    		}
-    		return parser.loadTextureImage( textureIndex, extension.source, loader );
-    	}
-    }
-    class GLTFMeshoptCompression {
-    	constructor( parser ) {
-    		this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION;
-    		this.parser = parser;
-    	}
-    	loadBufferView( index ) {
-    		const json = this.parser.json;
-    		const bufferView = json.bufferViews[ index ];
-    		if ( bufferView.extensions && bufferView.extensions[ this.name ] ) {
-    			const extensionDef = bufferView.extensions[ this.name ];
-    			const buffer = this.parser.getDependency( 'buffer', extensionDef.buffer );
-    			const decoder = this.parser.options.meshoptDecoder;
-    			if ( ! decoder || ! decoder.supported ) {
-    				if ( json.extensionsRequired && json.extensionsRequired.indexOf( this.name ) >= 0 ) {
-    					throw new Error( 'THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files' );
-    				} else {
-    					return null;
-    				}
-    			}
-    			return buffer.then( function ( res ) {
-    				const byteOffset = extensionDef.byteOffset || 0;
-    				const byteLength = extensionDef.byteLength || 0;
-    				const count = extensionDef.count;
-    				const stride = extensionDef.byteStride;
-    				const source = new Uint8Array( res, byteOffset, byteLength );
-    				if ( decoder.decodeGltfBufferAsync ) {
-    					return decoder.decodeGltfBufferAsync( count, stride, source, extensionDef.mode, extensionDef.filter ).then( function ( res ) {
-    						return res.buffer;
-    					} );
-    				} else {
-    					return decoder.ready.then( function () {
-    						const result = new ArrayBuffer( count * stride );
-    						decoder.decodeGltfBuffer( new Uint8Array( result ), count, stride, source, extensionDef.mode, extensionDef.filter );
-    						return result;
-    					} );
-    				}
-    			} );
-    		} else {
-    			return null;
-    		}
-    	}
-    }
-    class GLTFMeshGpuInstancing {
-    	constructor( parser ) {
-    		this.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING;
-    		this.parser = parser;
-    	}
-    	createNodeMesh( nodeIndex ) {
-    		const json = this.parser.json;
-    		const nodeDef = json.nodes[ nodeIndex ];
-    		if ( ! nodeDef.extensions || ! nodeDef.extensions[ this.name ] ||
-    			nodeDef.mesh === undefined ) {
-    			return null;
-    		}
-    		const meshDef = json.meshes[ nodeDef.mesh ];
-    		for ( const primitive of meshDef.primitives ) {
-    			if ( primitive.mode !== WEBGL_CONSTANTS.TRIANGLES &&
-    				 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP &&
-    				 primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN &&
-    				 primitive.mode !== undefined ) {
-    				return null;
-    			}
-    		}
-    		const extensionDef = nodeDef.extensions[ this.name ];
-    		const attributesDef = extensionDef.attributes;
-    		const pending = [];
-    		const attributes = {};
-    		for ( const key in attributesDef ) {
-    			pending.push( this.parser.getDependency( 'accessor', attributesDef[ key ] ).then( accessor => {
-    				attributes[ key ] = accessor;
-    				return attributes[ key ];
-    			} ) );
-    		}
-    		if ( pending.length < 1 ) {
-    			return null;
-    		}
-    		pending.push( this.parser.createNodeMesh( nodeIndex ) );
-    		return Promise.all( pending ).then( results => {
-    			const nodeObject = results.pop();
-    			const meshes = nodeObject.isGroup ? nodeObject.children : [ nodeObject ];
-    			const count = results[ 0 ].count;
-    			const instancedMeshes = [];
-    			for ( const mesh of meshes ) {
-    				const m = new Matrix4();
-    				const p = new Vector3();
-    				const q = new Quaternion();
-    				const s = new Vector3( 1, 1, 1 );
-    				const instancedMesh = new InstancedMesh( mesh.geometry, mesh.material, count );
-    				for ( let i = 0; i < count; i ++ ) {
-    					if ( attributes.TRANSLATION ) {
-    						p.fromBufferAttribute( attributes.TRANSLATION, i );
-    					}
-    					if ( attributes.ROTATION ) {
-    						q.fromBufferAttribute( attributes.ROTATION, i );
-    					}
-    					if ( attributes.SCALE ) {
-    						s.fromBufferAttribute( attributes.SCALE, i );
-    					}
-    					instancedMesh.setMatrixAt( i, m.compose( p, q, s ) );
-    				}
-    				for ( const attributeName in attributes ) {
-    					if ( attributeName === '_COLOR_0' ) {
-    						const attr = attributes[ attributeName ];
-    						instancedMesh.instanceColor = new InstancedBufferAttribute( attr.array, attr.itemSize, attr.normalized );
-    					} else if ( attributeName !== 'TRANSLATION' &&
-    						 attributeName !== 'ROTATION' &&
-    						 attributeName !== 'SCALE' ) {
-    						mesh.geometry.setAttribute( attributeName, attributes[ attributeName ] );
-    					}
-    				}
-    				Object3D.prototype.copy.call( instancedMesh, mesh );
-    				this.parser.assignFinalMaterial( instancedMesh );
-    				instancedMeshes.push( instancedMesh );
-    			}
-    			if ( nodeObject.isGroup ) {
-    				nodeObject.clear();
-    				nodeObject.add( ... instancedMeshes );
-    				return nodeObject;
-    			}
-    			return instancedMeshes[ 0 ];
-    		} );
-    	}
-    }
-    const BINARY_EXTENSION_HEADER_MAGIC = 'glTF';
-    const BINARY_EXTENSION_HEADER_LENGTH = 12;
-    const BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4E4F534A, BIN: 0x004E4942 };
-    class GLTFBinaryExtension {
-    	constructor( data ) {
-    		this.name = EXTENSIONS.KHR_BINARY_GLTF;
-    		this.content = null;
-    		this.body = null;
-    		const headerView = new DataView( data, 0, BINARY_EXTENSION_HEADER_LENGTH );
-    		const textDecoder = new TextDecoder();
-    		this.header = {
-    			magic: textDecoder.decode( new Uint8Array( data.slice( 0, 4 ) ) ),
-    			version: headerView.getUint32( 4, true ),
-    			length: headerView.getUint32( 8, true )
-    		};
-    		if ( this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC ) {
-    			throw new Error( 'THREE.GLTFLoader: Unsupported glTF-Binary header.' );
-    		} else if ( this.header.version < 2.0 ) {
-    			throw new Error( 'THREE.GLTFLoader: Legacy binary file detected.' );
-    		}
-    		const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;
-    		const chunkView = new DataView( data, BINARY_EXTENSION_HEADER_LENGTH );
-    		let chunkIndex = 0;
-    		while ( chunkIndex < chunkContentsLength ) {
-    			const chunkLength = chunkView.getUint32( chunkIndex, true );
-    			chunkIndex += 4;
-    			const chunkType = chunkView.getUint32( chunkIndex, true );
-    			chunkIndex += 4;
-    			if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON ) {
-    				const contentArray = new Uint8Array( data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength );
-    				this.content = textDecoder.decode( contentArray );
-    			} else if ( chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN ) {
-    				const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
-    				this.body = data.slice( byteOffset, byteOffset + chunkLength );
-    			}
-    			chunkIndex += chunkLength;
-    		}
-    		if ( this.content === null ) {
-    			throw new Error( 'THREE.GLTFLoader: JSON content not found.' );
-    		}
-    	}
-    }
-    class GLTFDracoMeshCompressionExtension {
-    	constructor( json, dracoLoader ) {
-    		if ( ! dracoLoader ) {
-    			throw new Error( 'THREE.GLTFLoader: No DRACOLoader instance provided.' );
-    		}
-    		this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
-    		this.json = json;
-    		this.dracoLoader = dracoLoader;
-    		this.dracoLoader.preload();
-    	}
-    	decodePrimitive( primitive, parser ) {
-    		const json = this.json;
-    		const dracoLoader = this.dracoLoader;
-    		const bufferViewIndex = primitive.extensions[ this.name ].bufferView;
-    		const gltfAttributeMap = primitive.extensions[ this.name ].attributes;
-    		const threeAttributeMap = {};
-    		const attributeNormalizedMap = {};
-    		const attributeTypeMap = {};
-    		for ( const attributeName in gltfAttributeMap ) {
-    			const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
-    			threeAttributeMap[ threeAttributeName ] = gltfAttributeMap[ attributeName ];
-    		}
-    		for ( const attributeName in primitive.attributes ) {
-    			const threeAttributeName = ATTRIBUTES[ attributeName ] || attributeName.toLowerCase();
-    			if ( gltfAttributeMap[ attributeName ] !== undefined ) {
-    				const accessorDef = json.accessors[ primitive.attributes[ attributeName ] ];
-    				const componentType = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
-    				attributeTypeMap[ threeAttributeName ] = componentType.name;
-    				attributeNormalizedMap[ threeAttributeName ] = accessorDef.normalized === true;
-    			}
-    		}
-    		return parser.getDependency( 'bufferView', bufferViewIndex ).then( function ( bufferView ) {
-    			return new Promise( function ( resolve, reject ) {
-    				dracoLoader.decodeDracoFile( bufferView, function ( geometry ) {
-    					for ( const attributeName in geometry.attributes ) {
-    						const attribute = geometry.attributes[ attributeName ];
-    						const normalized = attributeNormalizedMap[ attributeName ];
-    						if ( normalized !== undefined ) attribute.normalized = normalized;
-    					}
-    					resolve( geometry );
-    				}, threeAttributeMap, attributeTypeMap, LinearSRGBColorSpace, reject );
-    			} );
-    		} );
-    	}
-    }
-    class GLTFTextureTransformExtension {
-    	constructor() {
-    		this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
-    	}
-    	extendTexture( texture, transform ) {
-    		if ( ( transform.texCoord === undefined || transform.texCoord === texture.channel )
-    			&& transform.offset === undefined
-    			&& transform.rotation === undefined
-    			&& transform.scale === undefined ) {
-    			return texture;
-    		}
-    		texture = texture.clone();
-    		if ( transform.texCoord !== undefined ) {
-    			texture.channel = transform.texCoord;
-    		}
-    		if ( transform.offset !== undefined ) {
-    			texture.offset.fromArray( transform.offset );
-    		}
-    		if ( transform.rotation !== undefined ) {
-    			texture.rotation = transform.rotation;
-    		}
-    		if ( transform.scale !== undefined ) {
-    			texture.repeat.fromArray( transform.scale );
-    		}
-    		texture.needsUpdate = true;
-    		return texture;
-    	}
-    }
-    class GLTFMeshQuantizationExtension {
-    	constructor() {
-    		this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
-    	}
-    }
-    class GLTFCubicSplineInterpolant extends Interpolant {
-    	constructor( parameterPositions, sampleValues, sampleSize, resultBuffer ) {
-    		super( parameterPositions, sampleValues, sampleSize, resultBuffer );
-    	}
-    	copySampleValue_( index ) {
-    		const result = this.resultBuffer,
-    			values = this.sampleValues,
-    			valueSize = this.valueSize,
-    			offset = index * valueSize * 3 + valueSize;
-    		for ( let i = 0; i !== valueSize; i ++ ) {
-    			result[ i ] = values[ offset + i ];
-    		}
-    		return result;
-    	}
-    	interpolate_( i1, t0, t, t1 ) {
-    		const result = this.resultBuffer;
-    		const values = this.sampleValues;
-    		const stride = this.valueSize;
-    		const stride2 = stride * 2;
-    		const stride3 = stride * 3;
-    		const td = t1 - t0;
-    		const p = ( t - t0 ) / td;
-    		const pp = p * p;
-    		const ppp = pp * p;
-    		const offset1 = i1 * stride3;
-    		const offset0 = offset1 - stride3;
-    		const s2 = -2 * ppp + 3 * pp;
-    		const s3 = ppp - pp;
-    		const s0 = 1 - s2;
-    		const s1 = s3 - pp + p;
-    		for ( let i = 0; i !== stride; i ++ ) {
-    			const p0 = values[ offset0 + i + stride ];
-    			const m0 = values[ offset0 + i + stride2 ] * td;
-    			const p1 = values[ offset1 + i + stride ];
-    			const m1 = values[ offset1 + i ] * td;
-    			result[ i ] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
-    		}
-    		return result;
-    	}
-    }
-    const _quaternion = new Quaternion();
-    class GLTFCubicSplineQuaternionInterpolant extends GLTFCubicSplineInterpolant {
-    	interpolate_( i1, t0, t, t1 ) {
-    		const result = super.interpolate_( i1, t0, t, t1 );
-    		_quaternion.fromArray( result ).normalize().toArray( result );
-    		return result;
-    	}
-    }
-    const WEBGL_CONSTANTS = {
-    	POINTS: 0,
-    	LINES: 1,
-    	LINE_LOOP: 2,
-    	LINE_STRIP: 3,
-    	TRIANGLES: 4,
-    	TRIANGLE_STRIP: 5,
-    	TRIANGLE_FAN: 6};
-    const WEBGL_COMPONENT_TYPES = {
-    	5120: Int8Array,
-    	5121: Uint8Array,
-    	5122: Int16Array,
-    	5123: Uint16Array,
-    	5125: Uint32Array,
-    	5126: Float32Array
-    };
-    const WEBGL_FILTERS = {
-    	9728: NearestFilter,
-    	9729: LinearFilter,
-    	9984: NearestMipmapNearestFilter,
-    	9985: LinearMipmapNearestFilter,
-    	9986: NearestMipmapLinearFilter,
-    	9987: LinearMipmapLinearFilter
-    };
-    const WEBGL_WRAPPINGS = {
-    	33071: ClampToEdgeWrapping,
-    	33648: MirroredRepeatWrapping,
-    	10497: RepeatWrapping
-    };
-    const WEBGL_TYPE_SIZES = {
-    	'SCALAR': 1,
-    	'VEC2': 2,
-    	'VEC3': 3,
-    	'VEC4': 4,
-    	'MAT2': 4,
-    	'MAT3': 9,
-    	'MAT4': 16
-    };
-    const ATTRIBUTES = {
-    	POSITION: 'position',
-    	NORMAL: 'normal',
-    	TANGENT: 'tangent',
-    	TEXCOORD_0: 'uv',
-    	TEXCOORD_1: 'uv1',
-    	TEXCOORD_2: 'uv2',
-    	TEXCOORD_3: 'uv3',
-    	COLOR_0: 'color',
-    	WEIGHTS_0: 'skinWeight',
-    	JOINTS_0: 'skinIndex',
-    };
-    const PATH_PROPERTIES = {
-    	scale: 'scale',
-    	translation: 'position',
-    	rotation: 'quaternion',
-    	weights: 'morphTargetInfluences'
-    };
-    const INTERPOLATION = {
-    	CUBICSPLINE: undefined,
-    	LINEAR: InterpolateLinear,
-    	STEP: InterpolateDiscrete
-    };
-    const ALPHA_MODES = {
-    	OPAQUE: 'OPAQUE',
-    	MASK: 'MASK',
-    	BLEND: 'BLEND'
-    };
-    function createDefaultMaterial( cache ) {
-    	if ( cache[ 'DefaultMaterial' ] === undefined ) {
-    		cache[ 'DefaultMaterial' ] = new MeshStandardMaterial( {
-    			color: 0xFFFFFF,
-    			emissive: 0x000000,
-    			metalness: 1,
-    			roughness: 1,
-    			transparent: false,
-    			depthTest: true,
-    			side: FrontSide
-    		} );
-    	}
-    	return cache[ 'DefaultMaterial' ];
-    }
-    function addUnknownExtensionsToUserData( knownExtensions, object, objectDef ) {
-    	for ( const name in objectDef.extensions ) {
-    		if ( knownExtensions[ name ] === undefined ) {
-    			object.userData.gltfExtensions = object.userData.gltfExtensions || {};
-    			object.userData.gltfExtensions[ name ] = objectDef.extensions[ name ];
-    		}
-    	}
-    }
-    function assignExtrasToUserData( object, gltfDef ) {
-    	if ( gltfDef.extras !== undefined ) {
-    		if ( typeof gltfDef.extras === 'object' ) {
-    			Object.assign( object.userData, gltfDef.extras );
-    		} else {
-    			console.warn( 'THREE.GLTFLoader: Ignoring primitive type .extras, ' + gltfDef.extras );
-    		}
-    	}
-    }
-    function addMorphTargets( geometry, targets, parser ) {
-    	let hasMorphPosition = false;
-    	let hasMorphNormal = false;
-    	let hasMorphColor = false;
-    	for ( let i = 0, il = targets.length; i < il; i ++ ) {
-    		const target = targets[ i ];
-    		if ( target.POSITION !== undefined ) hasMorphPosition = true;
-    		if ( target.NORMAL !== undefined ) hasMorphNormal = true;
-    		if ( target.COLOR_0 !== undefined ) hasMorphColor = true;
-    		if ( hasMorphPosition && hasMorphNormal && hasMorphColor ) break;
-    	}
-    	if ( ! hasMorphPosition && ! hasMorphNormal && ! hasMorphColor ) return Promise.resolve( geometry );
-    	const pendingPositionAccessors = [];
-    	const pendingNormalAccessors = [];
-    	const pendingColorAccessors = [];
-    	for ( let i = 0, il = targets.length; i < il; i ++ ) {
-    		const target = targets[ i ];
-    		if ( hasMorphPosition ) {
-    			const pendingAccessor = target.POSITION !== undefined
-    				? parser.getDependency( 'accessor', target.POSITION )
-    				: geometry.attributes.position;
-    			pendingPositionAccessors.push( pendingAccessor );
-    		}
-    		if ( hasMorphNormal ) {
-    			const pendingAccessor = target.NORMAL !== undefined
-    				? parser.getDependency( 'accessor', target.NORMAL )
-    				: geometry.attributes.normal;
-    			pendingNormalAccessors.push( pendingAccessor );
-    		}
-    		if ( hasMorphColor ) {
-    			const pendingAccessor = target.COLOR_0 !== undefined
-    				? parser.getDependency( 'accessor', target.COLOR_0 )
-    				: geometry.attributes.color;
-    			pendingColorAccessors.push( pendingAccessor );
-    		}
-    	}
-    	return Promise.all( [
-    		Promise.all( pendingPositionAccessors ),
-    		Promise.all( pendingNormalAccessors ),
-    		Promise.all( pendingColorAccessors )
-    	] ).then( function ( accessors ) {
-    		const morphPositions = accessors[ 0 ];
-    		const morphNormals = accessors[ 1 ];
-    		const morphColors = accessors[ 2 ];
-    		if ( hasMorphPosition ) geometry.morphAttributes.position = morphPositions;
-    		if ( hasMorphNormal ) geometry.morphAttributes.normal = morphNormals;
-    		if ( hasMorphColor ) geometry.morphAttributes.color = morphColors;
-    		geometry.morphTargetsRelative = true;
-    		return geometry;
-    	} );
-    }
-    function updateMorphTargets( mesh, meshDef ) {
-    	mesh.updateMorphTargets();
-    	if ( meshDef.weights !== undefined ) {
-    		for ( let i = 0, il = meshDef.weights.length; i < il; i ++ ) {
-    			mesh.morphTargetInfluences[ i ] = meshDef.weights[ i ];
-    		}
-    	}
-    	if ( meshDef.extras && Array.isArray( meshDef.extras.targetNames ) ) {
-    		const targetNames = meshDef.extras.targetNames;
-    		if ( mesh.morphTargetInfluences.length === targetNames.length ) {
-    			mesh.morphTargetDictionary = {};
-    			for ( let i = 0, il = targetNames.length; i < il; i ++ ) {
-    				mesh.morphTargetDictionary[ targetNames[ i ] ] = i;
-    			}
-    		} else {
-    			console.warn( 'THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.' );
-    		}
-    	}
-    }
-    function createPrimitiveKey( primitiveDef ) {
-    	let geometryKey;
-    	const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ];
-    	if ( dracoExtension ) {
-    		geometryKey = 'draco:' + dracoExtension.bufferView
-    				+ ':' + dracoExtension.indices
-    				+ ':' + createAttributesKey( dracoExtension.attributes );
-    	} else {
-    		geometryKey = primitiveDef.indices + ':' + createAttributesKey( primitiveDef.attributes ) + ':' + primitiveDef.mode;
-    	}
-    	if ( primitiveDef.targets !== undefined ) {
-    		for ( let i = 0, il = primitiveDef.targets.length; i < il; i ++ ) {
-    			geometryKey += ':' + createAttributesKey( primitiveDef.targets[ i ] );
-    		}
-    	}
-    	return geometryKey;
-    }
-    function createAttributesKey( attributes ) {
-    	let attributesKey = '';
-    	const keys = Object.keys( attributes ).sort();
-    	for ( let i = 0, il = keys.length; i < il; i ++ ) {
-    		attributesKey += keys[ i ] + ':' + attributes[ keys[ i ] ] + ';';
-    	}
-    	return attributesKey;
-    }
-    function getNormalizedComponentScale( constructor ) {
-    	switch ( constructor ) {
-    		case Int8Array:
-    			return 1 / 127;
-    		case Uint8Array:
-    			return 1 / 255;
-    		case Int16Array:
-    			return 1 / 32767;
-    		case Uint16Array:
-    			return 1 / 65535;
-    		default:
-    			throw new Error( 'THREE.GLTFLoader: Unsupported normalized accessor component type.' );
-    	}
-    }
-    function getImageURIMimeType( uri ) {
-    	if ( uri.search( /\.jpe?g($|\?)/i ) > 0 || uri.search( /^data\:image\/jpeg/ ) === 0 ) return 'image/jpeg';
-    	if ( uri.search( /\.webp($|\?)/i ) > 0 || uri.search( /^data\:image\/webp/ ) === 0 ) return 'image/webp';
-    	if ( uri.search( /\.ktx2($|\?)/i ) > 0 || uri.search( /^data\:image\/ktx2/ ) === 0 ) return 'image/ktx2';
-    	return 'image/png';
-    }
-    const _identityMatrix = new Matrix4();
-    class GLTFParser {
-    	constructor( json = {}, options = {} ) {
-    		this.json = json;
-    		this.extensions = {};
-    		this.plugins = {};
-    		this.options = options;
-    		this.cache = new GLTFRegistry();
-    		this.associations = new Map();
-    		this.primitiveCache = {};
-    		this.nodeCache = {};
-    		this.meshCache = { refs: {}, uses: {} };
-    		this.cameraCache = { refs: {}, uses: {} };
-    		this.lightCache = { refs: {}, uses: {} };
-    		this.sourceCache = {};
-    		this.textureCache = {};
-    		this.nodeNamesUsed = {};
-    		let isSafari = false;
-    		let safariVersion = -1;
-    		let isFirefox = false;
-    		let firefoxVersion = -1;
-    		if ( typeof navigator !== 'undefined' ) {
-    			const userAgent = navigator.userAgent;
-    			isSafari = /^((?!chrome|android).)*safari/i.test( userAgent ) === true;
-    			const safariMatch = userAgent.match( /Version\/(\d+)/ );
-    			safariVersion = isSafari && safariMatch ? parseInt( safariMatch[ 1 ], 10 ) : -1;
-    			isFirefox = userAgent.indexOf( 'Firefox' ) > -1;
-    			firefoxVersion = isFirefox ? userAgent.match( /Firefox\/([0-9]+)\./ )[ 1 ] : -1;
-    		}
-    		if ( typeof createImageBitmap === 'undefined' || ( isSafari && safariVersion < 17 ) || ( isFirefox && firefoxVersion < 98 ) ) {
-    			this.textureLoader = new TextureLoader( this.options.manager );
-    		} else {
-    			this.textureLoader = new ImageBitmapLoader( this.options.manager );
-    		}
-    		this.textureLoader.setCrossOrigin( this.options.crossOrigin );
-    		this.textureLoader.setRequestHeader( this.options.requestHeader );
-    		this.fileLoader = new FileLoader( this.options.manager );
-    		this.fileLoader.setResponseType( 'arraybuffer' );
-    		if ( this.options.crossOrigin === 'use-credentials' ) {
-    			this.fileLoader.setWithCredentials( true );
-    		}
-    	}
-    	setExtensions( extensions ) {
-    		this.extensions = extensions;
-    	}
-    	setPlugins( plugins ) {
-    		this.plugins = plugins;
-    	}
-    	parse( onLoad, onError ) {
-    		const parser = this;
-    		const json = this.json;
-    		const extensions = this.extensions;
-    		this.cache.removeAll();
-    		this.nodeCache = {};
-    		this._invokeAll( function ( ext ) {
-    			return ext._markDefs && ext._markDefs();
-    		} );
-    		Promise.all( this._invokeAll( function ( ext ) {
-    			return ext.beforeRoot && ext.beforeRoot();
-    		} ) ).then( function () {
-    			return Promise.all( [
-    				parser.getDependencies( 'scene' ),
-    				parser.getDependencies( 'animation' ),
-    				parser.getDependencies( 'camera' ),
-    			] );
-    		} ).then( function ( dependencies ) {
-    			const result = {
-    				scene: dependencies[ 0 ][ json.scene || 0 ],
-    				scenes: dependencies[ 0 ],
-    				animations: dependencies[ 1 ],
-    				cameras: dependencies[ 2 ],
-    				asset: json.asset,
-    				parser: parser,
-    				userData: {}
-    			};
-    			addUnknownExtensionsToUserData( extensions, result, json );
-    			assignExtrasToUserData( result, json );
-    			return Promise.all( parser._invokeAll( function ( ext ) {
-    				return ext.afterRoot && ext.afterRoot( result );
-    			} ) ).then( function () {
-    				for ( const scene of result.scenes ) {
-    					scene.updateMatrixWorld();
-    				}
-    				onLoad( result );
-    			} );
-    		} ).catch( onError );
-    	}
-    	_markDefs() {
-    		const nodeDefs = this.json.nodes || [];
-    		const skinDefs = this.json.skins || [];
-    		const meshDefs = this.json.meshes || [];
-    		for ( let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex ++ ) {
-    			const joints = skinDefs[ skinIndex ].joints;
-    			for ( let i = 0, il = joints.length; i < il; i ++ ) {
-    				nodeDefs[ joints[ i ] ].isBone = true;
-    			}
-    		}
-    		for ( let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex ++ ) {
-    			const nodeDef = nodeDefs[ nodeIndex ];
-    			if ( nodeDef.mesh !== undefined ) {
-    				this._addNodeRef( this.meshCache, nodeDef.mesh );
-    				if ( nodeDef.skin !== undefined ) {
-    					meshDefs[ nodeDef.mesh ].isSkinnedMesh = true;
-    				}
-    			}
-    			if ( nodeDef.camera !== undefined ) {
-    				this._addNodeRef( this.cameraCache, nodeDef.camera );
-    			}
-    		}
-    	}
-    	_addNodeRef( cache, index ) {
-    		if ( index === undefined ) return;
-    		if ( cache.refs[ index ] === undefined ) {
-    			cache.refs[ index ] = cache.uses[ index ] = 0;
-    		}
-    		cache.refs[ index ] ++;
-    	}
-    	_getNodeRef( cache, index, object ) {
-    		if ( cache.refs[ index ] <= 1 ) return object;
-    		const ref = object.clone();
-    		const updateMappings = ( original, clone ) => {
-    			const mappings = this.associations.get( original );
-    			if ( mappings != null ) {
-    				this.associations.set( clone, mappings );
-    			}
-    			for ( const [ i, child ] of original.children.entries() ) {
-    				updateMappings( child, clone.children[ i ] );
-    			}
-    		};
-    		updateMappings( object, ref );
-    		ref.name += '_instance_' + ( cache.uses[ index ] ++ );
-    		return ref;
-    	}
-    	_invokeOne( func ) {
-    		const extensions = Object.values( this.plugins );
-    		extensions.push( this );
-    		for ( let i = 0; i < extensions.length; i ++ ) {
-    			const result = func( extensions[ i ] );
-    			if ( result ) return result;
-    		}
-    		return null;
-    	}
-    	_invokeAll( func ) {
-    		const extensions = Object.values( this.plugins );
-    		extensions.unshift( this );
-    		const pending = [];
-    		for ( let i = 0; i < extensions.length; i ++ ) {
-    			const result = func( extensions[ i ] );
-    			if ( result ) pending.push( result );
-    		}
-    		return pending;
-    	}
-    	getDependency( type, index ) {
-    		const cacheKey = type + ':' + index;
-    		let dependency = this.cache.get( cacheKey );
-    		if ( ! dependency ) {
-    			switch ( type ) {
-    				case 'scene':
-    					dependency = this.loadScene( index );
-    					break;
-    				case 'node':
-    					dependency = this._invokeOne( function ( ext ) {
-    						return ext.loadNode && ext.loadNode( index );
-    					} );
-    					break;
-    				case 'mesh':
-    					dependency = this._invokeOne( function ( ext ) {
-    						return ext.loadMesh && ext.loadMesh( index );
-    					} );
-    					break;
-    				case 'accessor':
-    					dependency = this.loadAccessor( index );
-    					break;
-    				case 'bufferView':
-    					dependency = this._invokeOne( function ( ext ) {
-    						return ext.loadBufferView && ext.loadBufferView( index );
-    					} );
-    					break;
-    				case 'buffer':
-    					dependency = this.loadBuffer( index );
-    					break;
-    				case 'material':
-    					dependency = this._invokeOne( function ( ext ) {
-    						return ext.loadMaterial && ext.loadMaterial( index );
-    					} );
-    					break;
-    				case 'texture':
-    					dependency = this._invokeOne( function ( ext ) {
-    						return ext.loadTexture && ext.loadTexture( index );
-    					} );
-    					break;
-    				case 'skin':
-    					dependency = this.loadSkin( index );
-    					break;
-    				case 'animation':
-    					dependency = this._invokeOne( function ( ext ) {
-    						return ext.loadAnimation && ext.loadAnimation( index );
-    					} );
-    					break;
-    				case 'camera':
-    					dependency = this.loadCamera( index );
-    					break;
-    				default:
-    					dependency = this._invokeOne( function ( ext ) {
-    						return ext != this && ext.getDependency && ext.getDependency( type, index );
-    					} );
-    					if ( ! dependency ) {
-    						throw new Error( 'Unknown type: ' + type );
-    					}
-    					break;
-    			}
-    			this.cache.add( cacheKey, dependency );
-    		}
-    		return dependency;
-    	}
-    	getDependencies( type ) {
-    		let dependencies = this.cache.get( type );
-    		if ( ! dependencies ) {
-    			const parser = this;
-    			const defs = this.json[ type + ( type === 'mesh' ? 'es' : 's' ) ] || [];
-    			dependencies = Promise.all( defs.map( function ( def, index ) {
-    				return parser.getDependency( type, index );
-    			} ) );
-    			this.cache.add( type, dependencies );
-    		}
-    		return dependencies;
-    	}
-    	loadBuffer( bufferIndex ) {
-    		const bufferDef = this.json.buffers[ bufferIndex ];
-    		const loader = this.fileLoader;
-    		if ( bufferDef.type && bufferDef.type !== 'arraybuffer' ) {
-    			throw new Error( 'THREE.GLTFLoader: ' + bufferDef.type + ' buffer type is not supported.' );
-    		}
-    		if ( bufferDef.uri === undefined && bufferIndex === 0 ) {
-    			return Promise.resolve( this.extensions[ EXTENSIONS.KHR_BINARY_GLTF ].body );
-    		}
-    		const options = this.options;
-    		return new Promise( function ( resolve, reject ) {
-    			loader.load( LoaderUtils.resolveURL( bufferDef.uri, options.path ), resolve, undefined, function () {
-    				reject( new Error( 'THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".' ) );
-    			} );
-    		} );
-    	}
-    	loadBufferView( bufferViewIndex ) {
-    		const bufferViewDef = this.json.bufferViews[ bufferViewIndex ];
-    		return this.getDependency( 'buffer', bufferViewDef.buffer ).then( function ( buffer ) {
-    			const byteLength = bufferViewDef.byteLength || 0;
-    			const byteOffset = bufferViewDef.byteOffset || 0;
-    			return buffer.slice( byteOffset, byteOffset + byteLength );
-    		} );
-    	}
-    	loadAccessor( accessorIndex ) {
-    		const parser = this;
-    		const json = this.json;
-    		const accessorDef = this.json.accessors[ accessorIndex ];
-    		if ( accessorDef.bufferView === undefined && accessorDef.sparse === undefined ) {
-    			const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
-    			const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
-    			const normalized = accessorDef.normalized === true;
-    			const array = new TypedArray( accessorDef.count * itemSize );
-    			return Promise.resolve( new BufferAttribute( array, itemSize, normalized ) );
-    		}
-    		const pendingBufferViews = [];
-    		if ( accessorDef.bufferView !== undefined ) {
-    			pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.bufferView ) );
-    		} else {
-    			pendingBufferViews.push( null );
-    		}
-    		if ( accessorDef.sparse !== undefined ) {
-    			pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.indices.bufferView ) );
-    			pendingBufferViews.push( this.getDependency( 'bufferView', accessorDef.sparse.values.bufferView ) );
-    		}
-    		return Promise.all( pendingBufferViews ).then( function ( bufferViews ) {
-    			const bufferView = bufferViews[ 0 ];
-    			const itemSize = WEBGL_TYPE_SIZES[ accessorDef.type ];
-    			const TypedArray = WEBGL_COMPONENT_TYPES[ accessorDef.componentType ];
-    			const elementBytes = TypedArray.BYTES_PER_ELEMENT;
-    			const itemBytes = elementBytes * itemSize;
-    			const byteOffset = accessorDef.byteOffset || 0;
-    			const byteStride = accessorDef.bufferView !== undefined ? json.bufferViews[ accessorDef.bufferView ].byteStride : undefined;
-    			const normalized = accessorDef.normalized === true;
-    			let array, bufferAttribute;
-    			if ( byteStride && byteStride !== itemBytes ) {
-    				const ibSlice = Math.floor( byteOffset / byteStride );
-    				const ibCacheKey = 'InterleavedBuffer:' + accessorDef.bufferView + ':' + accessorDef.componentType + ':' + ibSlice + ':' + accessorDef.count;
-    				let ib = parser.cache.get( ibCacheKey );
-    				if ( ! ib ) {
-    					array = new TypedArray( bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes );
-    					ib = new InterleavedBuffer( array, byteStride / elementBytes );
-    					parser.cache.add( ibCacheKey, ib );
-    				}
-    				bufferAttribute = new InterleavedBufferAttribute( ib, itemSize, ( byteOffset % byteStride ) / elementBytes, normalized );
-    			} else {
-    				if ( bufferView === null ) {
-    					array = new TypedArray( accessorDef.count * itemSize );
-    				} else {
-    					array = new TypedArray( bufferView, byteOffset, accessorDef.count * itemSize );
-    				}
-    				bufferAttribute = new BufferAttribute( array, itemSize, normalized );
-    			}
-    			if ( accessorDef.sparse !== undefined ) {
-    				const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
-    				const TypedArrayIndices = WEBGL_COMPONENT_TYPES[ accessorDef.sparse.indices.componentType ];
-    				const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
-    				const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
-    				const sparseIndices = new TypedArrayIndices( bufferViews[ 1 ], byteOffsetIndices, accessorDef.sparse.count * itemSizeIndices );
-    				const sparseValues = new TypedArray( bufferViews[ 2 ], byteOffsetValues, accessorDef.sparse.count * itemSize );
-    				if ( bufferView !== null ) {
-    					bufferAttribute = new BufferAttribute( bufferAttribute.array.slice(), bufferAttribute.itemSize, bufferAttribute.normalized );
-    				}
-    				bufferAttribute.normalized = false;
-    				for ( let i = 0, il = sparseIndices.length; i < il; i ++ ) {
-    					const index = sparseIndices[ i ];
-    					bufferAttribute.setX( index, sparseValues[ i * itemSize ] );
-    					if ( itemSize >= 2 ) bufferAttribute.setY( index, sparseValues[ i * itemSize + 1 ] );
-    					if ( itemSize >= 3 ) bufferAttribute.setZ( index, sparseValues[ i * itemSize + 2 ] );
-    					if ( itemSize >= 4 ) bufferAttribute.setW( index, sparseValues[ i * itemSize + 3 ] );
-    					if ( itemSize >= 5 ) throw new Error( 'THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.' );
-    				}
-    				bufferAttribute.normalized = normalized;
-    			}
-    			return bufferAttribute;
-    		} );
-    	}
-    	loadTexture( textureIndex ) {
-    		const json = this.json;
-    		const options = this.options;
-    		const textureDef = json.textures[ textureIndex ];
-    		const sourceIndex = textureDef.source;
-    		const sourceDef = json.images[ sourceIndex ];
-    		let loader = this.textureLoader;
-    		if ( sourceDef.uri ) {
-    			const handler = options.manager.getHandler( sourceDef.uri );
-    			if ( handler !== null ) loader = handler;
-    		}
-    		return this.loadTextureImage( textureIndex, sourceIndex, loader );
-    	}
-    	loadTextureImage( textureIndex, sourceIndex, loader ) {
-    		const parser = this;
-    		const json = this.json;
-    		const textureDef = json.textures[ textureIndex ];
-    		const sourceDef = json.images[ sourceIndex ];
-    		const cacheKey = ( sourceDef.uri || sourceDef.bufferView ) + ':' + textureDef.sampler;
-    		if ( this.textureCache[ cacheKey ] ) {
-    			return this.textureCache[ cacheKey ];
-    		}
-    		const promise = this.loadImageSource( sourceIndex, loader ).then( function ( texture ) {
-    			texture.flipY = false;
-    			texture.name = textureDef.name || sourceDef.name || '';
-    			if ( texture.name === '' && typeof sourceDef.uri === 'string' && sourceDef.uri.startsWith( 'data:image/' ) === false ) {
-    				texture.name = sourceDef.uri;
-    			}
-    			const samplers = json.samplers || {};
-    			const sampler = samplers[ textureDef.sampler ] || {};
-    			texture.magFilter = WEBGL_FILTERS[ sampler.magFilter ] || LinearFilter;
-    			texture.minFilter = WEBGL_FILTERS[ sampler.minFilter ] || LinearMipmapLinearFilter;
-    			texture.wrapS = WEBGL_WRAPPINGS[ sampler.wrapS ] || RepeatWrapping;
-    			texture.wrapT = WEBGL_WRAPPINGS[ sampler.wrapT ] || RepeatWrapping;
-    			texture.generateMipmaps = ! texture.isCompressedTexture && texture.minFilter !== NearestFilter && texture.minFilter !== LinearFilter;
-    			parser.associations.set( texture, { textures: textureIndex } );
-    			return texture;
-    		} ).catch( function () {
-    			return null;
-    		} );
-    		this.textureCache[ cacheKey ] = promise;
-    		return promise;
-    	}
-    	loadImageSource( sourceIndex, loader ) {
-    		const parser = this;
-    		const json = this.json;
-    		const options = this.options;
-    		if ( this.sourceCache[ sourceIndex ] !== undefined ) {
-    			return this.sourceCache[ sourceIndex ].then( ( texture ) => texture.clone() );
-    		}
-    		const sourceDef = json.images[ sourceIndex ];
-    		const URL = self.URL || self.webkitURL;
-    		let sourceURI = sourceDef.uri || '';
-    		let isObjectURL = false;
-    		if ( sourceDef.bufferView !== undefined ) {
-    			sourceURI = parser.getDependency( 'bufferView', sourceDef.bufferView ).then( function ( bufferView ) {
-    				isObjectURL = true;
-    				const blob = new Blob( [ bufferView ], { type: sourceDef.mimeType } );
-    				sourceURI = URL.createObjectURL( blob );
-    				return sourceURI;
-    			} );
-    		} else if ( sourceDef.uri === undefined ) {
-    			throw new Error( 'THREE.GLTFLoader: Image ' + sourceIndex + ' is missing URI and bufferView' );
-    		}
-    		const promise = Promise.resolve( sourceURI ).then( function ( sourceURI ) {
-    			return new Promise( function ( resolve, reject ) {
-    				let onLoad = resolve;
-    				if ( loader.isImageBitmapLoader === true ) {
-    					onLoad = function ( imageBitmap ) {
-    						const texture = new Texture( imageBitmap );
-    						texture.needsUpdate = true;
-    						resolve( texture );
-    					};
-    				}
-    				loader.load( LoaderUtils.resolveURL( sourceURI, options.path ), onLoad, undefined, reject );
-    			} );
-    		} ).then( function ( texture ) {
-    			if ( isObjectURL === true ) {
-    				URL.revokeObjectURL( sourceURI );
-    			}
-    			assignExtrasToUserData( texture, sourceDef );
-    			texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType( sourceDef.uri );
-    			return texture;
-    		} ).catch( function ( error ) {
-    			console.error( 'THREE.GLTFLoader: Couldn\'t load texture', sourceURI );
-    			throw error;
-    		} );
-    		this.sourceCache[ sourceIndex ] = promise;
-    		return promise;
-    	}
-    	assignTexture( materialParams, mapName, mapDef, colorSpace ) {
-    		const parser = this;
-    		return this.getDependency( 'texture', mapDef.index ).then( function ( texture ) {
-    			if ( ! texture ) return null;
-    			if ( mapDef.texCoord !== undefined && mapDef.texCoord > 0 ) {
-    				texture = texture.clone();
-    				texture.channel = mapDef.texCoord;
-    			}
-    			if ( parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] ) {
-    				const transform = mapDef.extensions !== undefined ? mapDef.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ] : undefined;
-    				if ( transform ) {
-    					const gltfReference = parser.associations.get( texture );
-    					texture = parser.extensions[ EXTENSIONS.KHR_TEXTURE_TRANSFORM ].extendTexture( texture, transform );
-    					parser.associations.set( texture, gltfReference );
-    				}
-    			}
-    			if ( colorSpace !== undefined ) {
-    				texture.colorSpace = colorSpace;
-    			}
-    			materialParams[ mapName ] = texture;
-    			return texture;
-    		} );
-    	}
-    	assignFinalMaterial( mesh ) {
-    		const geometry = mesh.geometry;
-    		let material = mesh.material;
-    		const useDerivativeTangents = geometry.attributes.tangent === undefined;
-    		const useVertexColors = geometry.attributes.color !== undefined;
-    		const useFlatShading = geometry.attributes.normal === undefined;
-    		if ( mesh.isPoints ) {
-    			const cacheKey = 'PointsMaterial:' + material.uuid;
-    			let pointsMaterial = this.cache.get( cacheKey );
-    			if ( ! pointsMaterial ) {
-    				pointsMaterial = new PointsMaterial();
-    				Material.prototype.copy.call( pointsMaterial, material );
-    				pointsMaterial.color.copy( material.color );
-    				pointsMaterial.map = material.map;
-    				pointsMaterial.sizeAttenuation = false;
-    				this.cache.add( cacheKey, pointsMaterial );
-    			}
-    			material = pointsMaterial;
-    		} else if ( mesh.isLine ) {
-    			const cacheKey = 'LineBasicMaterial:' + material.uuid;
-    			let lineMaterial = this.cache.get( cacheKey );
-    			if ( ! lineMaterial ) {
-    				lineMaterial = new LineBasicMaterial();
-    				Material.prototype.copy.call( lineMaterial, material );
-    				lineMaterial.color.copy( material.color );
-    				lineMaterial.map = material.map;
-    				this.cache.add( cacheKey, lineMaterial );
-    			}
-    			material = lineMaterial;
-    		}
-    		if ( useDerivativeTangents || useVertexColors || useFlatShading ) {
-    			let cacheKey = 'ClonedMaterial:' + material.uuid + ':';
-    			if ( useDerivativeTangents ) cacheKey += 'derivative-tangents:';
-    			if ( useVertexColors ) cacheKey += 'vertex-colors:';
-    			if ( useFlatShading ) cacheKey += 'flat-shading:';
-    			let cachedMaterial = this.cache.get( cacheKey );
-    			if ( ! cachedMaterial ) {
-    				cachedMaterial = material.clone();
-    				if ( useVertexColors ) cachedMaterial.vertexColors = true;
-    				if ( useFlatShading ) cachedMaterial.flatShading = true;
-    				if ( useDerivativeTangents ) {
-    					if ( cachedMaterial.normalScale ) cachedMaterial.normalScale.y *= -1;
-    					if ( cachedMaterial.clearcoatNormalScale ) cachedMaterial.clearcoatNormalScale.y *= -1;
-    				}
-    				this.cache.add( cacheKey, cachedMaterial );
-    				this.associations.set( cachedMaterial, this.associations.get( material ) );
-    			}
-    			material = cachedMaterial;
-    		}
-    		mesh.material = material;
-    	}
-    	getMaterialType(  ) {
-    		return MeshStandardMaterial;
-    	}
-    	loadMaterial( materialIndex ) {
-    		const parser = this;
-    		const json = this.json;
-    		const extensions = this.extensions;
-    		const materialDef = json.materials[ materialIndex ];
-    		let materialType;
-    		const materialParams = {};
-    		const materialExtensions = materialDef.extensions || {};
-    		const pending = [];
-    		if ( materialExtensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ] ) {
-    			const kmuExtension = extensions[ EXTENSIONS.KHR_MATERIALS_UNLIT ];
-    			materialType = kmuExtension.getMaterialType();
-    			pending.push( kmuExtension.extendParams( materialParams, materialDef, parser ) );
-    		} else {
-    			const metallicRoughness = materialDef.pbrMetallicRoughness || {};
-    			materialParams.color = new Color( 1.0, 1.0, 1.0 );
-    			materialParams.opacity = 1.0;
-    			if ( Array.isArray( metallicRoughness.baseColorFactor ) ) {
-    				const array = metallicRoughness.baseColorFactor;
-    				materialParams.color.setRGB( array[ 0 ], array[ 1 ], array[ 2 ], LinearSRGBColorSpace );
-    				materialParams.opacity = array[ 3 ];
-    			}
-    			if ( metallicRoughness.baseColorTexture !== undefined ) {
-    				pending.push( parser.assignTexture( materialParams, 'map', metallicRoughness.baseColorTexture, SRGBColorSpace ) );
-    			}
-    			materialParams.metalness = metallicRoughness.metallicFactor !== undefined ? metallicRoughness.metallicFactor : 1.0;
-    			materialParams.roughness = metallicRoughness.roughnessFactor !== undefined ? metallicRoughness.roughnessFactor : 1.0;
-    			if ( metallicRoughness.metallicRoughnessTexture !== undefined ) {
-    				pending.push( parser.assignTexture( materialParams, 'metalnessMap', metallicRoughness.metallicRoughnessTexture ) );
-    				pending.push( parser.assignTexture( materialParams, 'roughnessMap', metallicRoughness.metallicRoughnessTexture ) );
-    			}
-    			materialType = this._invokeOne( function ( ext ) {
-    				return ext.getMaterialType && ext.getMaterialType( materialIndex );
-    			} );
-    			pending.push( Promise.all( this._invokeAll( function ( ext ) {
-    				return ext.extendMaterialParams && ext.extendMaterialParams( materialIndex, materialParams );
-    			} ) ) );
-    		}
-    		if ( materialDef.doubleSided === true ) {
-    			materialParams.side = DoubleSide;
-    		}
-    		const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
-    		if ( alphaMode === ALPHA_MODES.BLEND ) {
-    			materialParams.transparent = true;
-    			materialParams.depthWrite = false;
-    		} else {
-    			materialParams.transparent = false;
-    			if ( alphaMode === ALPHA_MODES.MASK ) {
-    				materialParams.alphaTest = materialDef.alphaCutoff !== undefined ? materialDef.alphaCutoff : 0.5;
-    			}
-    		}
-    		if ( materialDef.normalTexture !== undefined && materialType !== MeshBasicMaterial ) {
-    			pending.push( parser.assignTexture( materialParams, 'normalMap', materialDef.normalTexture ) );
-    			materialParams.normalScale = new Vector2( 1, 1 );
-    			if ( materialDef.normalTexture.scale !== undefined ) {
-    				const scale = materialDef.normalTexture.scale;
-    				materialParams.normalScale.set( scale, scale );
-    			}
-    		}
-    		if ( materialDef.occlusionTexture !== undefined && materialType !== MeshBasicMaterial ) {
-    			pending.push( parser.assignTexture( materialParams, 'aoMap', materialDef.occlusionTexture ) );
-    			if ( materialDef.occlusionTexture.strength !== undefined ) {
-    				materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
-    			}
-    		}
-    		if ( materialDef.emissiveFactor !== undefined && materialType !== MeshBasicMaterial ) {
-    			const emissiveFactor = materialDef.emissiveFactor;
-    			materialParams.emissive = new Color().setRGB( emissiveFactor[ 0 ], emissiveFactor[ 1 ], emissiveFactor[ 2 ], LinearSRGBColorSpace );
-    		}
-    		if ( materialDef.emissiveTexture !== undefined && materialType !== MeshBasicMaterial ) {
-    			pending.push( parser.assignTexture( materialParams, 'emissiveMap', materialDef.emissiveTexture, SRGBColorSpace ) );
-    		}
-    		return Promise.all( pending ).then( function () {
-    			const material = new materialType( materialParams );
-    			if ( materialDef.name ) material.name = materialDef.name;
-    			assignExtrasToUserData( material, materialDef );
-    			parser.associations.set( material, { materials: materialIndex } );
-    			if ( materialDef.extensions ) addUnknownExtensionsToUserData( extensions, material, materialDef );
-    			return material;
-    		} );
-    	}
-    	createUniqueName( originalName ) {
-    		const sanitizedName = PropertyBinding.sanitizeNodeName( originalName || '' );
-    		if ( sanitizedName in this.nodeNamesUsed ) {
-    			return sanitizedName + '_' + ( ++ this.nodeNamesUsed[ sanitizedName ] );
-    		} else {
-    			this.nodeNamesUsed[ sanitizedName ] = 0;
-    			return sanitizedName;
-    		}
-    	}
-    	loadGeometries( primitives ) {
-    		const parser = this;
-    		const extensions = this.extensions;
-    		const cache = this.primitiveCache;
-    		function createDracoPrimitive( primitive ) {
-    			return extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ]
-    				.decodePrimitive( primitive, parser )
-    				.then( function ( geometry ) {
-    					return addPrimitiveAttributes( geometry, primitive, parser );
-    				} );
-    		}
-    		const pending = [];
-    		for ( let i = 0, il = primitives.length; i < il; i ++ ) {
-    			const primitive = primitives[ i ];
-    			const cacheKey = createPrimitiveKey( primitive );
-    			const cached = cache[ cacheKey ];
-    			if ( cached ) {
-    				pending.push( cached.promise );
-    			} else {
-    				let geometryPromise;
-    				if ( primitive.extensions && primitive.extensions[ EXTENSIONS.KHR_DRACO_MESH_COMPRESSION ] ) {
-    					geometryPromise = createDracoPrimitive( primitive );
-    				} else {
-    					geometryPromise = addPrimitiveAttributes( new BufferGeometry(), primitive, parser );
-    				}
-    				cache[ cacheKey ] = { primitive: primitive, promise: geometryPromise };
-    				pending.push( geometryPromise );
-    			}
-    		}
-    		return Promise.all( pending );
-    	}
-    	loadMesh( meshIndex ) {
-    		const parser = this;
-    		const json = this.json;
-    		const extensions = this.extensions;
-    		const meshDef = json.meshes[ meshIndex ];
-    		const primitives = meshDef.primitives;
-    		const pending = [];
-    		for ( let i = 0, il = primitives.length; i < il; i ++ ) {
-    			const material = primitives[ i ].material === undefined
-    				? createDefaultMaterial( this.cache )
-    				: this.getDependency( 'material', primitives[ i ].material );
-    			pending.push( material );
-    		}
-    		pending.push( parser.loadGeometries( primitives ) );
-    		return Promise.all( pending ).then( function ( results ) {
-    			const materials = results.slice( 0, results.length - 1 );
-    			const geometries = results[ results.length - 1 ];
-    			const meshes = [];
-    			for ( let i = 0, il = geometries.length; i < il; i ++ ) {
-    				const geometry = geometries[ i ];
-    				const primitive = primitives[ i ];
-    				let mesh;
-    				const material = materials[ i ];
-    				if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLES ||
-    						primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ||
-    						primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ||
-    						primitive.mode === undefined ) {
-    					mesh = meshDef.isSkinnedMesh === true
-    						? new SkinnedMesh( geometry, material )
-    						: new Mesh( geometry, material );
-    					if ( mesh.isSkinnedMesh === true ) {
-    						mesh.normalizeSkinWeights();
-    					}
-    					if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP ) {
-    						mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleStripDrawMode );
-    					} else if ( primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN ) {
-    						mesh.geometry = toTrianglesDrawMode( mesh.geometry, TriangleFanDrawMode );
-    					}
-    				} else if ( primitive.mode === WEBGL_CONSTANTS.LINES ) {
-    					mesh = new LineSegments( geometry, material );
-    				} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_STRIP ) {
-    					mesh = new Line$1( geometry, material );
-    				} else if ( primitive.mode === WEBGL_CONSTANTS.LINE_LOOP ) {
-    					mesh = new LineLoop( geometry, material );
-    				} else if ( primitive.mode === WEBGL_CONSTANTS.POINTS ) {
-    					mesh = new Points( geometry, material );
-    				} else {
-    					throw new Error( 'THREE.GLTFLoader: Primitive mode unsupported: ' + primitive.mode );
-    				}
-    				if ( Object.keys( mesh.geometry.morphAttributes ).length > 0 ) {
-    					updateMorphTargets( mesh, meshDef );
-    				}
-    				mesh.name = parser.createUniqueName( meshDef.name || ( 'mesh_' + meshIndex ) );
-    				assignExtrasToUserData( mesh, meshDef );
-    				if ( primitive.extensions ) addUnknownExtensionsToUserData( extensions, mesh, primitive );
-    				parser.assignFinalMaterial( mesh );
-    				meshes.push( mesh );
-    			}
-    			for ( let i = 0, il = meshes.length; i < il; i ++ ) {
-    				parser.associations.set( meshes[ i ], {
-    					meshes: meshIndex,
-    					primitives: i
-    				} );
-    			}
-    			if ( meshes.length === 1 ) {
-    				if ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, meshes[ 0 ], meshDef );
-    				return meshes[ 0 ];
-    			}
-    			const group = new Group$1();
-    			if ( meshDef.extensions ) addUnknownExtensionsToUserData( extensions, group, meshDef );
-    			parser.associations.set( group, { meshes: meshIndex } );
-    			for ( let i = 0, il = meshes.length; i < il; i ++ ) {
-    				group.add( meshes[ i ] );
-    			}
-    			return group;
-    		} );
-    	}
-    	loadCamera( cameraIndex ) {
-    		let camera;
-    		const cameraDef = this.json.cameras[ cameraIndex ];
-    		const params = cameraDef[ cameraDef.type ];
-    		if ( ! params ) {
-    			console.warn( 'THREE.GLTFLoader: Missing camera parameters.' );
-    			return;
-    		}
-    		if ( cameraDef.type === 'perspective' ) {
-    			camera = new PerspectiveCamera( MathUtils.radToDeg( params.yfov ), params.aspectRatio || 1, params.znear || 1, params.zfar || 2e6 );
-    		} else if ( cameraDef.type === 'orthographic' ) {
-    			camera = new OrthographicCamera( - params.xmag, params.xmag, params.ymag, - params.ymag, params.znear, params.zfar );
-    		}
-    		if ( cameraDef.name ) camera.name = this.createUniqueName( cameraDef.name );
-    		assignExtrasToUserData( camera, cameraDef );
-    		return Promise.resolve( camera );
-    	}
-    	loadSkin( skinIndex ) {
-    		const skinDef = this.json.skins[ skinIndex ];
-    		const pending = [];
-    		for ( let i = 0, il = skinDef.joints.length; i < il; i ++ ) {
-    			pending.push( this._loadNodeShallow( skinDef.joints[ i ] ) );
-    		}
-    		if ( skinDef.inverseBindMatrices !== undefined ) {
-    			pending.push( this.getDependency( 'accessor', skinDef.inverseBindMatrices ) );
-    		} else {
-    			pending.push( null );
-    		}
-    		return Promise.all( pending ).then( function ( results ) {
-    			const inverseBindMatrices = results.pop();
-    			const jointNodes = results;
-    			const bones = [];
-    			const boneInverses = [];
-    			for ( let i = 0, il = jointNodes.length; i < il; i ++ ) {
-    				const jointNode = jointNodes[ i ];
-    				if ( jointNode ) {
-    					bones.push( jointNode );
-    					const mat = new Matrix4();
-    					if ( inverseBindMatrices !== null ) {
-    						mat.fromArray( inverseBindMatrices.array, i * 16 );
-    					}
-    					boneInverses.push( mat );
-    				} else {
-    					console.warn( 'THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[ i ] );
-    				}
-    			}
-    			return new Skeleton( bones, boneInverses );
-    		} );
-    	}
-    	loadAnimation( animationIndex ) {
-    		const json = this.json;
-    		const parser = this;
-    		const animationDef = json.animations[ animationIndex ];
-    		const animationName = animationDef.name ? animationDef.name : 'animation_' + animationIndex;
-    		const pendingNodes = [];
-    		const pendingInputAccessors = [];
-    		const pendingOutputAccessors = [];
-    		const pendingSamplers = [];
-    		const pendingTargets = [];
-    		for ( let i = 0, il = animationDef.channels.length; i < il; i ++ ) {
-    			const channel = animationDef.channels[ i ];
-    			const sampler = animationDef.samplers[ channel.sampler ];
-    			const target = channel.target;
-    			const name = target.node;
-    			const input = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.input ] : sampler.input;
-    			const output = animationDef.parameters !== undefined ? animationDef.parameters[ sampler.output ] : sampler.output;
-    			if ( target.node === undefined ) continue;
-    			pendingNodes.push( this.getDependency( 'node', name ) );
-    			pendingInputAccessors.push( this.getDependency( 'accessor', input ) );
-    			pendingOutputAccessors.push( this.getDependency( 'accessor', output ) );
-    			pendingSamplers.push( sampler );
-    			pendingTargets.push( target );
-    		}
-    		return Promise.all( [
-    			Promise.all( pendingNodes ),
-    			Promise.all( pendingInputAccessors ),
-    			Promise.all( pendingOutputAccessors ),
-    			Promise.all( pendingSamplers ),
-    			Promise.all( pendingTargets )
-    		] ).then( function ( dependencies ) {
-    			const nodes = dependencies[ 0 ];
-    			const inputAccessors = dependencies[ 1 ];
-    			const outputAccessors = dependencies[ 2 ];
-    			const samplers = dependencies[ 3 ];
-    			const targets = dependencies[ 4 ];
-    			const tracks = [];
-    			for ( let i = 0, il = nodes.length; i < il; i ++ ) {
-    				const node = nodes[ i ];
-    				const inputAccessor = inputAccessors[ i ];
-    				const outputAccessor = outputAccessors[ i ];
-    				const sampler = samplers[ i ];
-    				const target = targets[ i ];
-    				if ( node === undefined ) continue;
-    				if ( node.updateMatrix ) {
-    					node.updateMatrix();
-    				}
-    				const createdTracks = parser._createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target );
-    				if ( createdTracks ) {
-    					for ( let k = 0; k < createdTracks.length; k ++ ) {
-    						tracks.push( createdTracks[ k ] );
-    					}
-    				}
-    			}
-    			const animation = new AnimationClip( animationName, undefined, tracks );
-    			assignExtrasToUserData( animation, animationDef );
-    			return animation;
-    		} );
-    	}
-    	createNodeMesh( nodeIndex ) {
-    		const json = this.json;
-    		const parser = this;
-    		const nodeDef = json.nodes[ nodeIndex ];
-    		if ( nodeDef.mesh === undefined ) return null;
-    		return parser.getDependency( 'mesh', nodeDef.mesh ).then( function ( mesh ) {
-    			const node = parser._getNodeRef( parser.meshCache, nodeDef.mesh, mesh );
-    			if ( nodeDef.weights !== undefined ) {
-    				node.traverse( function ( o ) {
-    					if ( ! o.isMesh ) return;
-    					for ( let i = 0, il = nodeDef.weights.length; i < il; i ++ ) {
-    						o.morphTargetInfluences[ i ] = nodeDef.weights[ i ];
-    					}
-    				} );
-    			}
-    			return node;
-    		} );
-    	}
-    	loadNode( nodeIndex ) {
-    		const json = this.json;
-    		const parser = this;
-    		const nodeDef = json.nodes[ nodeIndex ];
-    		const nodePending = parser._loadNodeShallow( nodeIndex );
-    		const childPending = [];
-    		const childrenDef = nodeDef.children || [];
-    		for ( let i = 0, il = childrenDef.length; i < il; i ++ ) {
-    			childPending.push( parser.getDependency( 'node', childrenDef[ i ] ) );
-    		}
-    		const skeletonPending = nodeDef.skin === undefined
-    			? Promise.resolve( null )
-    			: parser.getDependency( 'skin', nodeDef.skin );
-    		return Promise.all( [
-    			nodePending,
-    			Promise.all( childPending ),
-    			skeletonPending
-    		] ).then( function ( results ) {
-    			const node = results[ 0 ];
-    			const children = results[ 1 ];
-    			const skeleton = results[ 2 ];
-    			if ( skeleton !== null ) {
-    				node.traverse( function ( mesh ) {
-    					if ( ! mesh.isSkinnedMesh ) return;
-    					mesh.bind( skeleton, _identityMatrix );
-    				} );
-    			}
-    			for ( let i = 0, il = children.length; i < il; i ++ ) {
-    				node.add( children[ i ] );
-    			}
-    			return node;
-    		} );
-    	}
-    	_loadNodeShallow( nodeIndex ) {
-    		const json = this.json;
-    		const extensions = this.extensions;
-    		const parser = this;
-    		if ( this.nodeCache[ nodeIndex ] !== undefined ) {
-    			return this.nodeCache[ nodeIndex ];
-    		}
-    		const nodeDef = json.nodes[ nodeIndex ];
-    		const nodeName = nodeDef.name ? parser.createUniqueName( nodeDef.name ) : '';
-    		const pending = [];
-    		const meshPromise = parser._invokeOne( function ( ext ) {
-    			return ext.createNodeMesh && ext.createNodeMesh( nodeIndex );
-    		} );
-    		if ( meshPromise ) {
-    			pending.push( meshPromise );
-    		}
-    		if ( nodeDef.camera !== undefined ) {
-    			pending.push( parser.getDependency( 'camera', nodeDef.camera ).then( function ( camera ) {
-    				return parser._getNodeRef( parser.cameraCache, nodeDef.camera, camera );
-    			} ) );
-    		}
-    		parser._invokeAll( function ( ext ) {
-    			return ext.createNodeAttachment && ext.createNodeAttachment( nodeIndex );
-    		} ).forEach( function ( promise ) {
-    			pending.push( promise );
-    		} );
-    		this.nodeCache[ nodeIndex ] = Promise.all( pending ).then( function ( objects ) {
-    			let node;
-    			if ( nodeDef.isBone === true ) {
-    				node = new Bone();
-    			} else if ( objects.length > 1 ) {
-    				node = new Group$1();
-    			} else if ( objects.length === 1 ) {
-    				node = objects[ 0 ];
-    			} else {
-    				node = new Object3D();
-    			}
-    			if ( node !== objects[ 0 ] ) {
-    				for ( let i = 0, il = objects.length; i < il; i ++ ) {
-    					node.add( objects[ i ] );
-    				}
-    			}
-    			if ( nodeDef.name ) {
-    				node.userData.name = nodeDef.name;
-    				node.name = nodeName;
-    			}
-    			assignExtrasToUserData( node, nodeDef );
-    			if ( nodeDef.extensions ) addUnknownExtensionsToUserData( extensions, node, nodeDef );
-    			if ( nodeDef.matrix !== undefined ) {
-    				const matrix = new Matrix4();
-    				matrix.fromArray( nodeDef.matrix );
-    				node.applyMatrix4( matrix );
-    			} else {
-    				if ( nodeDef.translation !== undefined ) {
-    					node.position.fromArray( nodeDef.translation );
-    				}
-    				if ( nodeDef.rotation !== undefined ) {
-    					node.quaternion.fromArray( nodeDef.rotation );
-    				}
-    				if ( nodeDef.scale !== undefined ) {
-    					node.scale.fromArray( nodeDef.scale );
-    				}
-    			}
-    			if ( ! parser.associations.has( node ) ) {
-    				parser.associations.set( node, {} );
-    			} else if ( nodeDef.mesh !== undefined && parser.meshCache.refs[ nodeDef.mesh ] > 1 ) {
-    				const mapping = parser.associations.get( node );
-    				parser.associations.set( node, { ...mapping } );
-    			}
-    			parser.associations.get( node ).nodes = nodeIndex;
-    			return node;
-    		} );
-    		return this.nodeCache[ nodeIndex ];
-    	}
-    	loadScene( sceneIndex ) {
-    		const extensions = this.extensions;
-    		const sceneDef = this.json.scenes[ sceneIndex ];
-    		const parser = this;
-    		const scene = new Group$1();
-    		if ( sceneDef.name ) scene.name = parser.createUniqueName( sceneDef.name );
-    		assignExtrasToUserData( scene, sceneDef );
-    		if ( sceneDef.extensions ) addUnknownExtensionsToUserData( extensions, scene, sceneDef );
-    		const nodeIds = sceneDef.nodes || [];
-    		const pending = [];
-    		for ( let i = 0, il = nodeIds.length; i < il; i ++ ) {
-    			pending.push( parser.getDependency( 'node', nodeIds[ i ] ) );
-    		}
-    		return Promise.all( pending ).then( function ( nodes ) {
-    			for ( let i = 0, il = nodes.length; i < il; i ++ ) {
-    				scene.add( nodes[ i ] );
-    			}
-    			const reduceAssociations = ( node ) => {
-    				const reducedAssociations = new Map();
-    				for ( const [ key, value ] of parser.associations ) {
-    					if ( key instanceof Material || key instanceof Texture ) {
-    						reducedAssociations.set( key, value );
-    					}
-    				}
-    				node.traverse( ( node ) => {
-    					const mappings = parser.associations.get( node );
-    					if ( mappings != null ) {
-    						reducedAssociations.set( node, mappings );
-    					}
-    				} );
-    				return reducedAssociations;
-    			};
-    			parser.associations = reduceAssociations( scene );
-    			return scene;
-    		} );
-    	}
-    	_createAnimationTracks( node, inputAccessor, outputAccessor, sampler, target ) {
-    		const tracks = [];
-    		const targetName = node.name ? node.name : node.uuid;
-    		const targetNames = [];
-    		if ( PATH_PROPERTIES[ target.path ] === PATH_PROPERTIES.weights ) {
-    			node.traverse( function ( object ) {
-    				if ( object.morphTargetInfluences ) {
-    					targetNames.push( object.name ? object.name : object.uuid );
-    				}
-    			} );
-    		} else {
-    			targetNames.push( targetName );
-    		}
-    		let TypedKeyframeTrack;
-    		switch ( PATH_PROPERTIES[ target.path ] ) {
-    			case PATH_PROPERTIES.weights:
-    				TypedKeyframeTrack = NumberKeyframeTrack;
-    				break;
-    			case PATH_PROPERTIES.rotation:
-    				TypedKeyframeTrack = QuaternionKeyframeTrack;
-    				break;
-    			case PATH_PROPERTIES.translation:
-    			case PATH_PROPERTIES.scale:
-    				TypedKeyframeTrack = VectorKeyframeTrack;
-    				break;
-    			default:
-    				switch ( outputAccessor.itemSize ) {
-    					case 1:
-    						TypedKeyframeTrack = NumberKeyframeTrack;
-    						break;
-    					case 2:
-    					case 3:
-    					default:
-    						TypedKeyframeTrack = VectorKeyframeTrack;
-    						break;
-    				}
-    				break;
-    		}
-    		const interpolation = sampler.interpolation !== undefined ? INTERPOLATION[ sampler.interpolation ] : InterpolateLinear;
-    		const outputArray = this._getArrayFromAccessor( outputAccessor );
-    		for ( let j = 0, jl = targetNames.length; j < jl; j ++ ) {
-    			const track = new TypedKeyframeTrack(
-    				targetNames[ j ] + '.' + PATH_PROPERTIES[ target.path ],
-    				inputAccessor.array,
-    				outputArray,
-    				interpolation
-    			);
-    			if ( sampler.interpolation === 'CUBICSPLINE' ) {
-    				this._createCubicSplineTrackInterpolant( track );
-    			}
-    			tracks.push( track );
-    		}
-    		return tracks;
-    	}
-    	_getArrayFromAccessor( accessor ) {
-    		let outputArray = accessor.array;
-    		if ( accessor.normalized ) {
-    			const scale = getNormalizedComponentScale( outputArray.constructor );
-    			const scaled = new Float32Array( outputArray.length );
-    			for ( let j = 0, jl = outputArray.length; j < jl; j ++ ) {
-    				scaled[ j ] = outputArray[ j ] * scale;
-    			}
-    			outputArray = scaled;
-    		}
-    		return outputArray;
-    	}
-    	_createCubicSplineTrackInterpolant( track ) {
-    		track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline( result ) {
-    			const interpolantType = ( this instanceof QuaternionKeyframeTrack ) ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
-    			return new interpolantType( this.times, this.values, this.getValueSize() / 3, result );
-    		};
-    		track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
-    	}
-    }
-    function computeBounds( geometry, primitiveDef, parser ) {
-    	const attributes = primitiveDef.attributes;
-    	const box = new Box3();
-    	if ( attributes.POSITION !== undefined ) {
-    		const accessor = parser.json.accessors[ attributes.POSITION ];
-    		const min = accessor.min;
-    		const max = accessor.max;
-    		if ( min !== undefined && max !== undefined ) {
-    			box.set(
-    				new Vector3( min[ 0 ], min[ 1 ], min[ 2 ] ),
-    				new Vector3( max[ 0 ], max[ 1 ], max[ 2 ] )
-    			);
-    			if ( accessor.normalized ) {
-    				const boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] );
-    				box.min.multiplyScalar( boxScale );
-    				box.max.multiplyScalar( boxScale );
-    			}
-    		} else {
-    			console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
-    			return;
-    		}
-    	} else {
-    		return;
-    	}
-    	const targets = primitiveDef.targets;
-    	if ( targets !== undefined ) {
-    		const maxDisplacement = new Vector3();
-    		const vector = new Vector3();
-    		for ( let i = 0, il = targets.length; i < il; i ++ ) {
-    			const target = targets[ i ];
-    			if ( target.POSITION !== undefined ) {
-    				const accessor = parser.json.accessors[ target.POSITION ];
-    				const min = accessor.min;
-    				const max = accessor.max;
-    				if ( min !== undefined && max !== undefined ) {
-    					vector.setX( Math.max( Math.abs( min[ 0 ] ), Math.abs( max[ 0 ] ) ) );
-    					vector.setY( Math.max( Math.abs( min[ 1 ] ), Math.abs( max[ 1 ] ) ) );
-    					vector.setZ( Math.max( Math.abs( min[ 2 ] ), Math.abs( max[ 2 ] ) ) );
-    					if ( accessor.normalized ) {
-    						const boxScale = getNormalizedComponentScale( WEBGL_COMPONENT_TYPES[ accessor.componentType ] );
-    						vector.multiplyScalar( boxScale );
-    					}
-    					maxDisplacement.max( vector );
-    				} else {
-    					console.warn( 'THREE.GLTFLoader: Missing min/max properties for accessor POSITION.' );
-    				}
-    			}
-    		}
-    		box.expandByVector( maxDisplacement );
-    	}
-    	geometry.boundingBox = box;
-    	const sphere = new Sphere();
-    	box.getCenter( sphere.center );
-    	sphere.radius = box.min.distanceTo( box.max ) / 2;
-    	geometry.boundingSphere = sphere;
-    }
-    function addPrimitiveAttributes( geometry, primitiveDef, parser ) {
-    	const attributes = primitiveDef.attributes;
-    	const pending = [];
-    	function assignAttributeAccessor( accessorIndex, attributeName ) {
-    		return parser.getDependency( 'accessor', accessorIndex )
-    			.then( function ( accessor ) {
-    				geometry.setAttribute( attributeName, accessor );
-    			} );
-    	}
-    	for ( const gltfAttributeName in attributes ) {
-    		const threeAttributeName = ATTRIBUTES[ gltfAttributeName ] || gltfAttributeName.toLowerCase();
-    		if ( threeAttributeName in geometry.attributes ) continue;
-    		pending.push( assignAttributeAccessor( attributes[ gltfAttributeName ], threeAttributeName ) );
-    	}
-    	if ( primitiveDef.indices !== undefined && ! geometry.index ) {
-    		const accessor = parser.getDependency( 'accessor', primitiveDef.indices ).then( function ( accessor ) {
-    			geometry.setIndex( accessor );
-    		} );
-    		pending.push( accessor );
-    	}
-    	if ( ColorManagement.workingColorSpace !== LinearSRGBColorSpace && 'COLOR_0' in attributes ) {
-    		console.warn( `THREE.GLTFLoader: Converting vertex colors from "srgb-linear" to "${ColorManagement.workingColorSpace}" not supported.` );
-    	}
-    	assignExtrasToUserData( geometry, primitiveDef );
-    	computeBounds( geometry, primitiveDef, parser );
-    	return Promise.all( pending ).then( function () {
-    		return primitiveDef.targets !== undefined
-    			? addMorphTargets( geometry, primitiveDef.targets, parser )
-    			: geometry;
-    	} );
-    }
-
-    class GLTFLoadingManager extends LoadingManager {
-        constructor(file, params = {}) {
-            super();
-            this.path = "";
-            this.resourcePath = "";
-            this.fileURL = "";
-            this.dataURLs = new Map();
-            this.path = params.path || "";
-            const externalFiles = params.externalFiles || new Map();
-            if (typeof file === "string") {
-                this.fileURL = file;
-                this.resourcePath = LoaderUtils.extractUrlBase(file);
-            }
-            else {
-                externalFiles.forEach((value, key) => (this.fileURL = value === file ? key : this.fileURL));
-                externalFiles.set(this.fileURL, file);
-            }
-            externalFiles.forEach((value, key) => {
-                let dataURL;
-                if (typeof value === "string")
-                    dataURL = value;
-                else
-                    dataURL = URL.createObjectURL(new Blob([value]));
-                this.dataURLs.set(key, dataURL);
-            });
-            this.setURLModifier((url) => {
-                const key = decodeURI(url)
-                    .replace(this.path, "")
-                    .replace(this.resourcePath, "")
-                    .replace(/^(\.?\/)/, "");
-                const dataURL = this.dataURLs.get(key);
-                return dataURL !== null && dataURL !== void 0 ? dataURL : url;
-            });
-        }
-        dispose() {
-            this.dataURLs.forEach(URL.revokeObjectURL);
-        }
-    }
-
     class ModelImpl {
         constructor(scene) {
-            this.handle = "1";
             this.scene = scene;
         }
         dispose() {
@@ -39244,6 +36765,18 @@ void main() {
             this.scene.traverse(disposeObject);
             this.scene.clear();
         }
+        getUnits() {
+            return "Meters";
+        }
+        getUnitScale() {
+            return convertUnits(this.getUnits(), "Meters", 1);
+        }
+        getUnitString() {
+            return getDisplayUnit(this.getUnits());
+        }
+        getPrecision() {
+            return 2;
+        }
         getExtents(target) {
             this.scene.traverseVisible((object) => !object.children.length && target.expandByObject(object));
             return target;
@@ -39266,27 +36799,45 @@ void main() {
             }
             return false;
         }
+        hasHandle(handle) {
+            return !handle.includes(":") || handle.split(":", 1)[0] === this.id + "";
+        }
         getOwnObjects(objects) {
             if (!Array.isArray(objects))
                 objects = [objects];
             return objects.filter((object) => this.hasObject(object));
         }
+        getOwnHandles(handles) {
+            if (!Array.isArray(handles))
+                handles = [handles];
+            return handles.filter((handle) => this.hasHandle(handle));
+        }
         getObjectsByHandles(handles) {
-            const handleSet = new Set(handles);
+            const ownHandles = this.getOwnHandles(handles);
+            if (ownHandles.length === 0)
+                return [];
+            const handleSet = new Set(ownHandles.map((handle) => handle.slice(handle.indexOf(":") + 1)));
             const objects = [];
-            this.scene.traverse((object) => handleSet.has(object.userData.handle) && objects.push(object));
+            this.scene.traverse((object) => {
+                const handle = object.userData.handle;
+                if (handle && handleSet.has(handle))
+                    objects.push(object);
+            });
             return objects;
         }
         getHandlesByObjects(objects) {
-            if (!Array.isArray(objects))
-                objects = [objects];
-            const handlesSet = new Set();
-            this.getOwnObjects(objects).forEach((object) => handlesSet.add(object.userData.handle));
-            return Array.from(handlesSet);
+            const ownObjects = this.getOwnObjects(objects);
+            if (ownObjects.length === 0)
+                return [];
+            const handleSet = new Set();
+            ownObjects.forEach((object) => {
+                const handle = object.userData.handle;
+                if (handle)
+                    handleSet.add(`${this.id}:${handle}`);
+            });
+            return Array.from(handleSet);
         }
         hideObjects(objects) {
-            if (!Array.isArray(objects))
-                objects = [objects];
             this.getOwnObjects(objects).forEach((object) => (object.visible = false));
             return this;
         }
@@ -39302,8 +36853,6 @@ void main() {
             return this;
         }
         showObjects(objects) {
-            if (!Array.isArray(objects))
-                objects = [objects];
             this.getOwnObjects(objects).forEach((object) => {
                 object.visible = true;
                 object.traverseAncestors((parent) => (parent.visible = true));
@@ -39359,42 +36908,6 @@ void main() {
         }
     }
 
-    class GLTFFileLoader extends Loader$1 {
-        constructor(viewer) {
-            super();
-            this.viewer = viewer;
-        }
-        isSupport(file, format) {
-            return ((typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) &&
-                /(gltf|glb)$/i.test(format));
-        }
-        async load(file, format, params) {
-            const manager = new GLTFLoadingManager(file, params);
-            const loader = new GLTFLoader(manager);
-            loader.setPath(manager.path);
-            loader.setCrossOrigin(params.crossOrigin || loader.crossOrigin);
-            loader.setWithCredentials(params.withCredentials || loader.withCredentials);
-            const progress = (event) => {
-                const { lengthComputable, loaded, total } = event;
-                const progress = lengthComputable ? loaded / total : 1;
-                this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
-            };
-            const gltf = await loader.loadAsync(manager.fileURL, progress);
-            if (!this.viewer.scene)
-                return this;
-            const modelImpl = new ModelImpl(gltf.scene);
-            modelImpl.loader = this;
-            modelImpl.viewer = this.viewer;
-            this.viewer.scene.add(gltf.scene);
-            this.viewer.models.push(modelImpl);
-            this.viewer.syncOptions();
-            this.viewer.syncOverlay();
-            this.viewer.update();
-            this.viewer.emitEvent({ type: "databasechunk", data: gltf.scene, file });
-            return this;
-        }
-    }
-
     class DynamicModelImpl extends ModelImpl {
         getExtents(target) {
             return target.union(this.gltfLoader.getTotalGeometryExtent());
@@ -39413,31 +36926,40 @@ void main() {
             return this.gltfLoader.originalObjects.has(object);
         }
         getObjectsByHandles(handles) {
-            const handlesSet = new Set(handles);
+            const ownHandles = this.getOwnHandles(handles);
+            if (ownHandles.length === 0)
+                return [];
+            const handlesSet = new Set(ownHandles);
             const objects = [];
             handlesSet.forEach((handle) => {
-                const handle2 = `${this.modelId}_${handle}`;
-                const handles = this.gltfLoader.handleToObjects.get(handle2) || [];
-                objects.push(...Array.from(handles));
+                objects.push(...this.gltfLoader.getObjectsByHandle(handle));
             });
             return objects;
         }
         getHandlesByObjects(objects) {
-            const handles = super.getHandlesByObjects(objects);
-            return handles.map((x) => x.split("_").pop());
+            const ownObjects = this.getOwnObjects(objects);
+            if (ownObjects.length === 0)
+                return [];
+            const handleSet = new Set();
+            ownObjects.forEach((object) => {
+                const handle = object.userData.handle;
+                if (handle)
+                    handleSet.add(handle);
+            });
+            return Array.from(handleSet);
         }
         hideObjects(objects) {
-            const handles = super.getHandlesByObjects(objects);
+            const handles = this.getHandlesByObjects(objects);
             this.gltfLoader.hideObjects(handles);
             return this;
         }
         isolateObjects(objects) {
-            const handles = super.getHandlesByObjects(objects);
+            const handles = this.getHandlesByObjects(objects);
             this.gltfLoader.isolateObjects(new Set(handles));
             return this;
         }
         showObjects(objects) {
-            const handles = super.getHandlesByObjects(objects);
+            const handles = this.getHandlesByObjects(objects);
             this.gltfLoader.showObjects(handles);
             return this;
         }
@@ -39501,11 +37023,14 @@ void main() {
         this.materials = new Map();
         this.textureCache = new Map();
         this.materialCache = new Map();
+        this.uri = "";
+        this._nextObjectId = 0;
       }
       async initialize(loader) {
         this.json = await this.loadController.loadJson();
         this.baseUrl = await this.loadController.baseUrl();
         this.loader = loader;
+        this.uri = this.json.buffers[0].uri || "";
       }
       clear() {
         this.json = null;
@@ -39599,7 +37124,7 @@ void main() {
           await this.loader.waitForChunkSlot();
           try {
             const length = range.end - range.start;
-            const buffer = await this.loadController.loadBinaryData([{ offset: range.start, length }]);
+            const buffer = await this.loadController.loadBinaryData([{ offset: range.start, length }], this.uri);
             for (const req of range.requests) {
               const relOffset = req.offset - range.start;
               try {
@@ -39916,6 +37441,156 @@ void main() {
       }
     }
 
+    function mergeGeometries( geometries, useGroups = false ) {
+    	const isIndexed = geometries[ 0 ].index !== null;
+    	const attributesUsed = new Set( Object.keys( geometries[ 0 ].attributes ) );
+    	const morphAttributesUsed = new Set( Object.keys( geometries[ 0 ].morphAttributes ) );
+    	const attributes = {};
+    	const morphAttributes = {};
+    	const morphTargetsRelative = geometries[ 0 ].morphTargetsRelative;
+    	const mergedGeometry = new BufferGeometry();
+    	let offset = 0;
+    	for ( let i = 0; i < geometries.length; ++ i ) {
+    		const geometry = geometries[ i ];
+    		let attributesCount = 0;
+    		if ( isIndexed !== ( geometry.index !== null ) ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure index attribute exists among all geometries, or in none of them.' );
+    			return null;
+    		}
+    		for ( const name in geometry.attributes ) {
+    			if ( ! attributesUsed.has( name ) ) {
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. All geometries must have compatible attributes; make sure "' + name + '" attribute exists among all geometries, or in none of them.' );
+    				return null;
+    			}
+    			if ( attributes[ name ] === undefined ) attributes[ name ] = [];
+    			attributes[ name ].push( geometry.attributes[ name ] );
+    			attributesCount ++;
+    		}
+    		if ( attributesCount !== attributesUsed.size ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. Make sure all geometries have the same number of attributes.' );
+    			return null;
+    		}
+    		if ( morphTargetsRelative !== geometry.morphTargetsRelative ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. .morphTargetsRelative must be consistent throughout all geometries.' );
+    			return null;
+    		}
+    		for ( const name in geometry.morphAttributes ) {
+    			if ( ! morphAttributesUsed.has( name ) ) {
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '.  .morphAttributes must be consistent throughout all geometries.' );
+    				return null;
+    			}
+    			if ( morphAttributes[ name ] === undefined ) morphAttributes[ name ] = [];
+    			morphAttributes[ name ].push( geometry.morphAttributes[ name ] );
+    		}
+    		if ( useGroups ) {
+    			let count;
+    			if ( isIndexed ) {
+    				count = geometry.index.count;
+    			} else if ( geometry.attributes.position !== undefined ) {
+    				count = geometry.attributes.position.count;
+    			} else {
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed with geometry at index ' + i + '. The geometry must have either an index or a position attribute' );
+    				return null;
+    			}
+    			mergedGeometry.addGroup( offset, count, i );
+    			offset += count;
+    		}
+    	}
+    	if ( isIndexed ) {
+    		let indexOffset = 0;
+    		const mergedIndex = [];
+    		for ( let i = 0; i < geometries.length; ++ i ) {
+    			const index = geometries[ i ].index;
+    			for ( let j = 0; j < index.count; ++ j ) {
+    				mergedIndex.push( index.getX( j ) + indexOffset );
+    			}
+    			indexOffset += geometries[ i ].attributes.position.count;
+    		}
+    		mergedGeometry.setIndex( mergedIndex );
+    	}
+    	for ( const name in attributes ) {
+    		const mergedAttribute = mergeAttributes( attributes[ name ] );
+    		if ( ! mergedAttribute ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' attribute.' );
+    			return null;
+    		}
+    		mergedGeometry.setAttribute( name, mergedAttribute );
+    	}
+    	for ( const name in morphAttributes ) {
+    		const numMorphTargets = morphAttributes[ name ][ 0 ].length;
+    		if ( numMorphTargets === 0 ) break;
+    		mergedGeometry.morphAttributes = mergedGeometry.morphAttributes || {};
+    		mergedGeometry.morphAttributes[ name ] = [];
+    		for ( let i = 0; i < numMorphTargets; ++ i ) {
+    			const morphAttributesToMerge = [];
+    			for ( let j = 0; j < morphAttributes[ name ].length; ++ j ) {
+    				morphAttributesToMerge.push( morphAttributes[ name ][ j ][ i ] );
+    			}
+    			const mergedMorphAttribute = mergeAttributes( morphAttributesToMerge );
+    			if ( ! mergedMorphAttribute ) {
+    				console.error( 'THREE.BufferGeometryUtils: .mergeGeometries() failed while trying to merge the ' + name + ' morphAttribute.' );
+    				return null;
+    			}
+    			mergedGeometry.morphAttributes[ name ].push( mergedMorphAttribute );
+    		}
+    	}
+    	return mergedGeometry;
+    }
+    function mergeAttributes( attributes ) {
+    	let TypedArray;
+    	let itemSize;
+    	let normalized;
+    	let gpuType = -1;
+    	let arrayLength = 0;
+    	for ( let i = 0; i < attributes.length; ++ i ) {
+    		const attribute = attributes[ i ];
+    		if ( TypedArray === undefined ) TypedArray = attribute.array.constructor;
+    		if ( TypedArray !== attribute.array.constructor ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.array must be of consistent array types across matching attributes.' );
+    			return null;
+    		}
+    		if ( itemSize === undefined ) itemSize = attribute.itemSize;
+    		if ( itemSize !== attribute.itemSize ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.itemSize must be consistent across matching attributes.' );
+    			return null;
+    		}
+    		if ( normalized === undefined ) normalized = attribute.normalized;
+    		if ( normalized !== attribute.normalized ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.normalized must be consistent across matching attributes.' );
+    			return null;
+    		}
+    		if ( gpuType === -1 ) gpuType = attribute.gpuType;
+    		if ( gpuType !== attribute.gpuType ) {
+    			console.error( 'THREE.BufferGeometryUtils: .mergeAttributes() failed. BufferAttribute.gpuType must be consistent across matching attributes.' );
+    			return null;
+    		}
+    		arrayLength += attribute.count * itemSize;
+    	}
+    	const array = new TypedArray( arrayLength );
+    	const result = new BufferAttribute( array, itemSize, normalized );
+    	let offset = 0;
+    	for ( let i = 0; i < attributes.length; ++ i ) {
+    		const attribute = attributes[ i ];
+    		if ( attribute.isInterleavedBufferAttribute ) {
+    			const tupleOffset = offset / itemSize;
+    			for ( let j = 0, l = attribute.count; j < l; j ++ ) {
+    				for ( let c = 0; c < itemSize; c ++ ) {
+    					const value = attribute.getComponent( j, c );
+    					result.setComponent( j + tupleOffset, c, value );
+    				}
+    			}
+    		} else {
+    			array.set( attribute.array, offset );
+    		}
+    		offset += attribute.count * itemSize;
+    	}
+    	if ( gpuType !== undefined ) {
+    		result.gpuType = gpuType;
+    	}
+    	return result;
+    }
+
+    const STRUCTURE_ID_SEPARATOR = ":";
     class DynamicGltfLoader {
       constructor(camera, scene, renderer) {
         this.camera = camera;
@@ -39928,6 +37603,7 @@ void main() {
           geometryerror: [],
           update: [],
           geometrymemory: [],
+          optimizationprogress: [],
         };
         this.loadDistance = 100;
         this.unloadDistance = 150;
@@ -39969,7 +37645,6 @@ void main() {
         this.hiddenHandles = new Set();
         this.newOptimizedObjects = new Set();
         this.oldOptimizeObjects = new Set();
-        this.maxConcurrentChunks = 8;
         this.activeChunkLoads = 0;
         this.chunkQueue = [];
         this.objectIdToIndex = new Map();
@@ -39978,6 +37653,7 @@ void main() {
         this.maxConcurrentChunks = 6;
         this.mergedObjectMap = new Map();
         this.mergedGeometryVisibility = new Map();
+        this._webglInfoCache = null;
       }
       setVisibleEdges(visible) {
         this.visibleEdges = visible;
@@ -40081,6 +37757,123 @@ void main() {
         this.updateMemoryIndicator();
         console.log(`Final memory usage: ${Math.round(currentMemoryUsage / (1024 * 1024))}MB`);
       }
+      getStats() {
+        let totalObjects = 0;
+        let renderedObjects = 0;
+        let totalTriangles = 0;
+        let renderedTriangles = 0;
+        let totalLines = 0;
+        let renderedLines = 0;
+        let totalEdges = 0;
+        let renderedEdges = 0;
+        this.scene.traverse((object) => {
+          totalObjects++;
+          const geometry = object.geometry;
+          if (!geometry) return;
+          let triCount = 0;
+          if (geometry.index) {
+            triCount = Math.floor(geometry.index.count / 3);
+          } else if (geometry.attributes && geometry.attributes.position) {
+            triCount = Math.floor(geometry.attributes.position.count / 3);
+          }
+          totalTriangles += triCount;
+          let lineCount = 0;
+          if (geometry.index) {
+            lineCount = Math.floor(geometry.index.count / 2);
+          } else if (geometry.attributes && geometry.attributes.position) {
+            lineCount = Math.floor(geometry.attributes.position.count / 2);
+          }
+          if (object.type === "Line" || object.type === "LineSegments" || object.type === "LineLoop") {
+            if (object.userData.isEdge) {
+              totalEdges += lineCount;
+            } else {
+              totalLines += lineCount;
+            }
+          }
+          if (object.visible !== false) {
+            if (object.isMesh || object.isLine || object.isPoints) {
+              renderedObjects++;
+              if (object.isMesh) {
+                renderedTriangles += triCount;
+              } else if (object.type === "Line" || object.type === "LineSegments" || object.type === "LineLoop") {
+                if (object.userData.isEdge) {
+                  renderedEdges += lineCount;
+                } else {
+                  renderedLines += lineCount;
+                }
+              }
+            }
+          }
+        });
+        const geometryCount = this.geometryCache ? this.geometryCache.size : 0;
+        const geometryMemoryBytes = Array.from(this.geometryCache?.values?.() || []).reduce((a, b) => a + b, 0);
+        const uniqueMaterialIds = new Set();
+        const uniqueTextureIds = new Set();
+        if (Array.isArray(this.structures)) {
+          for (const structure of this.structures) {
+            console.log(structure.materialCache.values());
+            try {
+              for (const entry of structure.materialCache.values()) {
+                if (entry?.mesh?.uuid) uniqueMaterialIds.add(entry.mesh.uuid);
+                if (entry?.points?.uuid) uniqueMaterialIds.add(entry.points.uuid);
+                if (entry?.lines?.uuid) uniqueMaterialIds.add(entry.lines.uuid);
+              }
+            } catch (exp) {
+              console.error("Error adding material to uniqueMaterialIds", exp);
+            }
+          }
+        }
+        const materialCount = uniqueMaterialIds.size;
+        const textureCount = uniqueTextureIds.size;
+        const estimatedGpuMemoryBytes = geometryMemoryBytes;
+        if (!this._webglInfoCache) {
+          try {
+            const gl = this.renderer.getContext();
+            const dbgInfo = gl.getExtension("WEBGL_debug_renderer_info");
+            if (dbgInfo) {
+              const rendererStr = gl.getParameter(dbgInfo.UNMASKED_RENDERER_WEBGL);
+              const vendorStr = gl.getParameter(dbgInfo.UNMASKED_VENDOR_WEBGL);
+              this._webglInfoCache = { renderer: rendererStr, vendor: vendorStr };
+            } else {
+              this._webglInfoCache = { renderer: null, vendor: null };
+            }
+          } catch (e) {
+            console.error("Error getting webgl info", e);
+            this._webglInfoCache = { renderer: null, vendor: null };
+          }
+        }
+        const size = new Vector2();
+        if (this.renderer && this.renderer.getSize) {
+          this.renderer.getSize(size);
+        }
+        return {
+          scene: {
+            beforeOptimization: {
+              objects: totalObjects - renderedObjects,
+              triangles: totalTriangles - renderedTriangles,
+              lines: totalLines - renderedLines,
+              edges: totalEdges - renderedEdges,
+            },
+            afterOptimization: {
+              objects: renderedObjects,
+              triangles: renderedTriangles,
+              lines: renderedLines,
+              edges: renderedEdges,
+            },
+          },
+          memory: {
+            geometries: { count: geometryCount, bytes: geometryMemoryBytes },
+            textures: { count: textureCount },
+            materials: { count: materialCount },
+            totalEstimatedGpuBytes: estimatedGpuMemoryBytes,
+          },
+          system: {
+            webglRenderer: this._webglInfoCache?.renderer || "",
+            webglVendor: this._webglInfoCache?.vendor || "",
+            viewport: { width: size.x || 0, height: size.y || 0 },
+          },
+        };
+      }
       async loadNode(nodeId, onLoadFinishCb) {
         const node = this.nodes.get(nodeId);
         if (!node || node.loaded || node.loading) return;
@@ -40251,7 +38044,7 @@ void main() {
             if (node.handle) {
               mesh.userData.handle = node.handle;
             } else {
-              mesh.userData.handle = `${node.structure.id}_${mesh.userData.handle}`;
+              mesh.userData.handle = this.getFullHandle(node.structure.id, mesh.userData.handle);
             }
             if (mesh.material.name === "edges") {
               mesh.userData.isEdge = true;
@@ -40392,12 +38185,15 @@ void main() {
           })),
         });
       }
+      getFullHandle(structureId, originalHandle) {
+        return `${structureId}${STRUCTURE_ID_SEPARATOR}${originalHandle}`;
+      }
       async processNodeHierarchy(structure, nodeId, parentGroup) {
         const nodeDef = structure.json.nodes[nodeId];
         let nodeGroup = null;
         let handle = null;
         if (nodeDef.extras?.handle) {
-          handle = `${structure.id}_${nodeDef.extras.handle}`;
+          handle = this.getFullHandle(structure.id, nodeDef.extras.handle);
         }
         if (nodeDef.camera !== undefined) {
           const camera = this.loadCamera(structure, nodeDef.camera, nodeDef);
@@ -40414,7 +38210,7 @@ void main() {
           if (nodeDef.extras) {
             nodeGroup.userData = { ...nodeDef.extras };
             if (nodeGroup.userData.handle) {
-              nodeGroup.userData.handle = `${structure.id}_${nodeGroup.userData.handle}`;
+              nodeGroup.userData.handle = this.getFullHandle(structure.id, nodeGroup.userData.handle);
             }
           }
           if (nodeDef.matrix) {
@@ -40459,7 +38255,7 @@ void main() {
             this.edgeNodes.push(uniqueNodeId);
           }
           if (meshDef.extras && meshDef.extras.handle) {
-            handle = `${structure.id}_${meshDef.extras.handle}`;
+            handle = this.getFullHandle(structure.id, meshDef.extras.handle);
           }
           this.nodes.set(uniqueNodeId, {
             position: nodeGroup ? nodeGroup.position.clone() : new Vector3().setFromMatrixPosition(nodeMatrix),
@@ -40472,7 +38268,7 @@ void main() {
             structure,
             extras: nodeDef.extras,
             geometryExtents,
-            handle,
+            handle: handle || this.getFullHandle(structure.id, structure._nextObjectId++),
           });
         }
         if (nodeDef.children) {
@@ -40545,12 +38341,12 @@ void main() {
         }
       }
       async loadNodes() {
-        console.time("process nodes");
+        console.time("Process nodes");
         await this.processNodes();
-        console.timeEnd("process nodes");
-        console.time("optimize scene");
+        console.timeEnd("Process nodes");
+        console.time("Optimize scene");
         await this.optimizeScene();
-        console.timeEnd("optimize scene");
+        console.timeEnd("Optimize scene");
       }
       cleanupPartialLoad() {
         this.nodesToLoad.forEach((nodeId) => {
@@ -40871,7 +38667,7 @@ void main() {
           this.handleToObjects.set(fullHandle, new Set());
         }
         this.handleToObjects.get(fullHandle).add(object);
-        object.userData.structureId = object.userData.handle.split("_")[0];
+        object.userData.structureId = object.userData.handle.split(STRUCTURE_ID_SEPARATOR)[0];
       }
       getObjectsByHandle(handle) {
         if (!handle) return [];
@@ -40937,10 +38733,28 @@ void main() {
         }
         this.originalObjects.add(object);
       }
-      optimizeScene() {
+      yieldToUI() {
+        return new Promise((resolve) => {
+          requestAnimationFrame(() => {
+            setTimeout(resolve, 0);
+          });
+        });
+      }
+      async optimizeScene() {
+        console.log("Starting scene optimization...");
+        this.dispatchEvent("optimizationprogress", {
+          phase: "start",
+          progress: 0,
+          message: "Starting optimization...",
+        });
         this.originalObjects.clear();
         this.originalObjectsToSelection.clear();
         const structureGroups = new Map();
+        this.dispatchEvent("optimizationprogress", {
+          phase: "collecting",
+          progress: 5,
+          message: "Collecting scene objects...",
+        });
         this.scene.traverse((object) => {
           if (object.userData.structureId) {
             const structureId = object.userData.structureId;
@@ -40969,16 +38783,44 @@ void main() {
             }
           }
         });
+        let processedGroups = 0;
+        const totalGroups = structureGroups.size;
+        this.dispatchEvent("optimizationprogress", {
+          phase: "merging",
+          progress: 10,
+          message: `Merging ${totalGroups} structure groups...`,
+          current: 0,
+          total: totalGroups,
+        });
         for (const group of structureGroups.values()) {
           group.mapMeshes.clear();
           group.mapLines.clear();
           group.mapLineSegments.clear();
           group.mapPoints.clear();
-          this.mergeMeshGroups(group.meshes, group.rootGroup);
-          this.mergeLineGroups(group.lines, group.rootGroup);
-          this.mergeLineSegmentGroups(group.lineSegments, group.rootGroup);
-          this.mergePointsGroups(group.points, group.rootGroup);
+          await this.mergeMeshGroups(group.meshes, group.rootGroup);
+          await this.yieldToUI();
+          await this.mergeLineGroups(group.lines, group.rootGroup);
+          await this.yieldToUI();
+          await this.mergeLineSegmentGroups(group.lineSegments, group.rootGroup);
+          await this.yieldToUI();
+          await this.mergePointsGroups(group.points, group.rootGroup);
+          processedGroups++;
+          const progress = 10 + Math.round((processedGroups / totalGroups) * 80);
+          this.dispatchEvent("optimizationprogress", {
+            phase: "merging",
+            progress,
+            message: `Processing structure ${processedGroups}/${totalGroups}...`,
+            current: processedGroups,
+            total: totalGroups,
+          });
+          console.log(`Optimization progress: ${processedGroups}/${totalGroups} structure groups processed (${progress}%)`);
+          await this.yieldToUI();
         }
+        this.dispatchEvent("optimizationprogress", {
+          phase: "finalizing",
+          progress: 95,
+          message: "Finalizing optimization...",
+        });
         this.originalObjects.forEach((obj) => {
           obj.visible = false;
           if (!(obj instanceof Points) && !obj.userData.isEdge) {
@@ -40987,9 +38829,15 @@ void main() {
         });
         this.initializeObjectVisibility();
         console.log(`Optimization complete. Total objects: ${this.maxObjectId}`);
+        this.dispatchEvent("optimizationprogress", {
+          phase: "complete",
+          progress: 100,
+          message: `Optimization complete! ${this.maxObjectId} objects processed.`,
+        });
         this.dispatchEvent("update");
       }
-      mergeMeshGroups(materialGroups, rootGroup) {
+      async mergeMeshGroups(materialGroups, rootGroup) {
+        let processedGroups = 0;
         for (const group of materialGroups) {
           if (!group.material) {
             console.warn("Skipping mesh group with null material");
@@ -41003,8 +38851,6 @@ void main() {
             let currentVertexOffset = 0;
             for (const mesh of group.objects) {
               const geometry = mesh.geometry.clone();
-              mesh.updateWorldMatrix(true, false);
-              geometry.applyMatrix4(mesh.matrixWorld);
               const handle = mesh.userData.handle;
               if (!this.objectIdToIndex.has(handle)) {
                 this.objectIdToIndex.set(handle, this.maxObjectId++);
@@ -41063,6 +38909,10 @@ void main() {
                 this.handleToOptimizedObjects.set(handle, mergedObjects);
               }
             });
+            processedGroups++;
+            if (processedGroups % 5 === 0) {
+              await this.yieldToUI();
+            }
           } catch (error) {
             console.error("Failed to merge meshes for material:", error);
             group.objects.forEach((mesh) => {
@@ -41071,7 +38921,8 @@ void main() {
           }
         }
       }
-      mergeLineGroups(materialGroups, rootGroup) {
+      async mergeLineGroups(materialGroups, rootGroup) {
+        let processedGroups = 0;
         for (const group of materialGroups) {
           if (group.objects.length === 0) continue;
           if (!group.material) {
@@ -41090,7 +38941,9 @@ void main() {
           let posOffset = 0;
           const indices = [];
           let vertexOffset = 0;
+          let isEdge = false;
           group.objects.forEach((line) => {
+            isEdge = line.userData.isEdge;
             const geometry = line.geometry;
             const positionAttr = geometry.attributes.position;
             const vertexCount = positionAttr.count;
@@ -41103,12 +38956,9 @@ void main() {
               vertexCount,
             });
             currentVertexOffset += vertexCount;
-            line.updateWorldMatrix(true, false);
-            const matrix = line.matrixWorld;
             const vector = new Vector3();
             for (let i = 0; i < vertexCount; i++) {
               vector.fromBufferAttribute(positionAttr, i);
-              vector.applyMatrix4(matrix);
               positions[posOffset++] = vector.x;
               positions[posOffset++] = vector.y;
               positions[posOffset++] = vector.z;
@@ -41141,6 +38991,7 @@ void main() {
           geometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
           const visibilityMaterial = this.createVisibilityMaterial(group.material);
           const mergedLine = new LineSegments(geometry, visibilityMaterial);
+          mergedLine.userData.isEdge = isEdge;
           const mergedObjects = [mergedLine];
           if (this.useVAO) {
             this.createVAO(mergedLine);
@@ -41163,9 +39014,14 @@ void main() {
               this.handleToOptimizedObjects.set(handle, mergedObjects);
             }
           });
+          processedGroups++;
+          if (processedGroups % 5 === 0) {
+            await this.yieldToUI();
+          }
         }
       }
-      mergeLineSegmentGroups(materialGroups, rootGroup) {
+      async mergeLineSegmentGroups(materialGroups, rootGroup) {
+        let processedGroups = 0;
         for (const group of materialGroups) {
           if (!group.material) {
             console.warn("Skipping line segment group with null material");
@@ -41177,10 +39033,10 @@ void main() {
             const handles = new Set();
             const objectMapping = new Map();
             let currentVertexOffset = 0;
+            let isEdge = false;
             for (const line of group.objects) {
+              isEdge = line.userData.isEdge;
               const geometry = line.geometry.clone();
-              line.updateWorldMatrix(true, false);
-              geometry.applyMatrix4(line.matrixWorld);
               const handle = line.userData.handle;
               if (!this.objectIdToIndex.has(handle)) {
                 this.objectIdToIndex.set(handle, this.maxObjectId++);
@@ -41213,6 +39069,7 @@ void main() {
               mergedGeometry.setAttribute("visibility", new BufferAttribute(visibilityArray, 1));
               const visibilityMaterial = this.createVisibilityMaterial(group.material);
               const mergedLine = new LineSegments(mergedGeometry, visibilityMaterial);
+              mergedLine.userData.isEdge = isEdge;
               if (this.useVAO) {
                 this.createVAO(mergedLine);
               }
@@ -41239,6 +39096,10 @@ void main() {
                 this.handleToOptimizedObjects.set(handle, mergedObjects);
               }
             });
+            processedGroups++;
+            if (processedGroups % 5 === 0) {
+              await this.yieldToUI();
+            }
           } catch (error) {
             console.warn("Failed to merge line segments for material:", error);
             group.objects.forEach((line) => {
@@ -41247,7 +39108,8 @@ void main() {
           }
         }
       }
-      mergePointsGroups(materialGroups, rootGroup) {
+      async mergePointsGroups(materialGroups, rootGroup) {
+        let processedGroups = 0;
         for (const group of materialGroups) {
           if (!group.material) {
             console.warn("Skipping points group with null material");
@@ -41259,8 +39121,6 @@ void main() {
             const handles = new Set();
             for (const points of group.objects) {
               const geometry = points.geometry.clone();
-              points.updateWorldMatrix(true, false);
-              geometry.applyMatrix4(points.matrixWorld);
               geometries.push(geometry);
               optimizedObjects.push(points);
               handles.add(points.userData.handle);
@@ -41289,6 +39149,10 @@ void main() {
                 this.handleToOptimizedObjects.set(handle, mergedObjects);
               }
             });
+            processedGroups++;
+            if (processedGroups % 5 === 0) {
+              await this.yieldToUI();
+            }
           } catch (error) {
             console.warn("Failed to merge points for material:", error);
             group.objects.forEach((points) => {
@@ -41307,7 +39171,6 @@ void main() {
           const hasNormals = lineSegmentsArray.some((segment) => segment.geometry.attributes.normal !== undefined);
           lineSegmentsArray.forEach((segment) => {
             const clonedGeometry = segment.geometry.clone();
-            segment.updateWorldMatrix(true, false);
             clonedGeometry.applyMatrix4(segment.matrixWorld);
             if (hasNormals && !clonedGeometry.attributes.normal) {
               clonedGeometry.computeVertexNormals();
@@ -41524,8 +39387,225 @@ void main() {
       }
     }
 
-    class GLTFCloudDynamicLoader {
+    class GLTFLoadingManager extends LoadingManager {
+        constructor(file, params = {}) {
+            super();
+            this.path = "";
+            this.resourcePath = "";
+            this.fileURL = "";
+            this.dataURLs = new Map();
+            this.path = params.path || "";
+            const externalFiles = params.externalFiles || new Map();
+            if (typeof file === "string") {
+                this.fileURL = file;
+                this.resourcePath = LoaderUtils.extractUrlBase(file);
+            }
+            else {
+                externalFiles.forEach((value, key) => (this.fileURL = value === file ? key : this.fileURL));
+                externalFiles.set(this.fileURL, file);
+            }
+            externalFiles.forEach((value, key) => {
+                let dataURL;
+                if (typeof value === "string")
+                    dataURL = value;
+                else
+                    dataURL = URL.createObjectURL(new Blob([value]));
+                this.dataURLs.set(key, dataURL);
+            });
+            this.setURLModifier((url) => {
+                const key = decodeURI(url)
+                    .replace(this.path, "")
+                    .replace(this.resourcePath, "")
+                    .replace(/^(\.?\/)/, "");
+                const dataURL = this.dataURLs.get(key);
+                return dataURL !== null && dataURL !== void 0 ? dataURL : url;
+            });
+        }
+        dispose() {
+            this.dataURLs.forEach((dataURL) => URL.revokeObjectURL(dataURL));
+        }
+    }
+
+    const BINARY_EXTENSION_HEADER_MAGIC = "glTF";
+    const BINARY_EXTENSION_HEADER_LENGTH = 12;
+    const BINARY_EXTENSION_CHUNK_TYPES = { JSON: 0x4e4f534a, BIN: 0x004e4042 };
+    class GLTFBinaryExtension {
+        constructor(data) {
+            const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH);
+            const textDecoder = new TextDecoder();
+            const magic = textDecoder.decode(new Uint8Array(data.slice(0, 4)));
+            if (magic !== BINARY_EXTENSION_HEADER_MAGIC) {
+                this.content = textDecoder.decode(data);
+                return;
+            }
+            const header = {
+                magic,
+                version: headerView.getUint32(4, true),
+                length: headerView.getUint32(8, true),
+            };
+            if (header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
+                throw new Error("Unsupported glTF-Binary header.");
+            }
+            if (header.version < 2.0) {
+                throw new Error("Legacy binary file detected.");
+            }
+            const chunkContentsLength = header.length - BINARY_EXTENSION_HEADER_LENGTH;
+            const chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH);
+            let chunkIndex = 0;
+            while (chunkIndex < chunkContentsLength) {
+                const chunkLength = chunkView.getUint32(chunkIndex, true);
+                chunkIndex += 4;
+                const chunkType = chunkView.getUint32(chunkIndex, true);
+                chunkIndex += 4;
+                if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
+                    const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength);
+                    this.content = textDecoder.decode(contentArray);
+                }
+                else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
+                    const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
+                    this.body = data.slice(byteOffset, byteOffset + chunkLength);
+                }
+                chunkIndex += chunkLength;
+            }
+            if (typeof this.content === "undefined") {
+                throw new Error("JSON content not found.");
+            }
+        }
+    }
+
+    class RangesLoader {
+        constructor() {
+            this.requestHeader = {};
+            this.withCredentials = false;
+            this.abortSignal = undefined;
+        }
+        setRequestHeader(requestHeader) {
+            this.requestHeader = requestHeader;
+        }
+        setWithCredentials(withCredentials) {
+            this.withCredentials = withCredentials;
+        }
+        setAbortSignal(abortSignal) {
+            this.abortSignal = abortSignal;
+        }
+        async load(url, ranges) {
+            const init = {
+                headers: {
+                    ...this.requestHeader,
+                    Range: "bytes=" + ranges.map((x) => `${x.offset}-${x.offset + x.length - 1}`).join(","),
+                },
+                credentials: this.withCredentials ? "include" : "same-origin",
+                signal: this.abortSignal,
+            };
+            const response = await fetch(url, init);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch "${url}", status ${response.status}`);
+            }
+            if (response.status !== 206) {
+                const arrayBuffer = await response.arrayBuffer();
+                return this.extractRanges(arrayBuffer, ranges);
+            }
+            return response.arrayBuffer();
+        }
+        extractRanges(arrayBuffer, ranges) {
+            const totalLength = ranges.reduce((sum, range) => sum + range.length, 0);
+            const result = new Uint8Array(totalLength);
+            let offset = 0;
+            for (const range of ranges) {
+                const chunk = new Uint8Array(arrayBuffer, range.offset, range.length);
+                result.set(chunk, offset);
+                offset += range.length;
+            }
+            return result.buffer;
+        }
+    }
+
+    class GLTFFileDynamicLoader extends Loader$1 {
+        constructor(viewer) {
+            super();
+            this.viewer = viewer;
+        }
+        dispose() {
+            if (this.gltfLoader)
+                this.gltfLoader.clear();
+            if (this.manager)
+                this.manager.dispose();
+        }
+        isSupport(file, format) {
+            return ((typeof file === "string" || file instanceof globalThis.File || file instanceof ArrayBuffer) &&
+                /(gltf|glb)$/i.test(format));
+        }
+        async load(file, format, params) {
+            this.manager = new GLTFLoadingManager(file, params);
+            const scene = new Group$1();
+            this.gltfLoader = new DynamicGltfLoader(this.viewer.camera, scene, this.viewer.renderer);
+            this.gltfLoader.memoryLimit = this.viewer.options.memoryLimit;
+            this.gltfLoader.visibleEdges = this.viewer.options.edgeModel;
+            const modelImpl = new DynamicModelImpl(scene);
+            modelImpl.id = params.modelId || this.extractFileName(file);
+            modelImpl.gltfLoader = this.gltfLoader;
+            this.gltfLoader.addEventListener("databasechunk", () => {
+                this.viewer.scene.add(scene);
+                this.viewer.models.push(modelImpl);
+                this.viewer.syncOptions();
+                this.viewer.syncOverlay();
+                this.viewer.update();
+                this.viewer.emitEvent({ type: "databasechunk", data: scene, file });
+            });
+            this.gltfLoader.addEventListener("geometryerror", (data) => {
+                this.viewer.emitEvent({ type: "geometryerror", data, file });
+            });
+            this.gltfLoader.addEventListener("update", (data) => {
+                this.viewer.update();
+            });
+            const loadController = {
+                loadJson: async () => {
+                    const loader = new FileLoader(this.manager);
+                    loader.setPath(this.manager.path);
+                    loader.setRequestHeader(params.requestHeader || {});
+                    loader.setWithCredentials(params.withCredentials || loader.withCredentials);
+                    loader.setResponseType("arraybuffer");
+                    const progress = (event) => {
+                        const { lengthComputable, loaded, total } = event;
+                        const progress = lengthComputable ? loaded / total : 1;
+                        this.viewer.emitEvent({ type: "geometryprogress", data: progress, file });
+                    };
+                    const data = await loader.loadAsync(this.manager.fileURL, progress);
+                    const extension = new GLTFBinaryExtension(data);
+                    this.gltf = JSON.parse(extension.content);
+                    this.bin = extension.body;
+                    return this.gltf;
+                },
+                loadBinaryData: (ranges, uri = "") => {
+                    const loader = new RangesLoader();
+                    loader.setRequestHeader(params.requestHeader || {});
+                    loader.setWithCredentials(params.withCredentials || false);
+                    loader.setAbortSignal(this.gltfLoader.abortController.signal);
+                    if (this.bin)
+                        return loader.extractRanges(this.bin, ranges);
+                    const path = this.manager.path || this.manager.resourcePath;
+                    const url = LoaderUtils.resolveURL(uri, path);
+                    return loader.load(this.manager.resolveURL(url), ranges);
+                },
+                baseUrl: () => {
+                    const path = this.manager.path || this.manager.resourcePath;
+                    return Promise.resolve(path);
+                },
+            };
+            const structure = new GltfStructure(modelImpl.id, loadController);
+            await this.gltfLoader.loadStructure(structure);
+            await this.gltfLoader.loadNodes();
+            return this;
+        }
+        cancel() {
+            if (this.gltfLoader)
+                this.gltfLoader.abortLoading();
+        }
+    }
+
+    class GLTFCloudDynamicLoader extends Loader$1 {
         constructor(viewer) {
+            super();
             this.requestId = 0;
             this.viewer = viewer;
         }
@@ -41540,17 +39620,15 @@ void main() {
                 typeof file.downloadResourceRange === "function" &&
                 /.gltf$/i.test(file.database));
         }
-        async load(model, format, params) {
+        async load(model, format, params = {}) {
             const scene = new Group$1();
             this.gltfLoader = new DynamicGltfLoader(this.viewer.camera, scene, this.viewer.renderer);
             this.gltfLoader.memoryLimit = this.viewer.options.memoryLimit;
             this.gltfLoader.setVisibleEdges(this.viewer.options.edgeModel);
+            const modelImpl = new DynamicModelImpl(scene);
+            modelImpl.id = model.file.id;
+            modelImpl.gltfLoader = this.gltfLoader;
             this.gltfLoader.addEventListener("databasechunk", (data) => {
-                const modelImpl = new DynamicModelImpl(scene);
-                modelImpl.loader = this;
-                modelImpl.viewer = this.viewer;
-                modelImpl.gltfLoader = this.gltfLoader;
-                modelImpl.modelId = model.id;
                 this.viewer.scene.add(scene);
                 this.viewer.models.push(modelImpl);
                 this.viewer.syncOptions();
@@ -41558,10 +39636,6 @@ void main() {
                 this.viewer.update();
                 this.viewer.emitEvent({ type: "databasechunk", data: scene, file: model.file, model });
             });
-            this.gltfLoader.addEventListener("geometryprogress", (data) => {
-                const progress = data.loaded / data.total;
-                this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model.file, model });
-            });
             this.gltfLoader.addEventListener("geometryerror", (data) => {
                 this.viewer.emitEvent({ type: "geometryerror", data, file: model.file, model });
             });
@@ -41571,7 +39645,7 @@ void main() {
             const loadController = {
                 loadJson: async () => {
                     const progress = (progress) => {
-                        this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model });
+                        this.viewer.emitEvent({ type: "geometryprogress", data: progress, file: model.file, model });
                     };
                     const arrayBuffer = await model.downloadResource(model.database, progress, this.gltfLoader.getAbortController().signal);
                     const text = new TextDecoder().decode(arrayBuffer);
@@ -41588,7 +39662,7 @@ void main() {
                 },
                 baseUrl: () => Promise.resolve(`${model.httpClient.serverUrl}${model.path}/`),
             };
-            const structure = new GltfStructure(model.id, loadController);
+            const structure = new GltfStructure(modelImpl.id, loadController);
             await this.gltfLoader.loadStructure(structure);
             await this.gltfLoader.loadNodes();
             return this;
@@ -41600,7 +39674,7 @@ void main() {
     }
 
     const loaders = loadersRegistry("threejs");
-    loaders.registerLoader("gltf-file", (viewer) => new GLTFFileLoader(viewer));
+    loaders.registerLoader("gltf-file", (viewer) => new GLTFFileDynamicLoader(viewer));
     loaders.registerLoader("gltf-cloud", (viewer) => new GLTFCloudDynamicLoader(viewer));
 
     const CopyShader = {
@@ -56561,24 +54635,25 @@ js: import "konva/skia-backend";
     class Viewer extends EventEmitter2 {
         constructor(client) {
             super();
-            this._options = new Options(this);
             this.client = client;
-            this.canvasEvents = CANVAS_EVENTS;
-            this.canvaseventlistener = (event) => this.emit(event);
+            this.options = new Options(this);
             this.loaders = [];
             this.models = [];
+            this.canvasEvents = CANVAS_EVENTS.slice();
+            this.canvaseventlistener = (event) => this.emit(event);
             this.selected = [];
             this.extents = new Box3();
-            this.target = new Vector3();
+            this.target = new Vector3(0, 0, 0);
             this._activeDragger = null;
             this._components = [];
+            this._renderNeeded = false;
             this._renderTime = 0;
             this.render = this.render.bind(this);
             this.update = this.update.bind(this);
             this._markup = new KonvaMarkup();
         }
-        get options() {
-            return this._options;
+        get markup() {
+            return this._markup;
         }
         get draggers() {
             return [...draggers.getDraggers().keys()];
@@ -56586,14 +54661,10 @@ js: import "konva/skia-backend";
         get components() {
             return [...components.getComponents().keys()];
         }
-        get markup() {
-            return this._markup;
-        }
         initialize(canvas, onProgress) {
             this.addEventListener("optionschange", (event) => this.syncOptions(event.data));
             this.scene = new Scene();
             this.helpers = new Helpers();
-            this.target = new Vector3(0, 0, 0);
             const pixelRatio = window.devicePixelRatio;
             const rect = canvas.parentElement.getBoundingClientRect();
             const width = rect.width || 1;
@@ -56744,21 +54815,25 @@ js: import "konva/skia-backend";
         async open(file, params = {}) {
             if (!this.renderer)
                 return this;
-            if (params.mode !== "a" && params.mode !== "append") {
+            const mode = params.mode || "file";
+            if (mode !== "assembly" && mode !== "a" && mode !== "append") {
                 this.cancel();
                 this.clear();
             }
-            this.emitEvent({ type: "open", file });
+            this.emitEvent({ type: "open", mode, file });
             let model = file;
             if (model && typeof model.getModels === "function") {
                 const models = await model.getModels();
                 model = models.find((model) => model.default) || models[0] || file;
             }
+            if (model && typeof model.database === "string") {
+                file = model.file;
+            }
             if (!model)
                 throw new Error(`Format not supported`);
             let format = params.format;
-            if (!format && typeof model.type === "string")
-                format = model.type.split(".").pop();
+            if (!format && typeof file["type"] === "string")
+                format = file["type"].split(".").pop();
             if (!format && typeof file === "string")
                 format = file.split(".").pop();
             if (!format && file instanceof globalThis.File)
@@ -56785,7 +54860,7 @@ js: import "konva/skia-backend";
         }
         loadGltfFile(file, externalFiles, params = {}) {
             console.warn("Viewer.loadGltfFile() has been deprecated since 26.4 and will be removed in a future release, use Viewer.open() instead.");
-            return this.open(file, { ...params, format: "gltf", externalFiles, mode: "append" });
+            return this.open(file, { ...params, format: "gltf", externalFiles, mode: "assembly" });
         }
         cancel() {
             this.loaders.forEach((loader) => loader.cancel());
@@ -56805,12 +54880,17 @@ js: import "konva/skia-backend";
             this.models = [];
             this.scene.clear();
             this.helpers.clear();
+            this.extents.makeEmpty();
+            this.target.set(0, 0, 0);
             this.syncOptions();
             this.syncOverlay();
             this.update(true);
             this.emitEvent({ type: "clear" });
             return this;
         }
+        is3D() {
+            return true;
+        }
         syncOptions(options = this.options) {
             if (!this.renderer)
                 return;
@@ -56842,9 +54922,15 @@ js: import "konva/skia-backend";
         getSelected() {
             return this.executeCommand("getSelected");
         }
+        getSelected2() {
+            return this.executeCommand("getSelected2");
+        }
         setSelected(handles) {
             this.executeCommand("setSelected", handles);
         }
+        setSelected2(handles) {
+            this.executeCommand("setSelected2", handles);
+        }
         clearSelected() {
             this.executeCommand("clearSelected");
         }
@@ -56904,37 +54990,8 @@ js: import "konva/skia-backend";
         getComponent(name) {
             return this._components.find((component) => component.name === name);
         }
-        is3D() {
-            return true;
-        }
-        screenToWorld(position) {
-            if (!this.renderer)
-                return { x: position.x, y: position.y, z: 0 };
-            const rect = this.canvas.getBoundingClientRect();
-            const x = position.x / (rect.width / 2) - 1;
-            const y = -position.y / (rect.height / 2) + 1;
-            const point = new Vector3(x, y, -1);
-            point.unproject(this.camera);
-            return { x: point.x, y: point.y, z: point.z };
-        }
-        worldToScreen(position) {
-            if (!this.renderer)
-                return { x: position.x, y: position.y };
-            const point = new Vector3(position.x, position.y, position.z);
-            point.project(this.camera);
-            const rect = this.canvas.getBoundingClientRect();
-            const x = (point.x + 1) * (rect.width / 2);
-            const y = (-point.y + 1) * (rect.height / 2);
-            return { x, y };
-        }
-        getScale() {
-            return { x: 1, y: 1, z: 1 };
-        }
-        executeCommand(id, ...args) {
-            return commands.executeCommand(id, this, ...args);
-        }
         drawViewpoint(viewpoint) {
-            var _a, _b, _c;
+            var _a, _b, _c, _d;
             if (!this.renderer)
                 return;
             const getVector3FromPoint3d = ({ x, y, z }) => new Vector3(x, y, z);
@@ -56986,11 +55043,13 @@ js: import "konva/skia-backend";
                 }
             };
             const setClippingPlanes = (clipping_planes) => {
-                clipping_planes === null || clipping_planes === void 0 ? void 0 : clipping_planes.forEach((clipping_plane) => {
-                    const plane = new Plane();
-                    plane.setFromNormalAndCoplanarPoint(getVector3FromPoint3d(clipping_plane.direction), getVector3FromPoint3d(clipping_plane.location));
-                    this.renderer.clippingPlanes.push(plane);
-                });
+                if (clipping_planes) {
+                    clipping_planes.forEach((clipping_plane) => {
+                        const plane = new Plane();
+                        plane.setFromNormalAndCoplanarPoint(getVector3FromPoint3d(clipping_plane.direction), getVector3FromPoint3d(clipping_plane.location));
+                        this.renderer.clippingPlanes.push(plane);
+                    });
+                }
             };
             const setSelection = (selection) => {
                 if (selection)
@@ -57006,9 +55065,9 @@ js: import "konva/skia-backend";
             setOrthogonalCamera(viewpoint.orthogonal_camera);
             setPerspectiveCamera(viewpoint.perspective_camera);
             setClippingPlanes(viewpoint.clipping_planes);
-            setSelection(viewpoint.selection);
+            setSelection(((_b = viewpoint.custom_fields) === null || _b === void 0 ? void 0 : _b.selection2) || viewpoint.selection);
             this._markup.setViewpoint(viewpoint);
-            this.target = getVector3FromPoint3d((_c = (_b = viewpoint.custom_fields) === null || _b === void 0 ? void 0 : _b.camera_target) !== null && _c !== void 0 ? _c : this.target);
+            this.target.copy(getVector3FromPoint3d((_d = (_c = viewpoint.custom_fields) === null || _c === void 0 ? void 0 : _c.camera_target) !== null && _d !== void 0 ? _d : this.target));
             this.setActiveDragger(draggerName);
             this.emitEvent({ type: "drawviewpoint", data: viewpoint });
             this.update();
@@ -57055,6 +55114,9 @@ js: import "konva/skia-backend";
             const getSelection = () => {
                 return this.getSelected().map((handle) => ({ handle }));
             };
+            const getSelection2 = () => {
+                return this.getSelected2().map((handle) => ({ handle }));
+            };
             const viewpoint = { custom_fields: {} };
             viewpoint.orthogonal_camera = getOrthogonalCamera();
             viewpoint.perspective_camera = getPerspectiveCamera();
@@ -57063,9 +55125,36 @@ js: import "konva/skia-backend";
             viewpoint.description = new Date().toDateString();
             this._markup.getViewpoint(viewpoint);
             viewpoint.custom_fields.camera_target = getPoint3dFromVector3(this.target);
+            viewpoint.custom_fields.selection2 = getSelection2();
             this.emitEvent({ type: "createviewpoint", data: viewpoint });
             return viewpoint;
         }
+        screenToWorld(position) {
+            if (!this.renderer)
+                return { x: position.x, y: position.y, z: 0 };
+            const rect = this.canvas.getBoundingClientRect();
+            const x = position.x / (rect.width / 2) - 1;
+            const y = -position.y / (rect.height / 2) + 1;
+            const point = new Vector3(x, y, -1);
+            point.unproject(this.camera);
+            return { x: point.x, y: point.y, z: point.z };
+        }
+        worldToScreen(position) {
+            if (!this.renderer)
+                return { x: position.x, y: position.y };
+            const point = new Vector3(position.x, position.y, position.z);
+            point.project(this.camera);
+            const rect = this.canvas.getBoundingClientRect();
+            const x = (point.x + 1) * (rect.width / 2);
+            const y = (-point.y + 1) * (rect.height / 2);
+            return { x, y };
+        }
+        getScale() {
+            return { x: 1, y: 1, z: 1 };
+        }
+        executeCommand(id, ...args) {
+            return commands.executeCommand(id, this, ...args);
+        }
     }
 
     if (typeof window !== "undefined")