https://www.vzome.com/modules/chunk-6JQSYMRV.js

116// node_modules/solid-three/node_modules/@solid-primitives/utils/dist/index.js
117var noop = (() => void 0);
118var isNonNullable = (i) => i != null;
119var filterNonNullable = (arr) => arr.filter(isNonNullable);
120var access = (v) => typeof v === "function" && !v.length ? v() : v;
121var asArray = (value) => Array.isArray(value) ? value : value ? [value] : [];
122function handleDiffArray(current, prev, handleAdded, handleRemoved) {
123  const currLength = current.length;
124  const prevLength = prev.length;
125  let i = 0;
126  if (!prevLength) {
127    for (; i < currLength; i++)
128      handleAdded(current[i]);
129    return;
130  }
131  if (!currLength) {
132    for (; i < prevLength; i++)
133      handleRemoved(prev[i]);
134    return;
135  }
136  for (; i < prevLength; i++) {
137    if (prev[i] !== current[i])
138      break;
139  }
140  let prevEl;
141  let currEl;
142  prev = prev.slice(i);
143  current = current.slice(i);
144  for (prevEl of prev) {
145    if (!current.includes(prevEl))
146      handleRemoved(prevEl);
147  }
148  for (currEl of current) {
149    if (!prev.includes(currEl))
150      handleAdded(currEl);
151  }
152}
153

154// node_modules/solid-three/node_modules/@solid-primitives/resize-observer/dist/index.js
155function makeResizeObserver(callback, options) {
156  if (isServer) {
157    return { observe: noop, unobserve: noop };
158  }
159  const observer = new ResizeObserver(callback);
160  onCleanup(observer.disconnect.bind(observer));
161  return {
162    observe: (ref) => observer.observe(ref, options),
163    unobserve: observer.unobserve.bind(observer)
164  };
165}
166function createResizeObserver(targets, onResize, options) {
167  if (isServer)
168    return;
169  const previousMap = /* @__PURE__ */ new WeakMap(), { observe, unobserve } = makeResizeObserver((entries) => {
170    for (const entry of entries) {
171      const { contentRect, target } = entry, width = Math.round(contentRect.width), height = Math.round(contentRect.height), previous = previousMap.get(target);
172      if (!previous || previous.width !== width || previous.height !== height) {
173        onResize(contentRect, target, entry);
174        previousMap.set(target, { width, height });
175      }
176    }
177  }, options);
178  createEffect((prev) => {
179    const refs = filterNonNullable(asArray(access(targets)));
180    handleDiffArray(refs, prev, observe, unobserve);
181    return refs;
182  }, []);
183}
184

185// node_modules/@bigmistqke/solid-whenever/dist/index.js
186function resolve(value) {
187  return typeof value !== "function" ? value : value();
188}
189var check = (accessor, callback, fallback) => {
190  const value = resolve(accessor);
191  return value ? callback(value) : fallback ? fallback() : void 0;
192};
193var when = (accessor, callback, fallback) => {
194  return (...args) => check(
195    accessor,
196    (value) => callback(value, ...args),
197    fallback ? () => fallback(...args) : void 0
198  );
199};
200function whenify(fn) {
201  return function(accessor, callback, fallback) {
202    return fn(when(accessor, callback, fallback));
203  };
204}
205var whenMemo = whenify(createMemo);
206var whenEffect = whenify(createEffect);
207var whenRenderEffect = whenify(createRenderEffect);
208var whenComputed = whenify(createComputed);
209

210// node_modules/solid-three/dist/index.js
211var $S3C = /* @__PURE__ */ Symbol("solid-three");
212function isRecord(value) {
213  return !Array.isArray(value) && typeof value === "object";
214}
215var isOrthographicCamera = (def) => "isOrthographicCamera" in def && !!def.isOrthographicCamera;
216var isVector3 = (def) => "isVector3" in def && !!def.isVector3;
217function autodispose(object) {
218  if (object.dispose) {
219    onCleanup(() => object.dispose?.());
220  }
221  return object;
222}
223function meta(instance, augmentation = { props: {} }) {
224  if (hasMeta(instance)) {
225    return instance;
226  }
227  const _instance = instance;
228  _instance[$S3C] = mergeProps(
229    { children: /* @__PURE__ */ new Set(), parent: void 0 },
230    augmentation
231  );
232  return _instance;
233}
234function getMeta(value) {
235  return hasMeta(value) ? value[$S3C] : void 0;
236}
237function hasMeta(element) {
238  return typeof element === "object" && element && $S3C in element;
239}
240async function awaitMapObject(object, callback) {
241  const result = {};
242  for (const key in object) {
243    result[key] = await callback(object[key], key);
244  }
245  return result;
246}
247function bubbleUp(node, callback) {
248  let current = node;
249  while (current) {
250    callback(current);
251    current = "parent" in current ? current.parent : void 0;
252  }
253}
254function defaultProps(props, defaults) {
255  return mergeProps(defaults, props);
256}
257var hasColorSpace = (object) => "colorSpace" in object || "outputColorSpace" in object;
258function isConstructor(value) {
259  return typeof value === "function" && value.prototype !== void 0;
260}
261function isMaterial(value) {
262  return !!value && value.isMaterial === true;
263}
264function isBufferGeometry(value) {
265  return !!value && value.isBufferGeometry === true;
266}
267function isFog(value) {
268  return !!value && value.isFog === true;
269}
270function isObject3D(value) {
271  return !!value && value.isObject3D === true;
272}
273function isWritable(object, propertyName) {
274  return Object.getOwnPropertyDescriptor(object, propertyName)?.writable;
275}
276function isRenderer(value) {
277  return typeof value === "object" && value !== null && typeof value.render === "function" && typeof value.setSize === "function";
278}
279function isWebGLShadowMap(value) {
280  return !!value && "needsUpdate" in value;
281}
282function getPendingInit(renderer) {
283  const init = renderer.init;
284  const hasInitialized = renderer.hasInitialized;
285  if (typeof init !== "function") return void 0;
286  if (hasInitialized?.call(renderer)) return void 0;
287  return () => init.call(renderer);
288}
289var removeElementFromArray = (array, value) => {
290  const index = array.indexOf(value);
291  if (index !== -1) array.splice(index, 1);
292  return array;
293};
294function resolve2(child, recursive = false) {
295  if (isConstructor(child)) {
296    return child;
297  }
298  if (typeof child === "function") {
299    const value = child();
300    if (recursive) {
301      return resolve2(value);
302    }
303    return value;
304  }
305  return child;
306}
307function withMultiContexts(children3, values) {
308  let result;
309  values.reduce((acc, [context, value], index) => {
310    return () => context.Provider({
311      value,
312      children: () => {
313        if (index === 0) result = acc();
314        else acc();
315      }
316    });
317  }, children3)();
318  return result;
319}
320async function load(loader, input) {
321  if (isRecord(input)) {
322    return await awaitMapObject(input, (path) => load(loader, path));
323  }
324  return new Promise((resolve22, reject) => loader.load(input, resolve22, void 0, reject));
325}
326function useRef(props, value) {
327  createRenderEffect(() => {
328    const result = typeof value === "function" ? (
329      // @ts-expect-error — T may itself be callable; the Accessor branch is intended
330      value()
331    ) : value;
332    if (typeof props.ref === "function") {
333      const cleanup = props.ref(result);
334      if (typeof cleanup === "function") onCleanup(cleanup);
335    } else {
336      props.ref = result;
337    }
338  });
339}
340var tempTarget = new Vector3();
341var position = new Vector3();
342function getCurrentViewport(_camera, target, { width, height, top, left }) {
343  const aspect = width / height;
344  if (isVector3(target)) {
345    tempTarget.copy(target);
346  } else {
347    tempTarget.set(...target);
348  }
349  const distance = _camera.getWorldPosition(position).distanceTo(tempTarget);
350  if (isOrthographicCamera(_camera)) {
351    return {
352      width: width / _camera.zoom,
353      height: height / _camera.zoom,
354      top,
355      left,
356      factor: 1,
357      distance,
358      aspect
359    };
360  }
361  const fov = _camera.fov * Math.PI / 180;
362  const h = 2 * Math.tan(fov / 2) * distance;
363  const w = h * (width / height);
364  return { width: w, height: h, top, left, factor: width / w, distance, aspect };
365}
366function binarySearch(array, target) {
367  let left = 0;
368  let right = array.length;
369  while (left < right) {
370    const mid = Math.floor((left + right) / 2);
371    if (array[mid] < target) {
372      left = mid + 1;
373    } else {
374      right = mid;
375    }
376  }
377  return left;
378}
379var eventNameMap = {
380  onClick: "click",
381  onContextMenu: "contextmenu",
382  onDoubleClick: "dblclick",
383  onMouseDown: "mousedown",
384  onMouseMove: "mousemove",
385  onMouseUp: "mouseup",
386  onMouseLeave: "mouseleave",
387  onPointerUp: "pointerup",
388  onPointerDown: "pointerdown",
389  onPointerMove: "pointermove",
390  onPointerLeave: "pointerleave",
391  onWheel: "wheel"
392};
393function createRegistry() {
394  const array = [];
395  return {
396    array,
397    add(instance) {
398      array.push(instance);
399      return () => {
400        array.splice(
401          array.findIndex((_instance) => _instance === instance),
402          1
403        );
404      };
405    }
406  };
407}
408var isEventType = (type) => /^on(Pointer|Click|DoubleClick|ContextMenu|Wheel|Mouse)/.test(type);
409function createThreeEvent(nativeEvent, { stoppable = true, intersections } = {}) {
410  const event = stoppable ? {
411    nativeEvent,
412    stopped: false,
413    stopPropagation() {
414      event.stopped = true;
415    }
416  } : { nativeEvent };
417  if (intersections) {
418    event.intersections = intersections;
419    event.intersection = intersections[0];
420  }
421  return event;
422}
423function raycast(context, registry, event) {
424  if ("update" in context.raycaster) {
425    context.raycaster.update(event, context);
426  }
427  const nodeSet = /* @__PURE__ */ new Set();
428  const visitedSet = /* @__PURE__ */ new Set();
429  const stack = [...registry];
430  for (const object of stack) {
431    if (visitedSet.has(object)) continue;
432    visitedSet.add(object);
433    const meta2 = getMeta(object);
434    if (meta2 && meta2.props.raycastable !== false) {
435      nodeSet.add(object);
436    }
437    stack.push(...object.children);
438  }
439  return context.raycaster.intersectObjects(Array.from(nodeSet), false);
440}
441function createMissableEventRegistry(type, context) {
442  const registry = createRegistry();
443  context.canvas.addEventListener(eventNameMap[type], (nativeEvent) => {
444    const missedType = `${type}Missed`;
445    if (registry.array.length === 0 && !context.props[type] && !context.props[missedType]) return;
446    const missedObjects = new Set(registry.array);
447    const visitedObjects = /* @__PURE__ */ new Set();
448    const intersections = raycast(context, registry.array, nativeEvent);
449    const stoppableEvent = createThreeEvent(nativeEvent, { intersections });
450    for (const intersection of intersections) {
451      stoppableEvent.currentIntersection = intersection;
452      let node = intersection.object;
453      while (node && !stoppableEvent.stopped && !visitedObjects.has(node)) {
454        missedObjects.delete(node);
455        visitedObjects.add(node);
456        getMeta(node)?.props[type]?.(
457          // @ts-expect-error TODO: fix type-error
458          stoppableEvent
459        );
460        node = node.parent;
461      }
462    }
463    if (!stoppableEvent.stopped) {
464      delete stoppableEvent.currentIntersection;
465      context.props[type]?.(stoppableEvent);
466    }
467    for (const remainingObject of missedObjects) {
468      const intersections2 = context.raycaster.intersectObject(remainingObject, true);
469      for (const { object } of intersections2) {
470        let node = object;
471        while (node && !visitedObjects.has(node)) {
472          missedObjects.delete(node);
473          visitedObjects.add(node);
474          node = node.parent;
475        }
476      }
477    }
478    const missedEvent = createThreeEvent(nativeEvent, { stoppable: false });
479    for (const object of missedObjects) {
480      getMeta(object)?.props[missedType]?.(missedEvent);
481    }
482    if (intersections.length === 0) {
483      context.props[`${type}Missed`]?.(missedEvent);
484    }
485  });
486  return registry;
487}
488function createHoverEventRegistry(type, context) {
489  const registry = createRegistry();
490  let hoveredSet = /* @__PURE__ */ new Set();
491  let intersections = [];
492  let hoveredCanvas = false;
493  context.canvas.addEventListener(eventNameMap[`on${type}Move`], (nativeEvent) => {
494    intersections = raycast(context, registry.array, nativeEvent);
495    const enterEvent = createThreeEvent(nativeEvent, { stoppable: false, intersections });
496    const enterSet = /* @__PURE__ */ new Set();
497    for (const intersection of intersections) {
498      enterEvent.currentIntersection = intersection;
499      let current = intersection.object;
500      while (current && !enterSet.has(current)) {
501        enterSet.add(current);
502        if (!hoveredSet.has(current)) {
503          getMeta(current)?.props[`on${type}Enter`]?.(
504            // @ts-expect-error TODO: fix type-error
505            enterEvent
506          );
507        }
508        current = current.parent;
509      }
510    }
511    if (hoveredCanvas === false) {
512      context.props[`on${type}Enter`]?.(
513        // @ts-expect-error TODO: fix type-error
514        enterEvent
515      );
516      hoveredCanvas = true;
517    }
518    const moveEvent = createThreeEvent(nativeEvent, { intersections });
519    const moveSet = /* @__PURE__ */ new Set();
520    for (const intersection of intersections) {
521      moveEvent.currentIntersection = intersection;
522      let current = intersection.object;
523      while (current && !moveSet.has(current)) {
524        moveSet.add(current);
525        const meta2 = getMeta(current);
526        if (meta2) {
527          meta2.props[`on${type}Move`]?.(
528            // @ts-expect-error TODO: fix type-error
529            moveEvent
530          );
531          if (moveEvent.stopped) {
532            break;
533          }
534        }
535        current = current.parent;
536      }
537    }
538    if (!moveEvent.stopped) {
539      delete moveEvent.currentIntersection;
540      context.props[`on${type}Move`]?.(
541        // @ts-expect-error TODO: fix type-error
542        moveEvent
543      );
544    }
545    const leaveEvent = createThreeEvent(nativeEvent, { intersections, stoppable: false });
546    const prevHoveredSet = hoveredSet;
547    hoveredSet = enterSet;
548    for (const object of prevHoveredSet) {
549      if (enterSet.has(object)) continue;
550      getMeta(object)?.props[`on${type}Leave`]?.(
551        // @ts-expect-error TODO: fix type-error
552        leaveEvent
553      );
554    }
555  });
556  context.canvas.addEventListener(eventNameMap[`on${type}Leave`], (nativeEvent) => {
557    const leaveEvent = createThreeEvent(nativeEvent, { stoppable: false });
558    context.props[`on${type}Leave`]?.(leaveEvent);
559    hoveredCanvas = false;
560    for (const object of hoveredSet) {
561      getMeta(object)?.props[`on${type}Leave`]?.(
562        // @ts-expect-error TODO: fix type-error
563        leaveEvent
564      );
565    }
566    hoveredSet.clear();
567  });
568  return registry;
569}
570function createDefaultEventRegistry(type, context, options) {
571  const registry = createRegistry();
572  context.canvas.addEventListener(
573    eventNameMap[type],
574    (nativeEvent) => {
575      const intersections = raycast(context, registry.array, nativeEvent);
576      const event = createThreeEvent(nativeEvent, { intersections });
577      for (const intersection of intersections) {
578        event.currentIntersection = intersection;
579        let node = intersection.object;
580        while (node && !event.stopped) {
581          getMeta(node)?.props[type]?.(
582            // @ts-expect-error TODO: fix type-error
583            event
584          );
585          node = node.parent;
586        }
587      }
588      if (!event.stopped) {
589        delete event.currentIntersection;
590        context.props[type]?.(event);
591      }
592    },
593    options
594  );
595  return registry;
596}
597function createEvents(context) {
598  const hoverMouseRegistry = createHoverEventRegistry("Mouse", context);
599  const hoverPointerRegistry = createHoverEventRegistry("Pointer", context);
600  const missableClickRegistry = createMissableEventRegistry("onClick", context);
601  const missableContextMenuRegistry = createMissableEventRegistry("onContextMenu", context);
602  const missableDoubleClickRegistry = createMissableEventRegistry("onDoubleClick", context);
603  const mouseDownRegistry = createDefaultEventRegistry("onMouseDown", context);
604  const mouseUpRegistry = createDefaultEventRegistry("onMouseUp", context);
605  const pointerDownRegistry = createDefaultEventRegistry("onPointerDown", context);
606  const pointerUpRegistry = createDefaultEventRegistry("onPointerUp", context);
607  const wheelRegistry = createDefaultEventRegistry("onWheel", context, { passive: true });
608  return {
609    /**
610     * Registers an `AugmentedElement<Object3D>` with the event handling system.
611     *
612     * @param object - The 3D object to register.
613     * @param type - The type of event the object should listen for.
614     */
615    addEventListener(object, type) {
616      switch (type) {
617        // Missable Events
618        case "onClick":
619        case "onClickMissed":
620          return missableClickRegistry.add(object);
621        case "onContextMenu":
622        case "onContextMenuMissed":
623          return missableContextMenuRegistry.add(object);
624        case "onDoubleClick":
625        case "onDoubleClickMissed":
626          return missableDoubleClickRegistry.add(object);
627        // Hover Events
628        case "onMouseEnter":
629        case "onMouseLeave":
630        case "onMouseMove":
631          return hoverMouseRegistry.add(object);
632        case "onPointerEnter":
633        case "onPointerLeave":
634        case "onPointerMove":
635          return hoverPointerRegistry.add(object);
636        // Default Events
637        case "onMouseDown":
638          return mouseDownRegistry.add(object);
639        case "onMouseUp":
640          return mouseUpRegistry.add(object);
641        case "onPointerDown":
642          return pointerDownRegistry.add(object);
643        case "onPointerUp":
644          return pointerUpRegistry.add(object);
645        case "onWheel":
646          return wheelRegistry.add(object);
647      }
648    }
649  };
650}
651var Stack = class {
652  constructor(name = "") {
653    this.name = name;
654    [this.#array, this.#setArray] = createSignal([], {
655      equals: false
656    });
657  }
658  name;
659  #array;
660  #setArray;
661  /**
662   * Returns the complete stack.
663   * @returns Returns the complete stack.
664   */
665  all() {
666    return this.#array();
667  }
668  /**
669   * Returns the top element of the stack without removing it.
670   * @returns The top element of the stack.
671   */
672  peek() {
673    const array = this.#array();
674    const top = array[array.length - 1];
675    return typeof top === "function" ? top() : top;
676  }
677  /**
678   * Adds a value `T` or `Accessor<T>` to the stack.
679   * Value is automatically removed from stack on cleanup.
680   * @param value - The value to add to the stack.
681   * @returns A cleanup function to remove the value from the stack.
682   */
683  push(value) {
684    this.#setArray((array) => {
685      const index = array.indexOf(value);
686      if (index !== -1) array.splice(index, 1);
687      array.push(value);
688      return array;
689    });
690    onCleanup(() => this.remove(value));
691    return () => this.remove(value);
692  }
693  /**
694   * Removes a value from the stack.
695   * @private
696   * @param value - The value to remove from the stack.
697   */
698  remove(value) {
699    this.#setArray((array) => {
700      const index = array.indexOf(value);
701      if (index === -1) return array;
702      array.splice(index, 1);
703      return array;
704    });
705  }
706};
707var TreeNode = class {
708  constructor(key, parent) {
709    this.key = key;
710    this.parent = parent;
711  }
712  key;
713  parent;
714  children = /* @__PURE__ */ new Map();
715  count = 0;
716  data;
717  delete() {
718    this.parent.children.delete(this.key);
719  }
720};
721var TreeRegistry = class _TreeRegistry {
722  /** Map of child nodes at the root level */
723  children = /* @__PURE__ */ new Map();
724  /** Count of data nodes in this tree */
725  count = 0;
726  #resolve(input, autocreate) {
727    const paths = Array.isArray(input) ? input : [input];
728    let current = this;
729    for (let i = 0; i < paths.length; i++) {
730      let node = current.children.get(paths[i]);
731      if (!node) {
732        if (!autocreate) {
733          return void 0;
734        }
735        node = new TreeNode(paths[i], current);
736        current.children.set(paths[i], node);
737      }
738      current = node;
739    }
740    if (current instanceof _TreeRegistry) {
741      throw new Error(`Invalid resolution: ${paths}`);
742    }
743    return current;
744  }
745  /**
746   * Retrieves data stored at the specified path.
747   * @param input Path as a string or array of strings
748   * @returns The data stored at the path, or undefined if not found
749   */
750  get(input, warn = true) {
751    const node = this.#resolve(input, false);
752    if (!node) {
753      return void 0;
754    }
755    return node.data;
756  }
757  /**
758   * Stores data at the specified path, creating nodes as needed.
759   * Automatically increments reference counts up the tree when storing new data.
760   * @param input Path as a string or array of strings
761   * @param data The data to store
762   */
763  set(input, data) {
764    const node = this.#resolve(input, true);
765    if (!node.data) {
766      bubbleUp(node, (node2) => node2.count++);
767    }
768    node.data = data;
769  }
770  /**
771   * Deletes data at the specified path and cleans up empty branches.
772   * Automatically decrements reference counts and removes nodes with zero references.
773   * @param input Path as a string or array of strings
774   */
775  delete(input) {
776    const node = this.#resolve(input, false);
777    if (!node) {
778      return;
779    }
780    bubbleUp(node, (node2) => {
781      node2.count--;
782      if (node2 instanceof TreeNode && node2.count === 0) {
783        node2.delete();
784      }
785    });
786  }
787};
788var LoaderCache = class {
789  /** Map of loader instances to their respective tree registries */
790  #treeRegistryMap = /* @__PURE__ */ new Map();
791  /** Weak map for reverse lookup from data to cache nodes */
792  #dataMap = /* @__PURE__ */ new WeakMap();
793  /** Set of resources that do not have active references and can be safely cleaned up. */
794  freeList = /* @__PURE__ */ new Set();
795  /**
796   * Gets or creates a tree registry for a specific loader.
797   * @param loader The Three.js loader instance
798   * @returns The tree registry for this loader
799   * @private
800   */
801  #registry(loader) {
802    let registry = this.#treeRegistryMap.get(loader);
803    if (!registry) {
804      this.#treeRegistryMap.set(
805        loader,
806        registry = new TreeRegistry()
807      );
808    }
809    return registry;
810  }
811  /**
812   * Deletes a cache node and its associated resource.
813   * @param node The cache node to delete
814   * @param options.force Force deletion even if not in free list
815   * @private
816   */
817  #delete(node, { force } = {}) {
818    if (!force && !this.freeList.has(node.data)) {
819      return;
820    }
821    node.dispose();
822  }
823  /**
824   * Disposes all resources in the free list.
825   * Should be called periodically to clean up unused resources.
826   */
827  disposeFreeList() {
828    this.freeList.forEach((resource) => this.#dataMap.get(resource)?.dispose());
829  }
830  /**
831   * Manually deletes a specific resource from the cache.
832   * @param resource The resource object to delete
833   * @param options.force Force deletion even if resource has active references
834   */
835  disposeResource(resource, options) {
836    const node = this.#dataMap.get(resource);
837    if (!node) {
838      return;
839    }
840    this.#delete(node, options);
841  }
842  /**
843   * Removes a resource from a specific loader's cache at the given path.
844   * @param loader The Three.js loader instance
845   * @param url The URL or path to the resource
846   * @param options.force Force deletion even if resource has active references
847   */
848  delete(loader, url, options) {
849    const node = this.#registry(loader).get(url);
850    if (!node) {
851      return;
852    }
853    this.#delete(node, options);
854  }
855  /**
856   * Retrieves a resource from the cache and tracks its usage.
857   * Automatically integrates with Solid.js cleanup for reference counting.
858   * @param loader The Three.js loader instance
859   * @param url The URL or path to the resource
860   * @returns The resource promise, resolved data, or undefined if not found
861   */
862  get(loader, url, warn) {
863    const node = this.#registry(loader).get(url, warn);
864    if (!node) return void 0;
865    return node.data;
866  }
867  /**
868   * Stores a resource in the cache at the specified path.
869   * @param loader The Three.js loader instance
870   * @param path The URL or path to store the resource at
871   * @param data The resource promise to cache
872   * @param options.force Force update even if resource already exists
873   * @returns The stored promise
874   */
875  set(loader, path, data, options) {
876    const registry = this.#registry(loader);
877    let node = registry.get(path, false);
878    if (node) {
879      node.update(data, options);
880    } else {
881      node = new CacheNode(this.freeList, registry, path, data);
882      this.#dataMap.set(data, node);
883      registry.set(path, node);
884    }
885    return data;
886  }
887};
888var CacheNode = class {
889  /**
890   * Creates a new cache node.
891   * @param free The global free list for deferred disposal
892   * @param registry The tree registry containing this node
893   * @param path The path where this resource is stored
894   * @param promise The resource promise to cache
895   */
896  constructor(free, registry, path, promise) {
897    this.free = free;
898    this.registry = registry;
899    this.path = path;
900    this.data = promise;
901    this.#set(promise);
902  }
903  free;
904  registry;
905  path;
906  /** Reference count for this resource */
907  count = 0;
908  /** The cached resource (promise or resolved value) */
909  data;
910  /**
911   * Sets the promise and handles resolution.
912   * @param promise The resource promise
913   * @private
914   */
915  #set(promise) {
916    this.data = promise;
917    Promise.resolve(promise).then((value) => {
918      if (this.data === promise) {
919        this.data = value;
920      }
921    });
922  }
923  /**
924   * Disposes the Three.js resource if it has a dispose method.
925   * @private
926   */
927  #dispose() {
928    if (isRecord(this.data) && "dispose" in this.data && typeof this.data.dispose === "function") {
929      this.data.dispose();
930    }
931  }
932  /**
933   * Deletes this node and disposes its resource.
934   */
935  dispose() {
936    this.#dispose();
937    this.registry.delete(this.path);
938  }
939  /**
940   * Tracks usage of this resource within a Solid.js reactive context.
941   * Automatically increments reference count and schedules cleanup on component unmount.
942   */
943  track() {
944    if (this.count === 0) {
945      this.free.delete(this.data);
946    }
947    this.count++;
948    if (!getOwner()) ;
949    else {
950      onCleanup(() => {
951        this.count -= 1;
952        if (this.count <= 0) {
953          this.free.add(this.data);
954        }
955      });
956    }
957  }
958  /**
959   * Updates the cached resource with new data.
960   * @param data The new resource promise
961   * @param options.force Force update and dispose current resource (default: true)
962   */
963  update(data, { force = true } = {}) {
964    if (this.data !== data && !force) ;
965    else {
966      this.#dispose();
967      this.#set(data);
968      this.registry.set(this.path, this);
969    }
970  }
971};
972var frameContext = createContext();
973var useFrame = (callback, options) => {
974  const addFrameListener = useContext(frameContext);
975  if (!addFrameListener) {
976    throw new Error("S3: Hooks can only be used within the Canvas component!");
977  }
978  return addFrameListener(callback, options);
979};
980var threeContext = createContext(null);
981function useThree(callback) {
982  const store = useContext(threeContext);
983  if (!store) {
984    throw new Error("S3: Hooks can only be used within the Canvas component!");
985  }
986  if (callback) return () => callback(store);
987  return store;
988}
989var LOADER_CACHE = /* @__PURE__ */ new Map();
990function resolveUrls(base, url) {
991  if (Array.isArray(url)) {
992    return url.map((url2) => new URL(url2, base).href);
993  } else if (isRecord(url)) {
994    return Object.fromEntries(
995      Object.entries(url).map(([key, url2]) => [key, resolveUrls(base, url2)])
996    );
997  } else if (typeof url === "string") {
998    return new URL(url, base).href;
999  }
1000  throw new Error("Unexpected type");
1001}
1002function useLoader(constructor, url, options) {
1003  const config = mergeProps({ cache: true }, options);
1004  const loader = createMemo(() => {
1005    const _constructor = resolve2(constructor);
1006    let loader2 = LOADER_CACHE.get(_constructor);
1007    if (!loader2) {
1008      LOADER_CACHE.set(_constructor, loader2 = new _constructor());
1009    }
1010    return loader2;
1011  });
1012  function getOrInsert(registry, loader2, input) {
1013    if (isRecord(input)) {
1014      return awaitMapObject(input, async (value) => getOrInsert(registry, loader2, value));
1015    } else {
1016      const _input = input;
1017      const cachedPromise = registry.get(loader2, _input, false);
1018      if (cachedPromise) {
1019        return cachedPromise;
1020      }
1021      const promise = load(loader2, _input);
1022      registry.set(loader2, _input, promise);
1023      return promise;
1024    }
1025  }
1026  function loadUrl(url2) {
1027    if (config.cache === true) {
1028      if (!useLoader.cache) {
1029        return load(loader(), url2);
1030      }
1031      return getOrInsert(useLoader.cache, loader(), url2);
1032    }
1033    if (config.cache) {
1034      return getOrInsert(config.cache, loader(), url2);
1035    }
1036    return load(loader(), url2);
1037  }
1038  const [resource] = createResource(
1039    () => [resolve2(url), options?.base, loader()],
1040    async ([url2, base, loader2]) => {
1041      config.onBeforeLoad?.(loader2);
1042      url2 = base ? resolveUrls(base, url2) : url2;
1043      const result = await loadUrl(url2);
1044      config.onLoad?.(result);
1045      return result;
1046    }
1047  );
1048  return resource;
1049}
1050useLoader.cache = new LoaderCache();
1051var addToEventListeners = (object, type) => {
1052  const addToEventListeners2 = useContext(eventContext);
1053  if (!addToEventListeners2) {
1054    throw new Error("S3: Hooks can only be used within the Canvas component!");
1055  }
1056  return addToEventListeners2(object, type);
1057};
1058var eventContext = createContext();
1059createContext();
1060function applySceneGraph(parent, child) {
1061  const parentMeta = getMeta(parent);
1062  if (parentMeta) {
1063    parentMeta.children.add(child);
1064    onCleanup(() => parentMeta.children.delete(child));
1065  }
1066  const childMeta = getMeta(child);
1067  if (childMeta) {
1068    childMeta.parent = parent;
1069    onCleanup(() => childMeta.parent = void 0);
1070  }
1071  let attachProp = childMeta?.props.attach;
1072  if (typeof attachProp === "function") {
1073    const cleanup = attachProp(parent, child);
1074    onCleanup(cleanup);
1075    return;
1076  }
1077  if (!attachProp) {
1078    if (isMaterial(child)) attachProp = "material";
1079    else if (isBufferGeometry(child)) attachProp = "geometry";
1080    else if (isFog(child)) attachProp = "fog";
1081  }
1082  if (attachProp) {
1083    let target = parent;
1084    let property;
1085    const path = attachProp.split("-");
1086    while (property = path.shift()) {
1087      if (path.length === 0) {
1088        target[property] = child;
1089        onCleanup(() => target[property] = void 0);
1090        break;
1091      } else {
1092        target = target[property];
1093      }
1094    }
1095    return;
1096  }
1097  if (isObject3D(child) && isObject3D(parent)) return;
1098}
1099var useSceneGraph = (_parent, props) => {
1100  const c = children(() => props.children);
1101  createComputed(
1102    mapArray(
1103      () => c.toArray(),
1104      (_child) => createComputed(() => {
1105        const parent = resolve2(_parent);
1106        if (!parent) return;
1107        const child = resolve2(_child);
1108        if (!child) return;
1109        applySceneGraph(parent, child);
1110        props.onUpdate?.(parent);
1111      })
1112    )
1113  );
1114  createComputed((previousManagedChildren) => {
1115    const parent = resolve2(_parent);
1116    if (!isObject3D(parent)) {
1117      return previousManagedChildren;
1118    }
1119    const childArray = c.toArray();
1120    const managedChildren = /* @__PURE__ */ new Set();
1121    for (const child of childArray) {
1122      if (!isObject3D(child) || getMeta(child)?.props.attach) continue;
1123      managedChildren.add(child);
1124      if (child.parent !== parent) {
1125        parent.add(child);
1126      }
1127    }
1128    for (const child of previousManagedChildren) {
1129      if (!managedChildren.has(child)) {
1130        parent.remove(child);
1131      }
1132    }
1133    let childArrayIndex = 0;
1134    for (let i = 0; i < parent.children.length; i++) {
1135      if (!managedChildren.has(parent.children[i])) {
1136        continue;
1137      }
1138      while (childArrayIndex < childArray.length) {
1139        const child = childArray[childArrayIndex++];
1140        if (isObject3D(child) && !getMeta(child)?.props.attach) {
1141          parent.children[i] = child;
1142          break;
1143        }
1144      }
1145    }
1146    return managedChildren;
1147  }, /* @__PURE__ */ new Set());
1148};
1149var NEEDS_UPDATE = [
1150  "map",
1151  "envMap",
1152  "bumpMap",
1153  "normalMap",
1154  "transparent",
1155  "morphTargets",
1156  "skinning",
1157  "alphaTest",
1158  "useVertexColors",
1159  "flatShading"
1160];
1161function applyProp(context, source, type, value) {
1162  if (!source) {
1163    return;
1164  }
1165  if (value === void 0) return;
1166  if (type.indexOf("-") > -1) {
1167    const [property, ...rest] = type.split("-");
1168    applyProp(context, source[property], rest.join("-"), value);
1169    return;
1170  }
1171  if (NEEDS_UPDATE.includes(type) && (!source[type] && value || source[type] && !value)) {
1172    source.needsUpdate = true;
1173  }
1174  if (hasColorSpace(source)) {
1175    const sRGBEncoding2 = 3001;
1176    const SRGBColorSpace22 = "srgb";
1177    const LinearSRGBColorSpace22 = "srgb-linear";
1178    if (type === "encoding") {
1179      type = "colorSpace";
1180      value = value === sRGBEncoding2 ? SRGBColorSpace22 : LinearSRGBColorSpace22;
1181    } else if (type === "outputEncoding") {
1182      type = "outputColorSpace";
1183      value = value === sRGBEncoding2 ? SRGBColorSpace22 : LinearSRGBColorSpace22;
1184    }
1185  }
1186  if (isEventType(type)) {
1187    if (isObject3D(source) && hasMeta(source)) {
1188      const cleanup = addToEventListeners(source, type);
1189      onCleanup(cleanup);
1190    }
1191    return;
1192  }
1193  const target = source[type];
1194  try {
1195    if (target?.copy && target?.constructor === value?.constructor && !isWritable(source, type)) {
1196      target.copy(value);
1197    } else if (target?.set && Array.isArray(value)) {
1198      if (target.fromArray) target.fromArray(value);
1199      else target.set(...value);
1200    } else if (target?.set && typeof value !== "object") {
1201      const isColor = target instanceof Color;
1202      if (!isColor && target.setScalar && typeof value === "number") {
1203        target.setScalar(value);
1204      } else if (value !== void 0) {
1205        target.set(value);
1206      }
1207    } else {
1208      source[type] = value;
1209      if (source[type] instanceof Texture && // sRGB textures must be RGBA8 since r137 https://github.com/mrdoob/three.js/pull/23129
1210      source[type].format === RGBAFormat && source[type].type === UnsignedByteType) {
1211        createRenderEffect(() => {
1212          context.props.linear;
1213          context.props.flat;
1214          const texture = source[type];
1215          if (hasColorSpace(texture) && hasColorSpace(context.gl)) {
1216            texture.colorSpace = context.gl.outputColorSpace;
1217          } else {
1218            texture.encoding = context.gl.outputEncoding;
1219          }
1220        });
1221      }
1222    }
1223  } finally {
1224    if ("needsUpdate" in source) {
1225      source.needsUpdate = true;
1226    }
1227    if (context.props.frameloop === "demand") {
1228      context.requestRender();
1229    }
1230  }
1231}
1232function useProps(accessor, props, context = useThree()) {
1233  const [local, instanceProps] = splitProps(props, ["ref", "args", "object", "attach", "children"]);
1234  useSceneGraph(accessor, props);
1235  createRenderEffect(() => {
1236    const object = resolve2(accessor);
1237    if (!object) return;
1238    createRenderEffect(() => {
1239      if (local.ref instanceof Function) local.ref(object);
1240      else local.ref = object;
1241    });
1242    createRenderEffect(() => {
1243      const keys2 = Object.keys(instanceProps);
1244      for (const key of keys2) {
1245        const subKeys = keys2.filter((_key) => key !== _key && _key.includes(key));
1246        createRenderEffect(() => {
1247          applyProp(context, object, key, props[key]);
1248          for (const subKey of subKeys) {
1249            applyProp(context, object, subKey, props[subKey]);
1250          }
1251        });
1252      }
1253      untrack(() => props.onUpdate)?.(object);
1254    });
1255  });
1256}
1257var CursorRaycaster = class extends Raycaster {
1258  pointer = new Vector2();
1259  update(event, context) {
1260    this.pointer.x = event.offsetX / context.bounds.width * 2 - 1;
1261    this.pointer.y = -(event.offsetY / context.bounds.height) * 2 + 1;
1262    this.setFromCamera(this.pointer, context.camera);
1263  }
1264};
1265function debounce(callback, wait = 100, options = {}) {
1266  if (typeof callback !== "function") {
1267    throw new TypeError(
1268      `Expected the first parameter to be a function, got \`${typeof callback}\`.`
1269    );
1270  }
1271  if (wait < 0) {
1272    throw new RangeError("`wait` must not be negative.");
1273  }
1274  const { immediate } = options;
1275  let storedContext;
1276  let storedArguments;
1277  let timeoutId;
1278  let timestamp;
1279  let result;
1280  function run() {
1281    const callContext = storedContext;
1282    const callArguments = storedArguments;
1283    storedContext = void 0;
1284    storedArguments = void 0;
1285    result = callback.apply(callContext, callArguments);
1286    return result;
1287  }
1288  function later() {
1289    const last = Date.now() - timestamp;
1290    if (last < wait && last >= 0) {
1291      timeoutId = setTimeout(later, wait - last);
1292    } else {
1293      timeoutId = void 0;
1294      if (!immediate) {
1295        result = run();
1296      }
1297    }
1298  }
1299  function debounced(...args) {
1300    if (storedContext && this !== storedContext) {
1301      throw new Error("Debounced method called with different contexts.");
1302    }
1303    storedContext = this;
1304    storedArguments = args;
1305    timestamp = Date.now();
1306    const callNow = immediate && !timeoutId;
1307    if (!timeoutId) {
1308      timeoutId = setTimeout(later, wait);
1309    }
1310    if (callNow) {
1311      result = run();
1312    }
1313    return result;
1314  }
1315  debounced.clear = () => {
1316    if (!timeoutId) return;
1317    clearTimeout(timeoutId);
1318    timeoutId = void 0;
1319  };
1320  debounced.flush = () => {
1321    if (!timeoutId) return;
1322    debounced.trigger();
1323  };
1324  debounced.trigger = () => {
1325    result = run();
1326    debounced.clear();
1327  };
1328  return debounced;
1329}
1330function useMeasure(options) {
1331  const config = mergeProps(
1332    {
1333      debounce: 0,
1334      scroll: false,
1335      offsetSize: false
1336    },
1337    options
1338  );
1339  const ResizeObserver2 = config.polyfill || (typeof globalThis === "undefined" ? class ResizeObserver {
1340  } : globalThis.ResizeObserver);
1341  if (!ResizeObserver2) {
1342    throw new Error(
1343      "This browser does not support ResizeObserver out of the box. See: https://github.com/react-spring/react-use-measure/#resize-observer-polyfills"
1344    );
1345  }
1346  const [element, setElement] = createSignal(null);
1347  const [bounds, setBounds] = createSignal({
1348    left: 0,
1349    top: 0,
1350    width: 0,
1351    height: 0,
1352    bottom: 0,
1353    right: 0,
1354    x: 0,
1355    y: 0
1356  });
1357  const scrollContainers = createMemo(() => findScrollContainers(element()));
1358  let lastBounds;
1359  const getDebounce = (type) => {
1360    const debounce2 = config.debounce ? typeof config.debounce === "number" ? config.debounce : config.debounce[type] : null;
1361    if (debounce2) return debounce(forceRefresh, debounce2);
1362    return forceRefresh;
1363  };
1364  const forceRefresh = when(element, (element2) => {
1365    const { left, top, width, height, bottom, right, x, y } = element2.getBoundingClientRect();
1366    const bounds2 = {
1367      left,
1368      top,
1369      width,
1370      height,
1371      bottom,
1372      right,
1373      x,
1374      y
1375    };
1376    if (element2 instanceof HTMLElement && config.offsetSize) {
1377      bounds2.height = element2.offsetHeight;
1378      bounds2.width = element2.offsetWidth;
1379    }
1380    Object.freeze(bounds2);
1381    if (!lastBounds || !areBoundsEqual(lastBounds, bounds2)) {
1382      lastBounds = bounds2;
1383      setBounds(bounds2);
1384    }
1385  });
1386  createEffect(() => {
1387    const onScroll = getDebounce("scroll");
1388    createEffect(() => {
1389      if (!config.scroll) return;
1390      globalThis.addEventListener("scroll", onScroll, { capture: true, passive: true });
1391      onCleanup(() => globalThis.removeEventListener("scroll", onScroll, true));
1392    });
1393    whenEffect(scrollContainers, (scrollContainers2) => {
1394      if (!config.scroll) return;
1395      scrollContainers2.forEach(
1396        (scrollContainer) => scrollContainer.addEventListener("scroll", onScroll, {
1397          capture: true,
1398          passive: true
1399        })
1400      );
1401      onCleanup(() => {
1402        scrollContainers2.forEach((element2) => {
1403          element2.removeEventListener("scroll", onScroll, true);
1404        });
1405      });
1406    });
1407  });
1408  createEffect(() => {
1409    const onResize = getDebounce("resize");
1410    globalThis.addEventListener("resize", onResize);
1411    onCleanup(() => globalThis.removeEventListener("resize", onResize));
1412    whenEffect(element, (element2) => {
1413      const observer = new ResizeObserver2(onResize);
1414      observer.observe(element2);
1415      onCleanup(() => observer.disconnect());
1416    });
1417  });
1418  return {
1419    setElement: (source) => {
1420      if (!source || source === element()) return;
1421      setElement(source);
1422      forceRefresh();
1423    },
1424    bounds,
1425    forceRefresh
1426  };
1427}
1428function findScrollContainers(element) {
1429  const result = [];
1430  if (!element || element === document.body) return result;
1431  const { overflow, overflowX, overflowY } = globalThis.getComputedStyle(element);
1432  if ([overflow, overflowX, overflowY].some((prop) => prop === "auto" || prop === "scroll"))
1433    result.push(element);
1434  return [...result, ...findScrollContainers(element.parentElement)];
1435}
1436var keys = ["x", "y", "top", "bottom", "left", "right", "width", "height"];
1437var areBoundsEqual = (a, b) => keys.every((key) => a[key] === b[key]);
1438function createThree(canvas, props) {
1439  const canvasProps = defaultProps(props, {
1440    frameloop: "always"
1441  });
1442  const frameListeners = {
1443    before: {
1444      map: /* @__PURE__ */ new Map(),
1445      priorities: []
1446      // Keep this sorted
1447    },
1448    after: {
1449      map: /* @__PURE__ */ new Map(),
1450      priorities: []
1451    }
1452  };
1453  const addFrameListener = (callback, options) => {
1454    return createRoot((dispose) => {
1455      createRenderEffect(() => {
1456        const {
1457          stage = "before",
1458          priority = 0
1459        } = options ?? {};
1460        const listeners = frameListeners[stage];
1461        let array = listeners.map.get(priority);
1462        if (!array) {
1463          array = [];
1464          listeners.map.set(priority, array);
1465          const index = binarySearch(listeners.priorities, priority);
1466          listeners.priorities.splice(index, 0, priority);
1467        }
1468        array.push(callback);
1469        onCleanup(() => {
1470          removeElementFromArray(array, callback);
1471          if (array.length === 0) {
1472            listeners.map.delete(priority);
1473            listeners.priorities.splice(listeners.priorities.indexOf(priority), 1);
1474          }
1475        });
1476      });
1477      return dispose;
1478    });
1479  };
1480  function updateFrameListeners(stage, delta, frame) {
1481    for (const priority of frameListeners[stage].priorities) {
1482      const callbacks = frameListeners[stage].map.get(priority);
1483      for (const callback of callbacks) {
1484        callback(context, delta, frame);
1485      }
1486    }
1487  }
1488  let pendingRenderRequest;
1489  const isPresenting = () => !!context.gl?.xr?.isPresenting;
1490  function render(timestamp, frame) {
1491    if (!context.gl || rendererReady.state !== "ready") {
1492      return;
1493    }
1494    if (props.frameloop === "never") {
1495      context.clock.elapsedTime = timestamp;
1496    }
1497    pendingRenderRequest = void 0;
1498    const delta = context.clock.getDelta();
1499    updateFrameListeners("before", delta, frame);
1500    context.gl.render(context.scene, context.camera);
1501    updateFrameListeners("after", delta, frame);
1502  }
1503  function requestRender() {
1504    if (isPresenting()) return;
1505    if (pendingRenderRequest) return;
1506    pendingRenderRequest = requestAnimationFrame(render);
1507  }
1508  onCleanup(() => pendingRenderRequest && cancelAnimationFrame(pendingRenderRequest));
1509  const cameraIsInstance = createMemo(() => props.camera instanceof Camera);
1510  const orthographicFlag = createMemo(() => !!props.orthographic);
1511  const sceneIsInstance = createMemo(() => props.scene instanceof Scene);
1512  const raycasterIsInstance = createMemo(() => props.raycaster instanceof Raycaster);
1513  const glKind = createMemo(() => {
1514    const _propsGl = props.gl;
1515    if (typeof _propsGl === "function") return "factory";
1516    if (isRenderer(_propsGl)) return "instance";
1517    return "default";
1518  });
1519  const WEBGL_CONSTRUCTOR_KEYS = ["alpha", "antialias", "depth", "failIfMajorPerformanceCaveat", "logarithmicDepthBuffer", "powerPreference", "precision", "premultipliedAlpha", "preserveDrawingBuffer", "reversedDepthBuffer", "stencil"];
1520  const camera = createMemo(() => {
1521    if (cameraIsInstance()) {
1522      return meta(props.camera, {
1523        get props() {
1524          return props.camera || {};
1525        }
1526      });
1527    }
1528    return meta(orthographicFlag() ? new OrthographicCamera() : new PerspectiveCamera(), {
1529      get props() {
1530        return props.camera || {};
1531      }
1532    });
1533  });
1534  const cameraStack = new Stack("camera");
1535  const scene = createMemo(() => {
1536    if (sceneIsInstance()) {
1537      return meta(props.scene, {
1538        get props() {
1539          return props.scene || {};
1540        }
1541      });
1542    }
1543    return meta(new Scene(), {
1544      get props() {
1545        return props.scene || {};
1546      }
1547    });
1548  });
1549  const raycaster = createMemo(() => {
1550    if (raycasterIsInstance()) {
1551      return meta(props.raycaster, {
1552        get props() {
1553          return props.raycaster || {};
1554        }
1555      });
1556    }
1557    return meta(new CursorRaycaster(), {
1558      get props() {
1559        return props.raycaster || {};
1560      }
1561    });
1562  });
1563  const raycasterStack = new Stack("raycaster");
1564  let ownsCurrentRenderer = false;
1565  let initialConstructorArgs = {};
1566  const gl = createMemo((previous) => {
1567    if (previous && ownsCurrentRenderer) {
1568      const old = previous;
1569      old.dispose?.();
1570      if ("forceContextLoss" in old) old.forceContextLoss();
1571    }
1572    const kind = glKind();
1573    let _gl;
1574    if (kind === "factory") {
1575      _gl = props.gl(canvas);
1576      ownsCurrentRenderer = false;
1577    } else if (kind === "instance") {
1578      _gl = props.gl;
1579      ownsCurrentRenderer = false;
1580    } else {
1581      const flat = untrack(() => props.gl ?? {});
1582      const constructorArgs = {};
1583      for (const key of WEBGL_CONSTRUCTOR_KEYS) {
1584        if (key in flat) constructorArgs[key] = flat[key];
1585      }
1586      initialConstructorArgs = constructorArgs;
1587      _gl = new WebGLRenderer({
1588        alpha: true,
1589        ...constructorArgs,
1590        canvas
1591      });
1592      ownsCurrentRenderer = true;
1593    }
1594    return meta(_gl, {
1595      get props() {
1596        return props.gl || {};
1597      }
1598    });
1599  });
1600  const [rendererReady] = createResource(() => gl(), (renderer) => {
1601    const init = getPendingInit(renderer);
1602    if (!init) return true;
1603    const rect = canvas.getBoundingClientRect();
1604    const ratio = globalThis.devicePixelRatio || 1;
1605    if (rect.width > 0 && rect.height > 0) {
1606      canvas.width = rect.width * ratio;
1607      canvas.height = rect.height * ratio;
1608    }
1609    return init().then(() => true);
1610  });
1611  const measure = useMeasure();
1612  measure.setElement(canvas);
1613  const defaultTarget = new Vector3();
1614  const viewport = createMemo(() => getCurrentViewport(camera(), defaultTarget, measure.bounds()));
1615  const clock = new Clock();
1616  clock.start();
1617  const context = {
1618    get bounds() {
1619      return measure.bounds();
1620    },
1621    canvas,
1622    clock,
1623    get dpr() {
1624      return this.gl.getPixelRatio?.() ?? 1;
1625    },
1626    props,
1627    render,
1628    requestRender,
1629    get viewport() {
1630      return viewport();
1631    },
1632    // elements
1633    get camera() {
1634      return cameraStack.peek() ?? camera();
1635    },
1636    setCamera(camera2) {
1637      return cameraStack.push(camera2);
1638    },
1639    get scene() {
1640      return scene();
1641    },
1642    get raycaster() {
1643      return raycasterStack.peek() || raycaster();
1644    },
1645    setRaycaster(raycaster2) {
1646      return raycasterStack.push(raycaster2);
1647    },
1648    get gl() {
1649      return gl();
1650    }
1651  };
1652  withMultiContexts(() => {
1653    createRenderEffect(() => {
1654      if (props.frameloop === "never") {
1655        context.clock.stop();
1656        context.clock.elapsedTime = 0;
1657      } else {
1658        context.clock.start();
1659      }
1660    });
1661    createRenderEffect(() => {
1662      if (cameraStack.peek()) return;
1663      if (!props.camera || props.camera instanceof Camera) return;
1664      useProps(camera, props.camera);
1665      camera().updateMatrixWorld(true);
1666    });
1667    createRenderEffect(() => {
1668      if (!props.scene || props.scene instanceof Scene) return;
1669      useProps(scene, props.scene);
1670    });
1671    createRenderEffect(() => {
1672      if (!props.raycaster || props.raycaster instanceof Raycaster) return;
1673      useProps(raycaster, props.raycaster);
1674    });
1675    createRenderEffect(() => {
1676      createRenderEffect(() => {
1677        const shadowMap = gl().shadowMap;
1678        if (!shadowMap) return;
1679        const oldEnabled = shadowMap.enabled;
1680        const oldType = shadowMap.type;
1681        shadowMap.enabled = !!props.shadows;
1682        if (typeof props.shadows === "boolean") {
1683          shadowMap.type = PCFSoftShadowMap;
1684        } else if (typeof props.shadows === "string") {
1685          const types = {
1686            basic: BasicShadowMap,
1687            percentage: PCFShadowMap,
1688            soft: PCFSoftShadowMap,
1689            variance: VSMShadowMap
1690          };
1691          shadowMap.type = types[props.shadows] ?? PCFSoftShadowMap;
1692        } else if (typeof props.shadows === "object") {
1693          Object.assign(shadowMap, props.shadows);
1694        }
1695        if (isWebGLShadowMap(shadowMap) && (oldEnabled !== shadowMap.enabled || oldType !== shadowMap.type)) {
1696          shadowMap.needsUpdate = true;
1697        }
1698      });
1699      const _gl = gl();
1700      if ("outputColorSpace" in _gl) {
1701        useProps(gl, {
1702          get outputColorSpace() {
1703            return props.linear ? LinearSRGBColorSpace : SRGBColorSpace;
1704          }
1705        });
1706      }
1707      if ("toneMapping" in _gl) {
1708        useProps(gl, {
1709          get toneMapping() {
1710            return props.flat ? NoToneMapping : ACESFilmicToneMapping;
1711          }
1712        });
1713      }
1714      const _propsGl = props.gl;
1715      if (_propsGl && typeof _propsGl !== "function" && !isRenderer(_propsGl)) {
1716        useProps(gl, _propsGl);
1717      }
1718      let warnedCtorKeys = false;
1719      createEffect(() => {
1720        if (warnedCtorKeys) return;
1721        const flat = props.gl ?? {};
1722        for (const key of WEBGL_CONSTRUCTOR_KEYS) {
1723          if (key in flat && flat[key] !== initialConstructorArgs[key]) {
1724            warnedCtorKeys = true;
1725            return;
1726          }
1727        }
1728      });
1729    });
1730  }, [[threeContext, context]]);
1731  let pendingLoopRequest;
1732  function loop(value) {
1733    if (isPresenting()) {
1734      pendingLoopRequest = void 0;
1735      return;
1736    }
1737    pendingLoopRequest = requestAnimationFrame(loop);
1738    context.render(value);
1739  }
1740  createRenderEffect(() => {
1741    if (canvasProps.frameloop === "always") {
1742      pendingLoopRequest = requestAnimationFrame(loop);
1743    }
1744    onCleanup(() => pendingLoopRequest && cancelAnimationFrame(pendingLoopRequest));
1745  });
1746  createRenderEffect(() => {
1747    const _gl = gl();
1748    const xr = _gl.xr;
1749    if (!xr || typeof xr.addEventListener !== "function") return;
1750    const resume = () => {
1751      if (canvasProps.frameloop === "always") {
1752        if (!pendingLoopRequest) pendingLoopRequest = requestAnimationFrame(loop);
1753      } else if (canvasProps.frameloop === "demand") {
1754        requestRender();
1755      }
1756    };
1757    xr.addEventListener("sessionend", resume);
1758    onCleanup(() => xr.removeEventListener("sessionend", resume));
1759  });
1760  const {
1761    addEventListener
1762  } = createEvents(context);
1763  const c = children(() => createComponent(eventContext.Provider, {
1764    value: addEventListener,
1765    get children() {
1766      return createComponent(frameContext.Provider, {
1767        value: addFrameListener,
1768        get children() {
1769          return createComponent(threeContext.Provider, {
1770            value: context,
1771            get children() {
1772              return canvasProps.children;
1773            }
1774          });
1775        }
1776      });
1777    }
1778  }));
1779  useSceneGraph(context.scene, {
1780    get children() {
1781      return c();
1782    }
1783  });
1784  withMultiContexts(() => useRef(props, context), [[threeContext, context], [frameContext, addFrameListener]]);
1785  return mergeProps(context, {
1786    addFrameListener
1787  });
1788}
1789var _tmpl$ = /* @__PURE__ */ template(`<div style=position:relative;width:100%;height:100%;overflow:hidden;contain:strict;display:flex><canvas>`);
1790function Canvas(props) {
1791  let canvas;
1792  let container;
1793  onMount(() => {
1794    if (!canvas || !container) return;
1795    const context = createThree(canvas, props);
1796    createResizeObserver(container, function onResize() {
1797      const {
1798        width,
1799        height
1800      } = container.getBoundingClientRect();
1801      context.gl.setSize(width, height);
1802      context.gl.setPixelRatio?.(globalThis.devicePixelRatio);
1803      if (context.camera instanceof OrthographicCamera) {
1804        context.camera.left = width / -2;
1805        context.camera.right = width / 2;
1806        context.camera.top = height / 2;
1807        context.camera.bottom = height / -2;
1808      } else {
1809        context.camera.aspect = width / height;
1810      }
1811      context.camera.updateProjectionMatrix();
1812      if (!context.gl?.xr?.isPresenting) context.render(performance.now());
1813    });
1814  });
1815  return (() => {
1816    var _el$ = _tmpl$(), _el$2 = _el$.firstChild;
1817    var _ref$ = container;
1818    typeof _ref$ === "function" ? use(_ref$, _el$) : container = _el$;
1819    var _ref$2 = canvas;
1820    typeof _ref$2 === "function" ? use(_ref$2, _el$2) : canvas = _el$2;
1821    createRenderEffect((_p$) => {
1822      var _v$ = {
1823        ...props.style
1824      }, _v$2 = props.class;
1825      _p$.e = style(_el$, _v$, _p$.e);
1826      _v$2 !== _p$.t && className(_el$, _p$.t = _v$2);
1827      return _p$;
1828    }, {
1829      e: void 0,
1830      t: void 0
1831    });
1832    return _el$;
1833  })();
1834}
1835function Resource(props) {
1836  const [options, config, rest] = splitProps(props, ["base", "cache", "onBeforeLoad", "onLoad"], ["loader", "url", "children"]);
1837  const resource = useLoader(() => config.loader, () => config.url, options);
1838  const tagged = createMemo(() => {
1839    const value = resource();
1840    if (!value || typeof value !== "object") return value;
1841    return hasMeta(value) ? value : meta(value, {
1842      props
1843    });
1844  });
1845  useProps(tagged, rest);
1846  return createComponent(Show, {
1847    get when() {
1848      return memo(() => "children" in config)() && tagged();
1849    },
1850    get fallback() {
1851      return tagged();
1852    },
1853    children: (value) => props.children?.(value)
1854  });
1855}
1856function createT(catalogue) {
1857  const cache = /* @__PURE__ */ new Map();
1858  return new Proxy({}, {
1859    get: (_, name) => {
1860      if (!cache.has(name)) {
1861        const constructor = catalogue[name];
1862        if (!constructor) return void 0;
1863        cache.set(name, createEntity(constructor));
1864      }
1865      return cache.get(name);
1866    }
1867  });
1868}
1869function createEntity(Constructor) {
1870  return (props) => {
1871    const memo2 = createMemo(() => {
1872      props.key;
1873      try {
1874        return meta(autodispose(new Constructor(...props.args ?? [])), {
1875          props
1876        });
1877      } catch (e) {
1878        throw new Error("");
1879      }
1880    });
1881    useProps(memo2, props);
1882    return memo2;
1883  };
1884}
1885var xrContext = createContext();
1886function useXR() {
1887  const state = useContext(xrContext);
1888  if (!state) {
1889    throw new Error("S3: useXR must be used within <xr.Provider> (from createXR())");
1890  }
1891  return state;
1892}
1893function createXR() {
1894  const [context, setContext] = createSignal();
1895  const [presenting, setPresenting] = createSignal(false);
1896  const [session, setSession] = createSignal();
1897  createRenderEffect(() => {
1898    const ctx = context();
1899    const gl = ctx ? ctx.gl : void 0;
1900    const xr = gl?.xr;
1901    if (!gl || !xr || typeof xr.addEventListener !== "function") return;
1902    const onStart = () => setPresenting(true);
1903    const onEnd = () => {
1904      setPresenting(false);
1905      setSession(void 0);
1906      gl.setAnimationLoop(null);
1907      gl.xr.enabled = false;
1908    };
1909    xr.addEventListener("sessionstart", onStart);
1910    xr.addEventListener("sessionend", onEnd);
1911    onCleanup(() => {
1912      xr.removeEventListener("sessionstart", onStart);
1913      xr.removeEventListener("sessionend", onEnd);
1914    });
1915  });
1916  function connect(value) {
1917    setContext(value);
1918    return () => setContext(void 0);
1919  }
1920  function requestSession(mode, init) {
1921    if (!navigator.xr) {
1922      throw new Error("S3: WebXR unavailable (navigator.xr is undefined)");
1923    }
1924    return navigator.xr.requestSession(mode, init);
1925  }
1926  async function enter(arg, init) {
1927    const ctx = context();
1928    if (!ctx) {
1929      throw new Error("S3: createXR().enter() called before <Canvas ref={xr.connect}> connected");
1930    }
1931    const gl = ctx.gl;
1932    if (!gl.xr) {
1933      throw new Error("S3: the active renderer has no xr manager");
1934    }
1935    const xrSession = typeof arg === "string" ? await requestSession(arg, init) : arg;
1936    gl.setAnimationLoop(ctx.render);
1937    gl.xr.enabled = true;
1938    await gl.xr.setSession(xrSession);
1939    setSession(xrSession);
1940    return xrSession;
1941  }
1942  async function exit() {
1943    await session()?.end();
1944  }
1945  function isSupported(mode) {
1946    return navigator.xr?.isSessionSupported(mode) ?? Promise.resolve(false);
1947  }
1948  const state = {
1949    isPresenting: presenting,
1950    session,
1951    exit
1952  };
1953  function Provider(props) {
1954    return createComponent(xrContext.Provider, {
1955      value: state,
1956      get children() {
1957        return props.children;
1958      }
1959    });
1960  }
1961  return {
1962    connect,
1963    enter,
1964    exit,
1965    isSupported,
1966    isPresenting: presenting,
1967    session,
1968    Provider
1969  };
1970}
1971

1972// node_modules/three-stdlib/utils/BufferGeometryUtils.js
1973function toTrianglesDrawMode(geometry, drawMode) {
1974  if (drawMode === TrianglesDrawMode) {
1975    console.warn("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Geometry already defined as triangles.");
1976    return geometry;
1977  }
1978  if (drawMode === TriangleFanDrawMode || drawMode === TriangleStripDrawMode) {
1979    let index = geometry.getIndex();
1980    if (index === null) {
1981      const indices = [];
1982      const position2 = geometry.getAttribute("position");
1983      if (position2 !== void 0) {
1984        for (let i = 0; i < position2.count; i++) {
1985          indices.push(i);
1986        }
1987        geometry.setIndex(indices);
1988        index = geometry.getIndex();
1989      } else {
1990        console.error(
1991          "THREE.BufferGeometryUtils.toTrianglesDrawMode(): Undefined position attribute. Processing not possible."
1992        );
1993        return geometry;
1994      }
1995    }
1996    const numberOfTriangles = index.count - 2;
1997    const newIndices = [];
1998    if (index) {
1999      if (drawMode === TriangleFanDrawMode) {
2000        for (let i = 1; i <= numberOfTriangles; i++) {
2001          newIndices.push(index.getX(0));
2002          newIndices.push(index.getX(i));
2003          newIndices.push(index.getX(i + 1));
2004        }
2005      } else {
2006        for (let i = 0; i < numberOfTriangles; i++) {
2007          if (i % 2 === 0) {
2008            newIndices.push(index.getX(i));
2009            newIndices.push(index.getX(i + 1));
2010            newIndices.push(index.getX(i + 2));
2011          } else {
2012            newIndices.push(index.getX(i + 2));
2013            newIndices.push(index.getX(i + 1));
2014            newIndices.push(index.getX(i));
2015          }
2016        }
2017      }
2018    }
2019    if (newIndices.length / 3 !== numberOfTriangles) {
2020      console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unable to generate correct amount of triangles.");
2021    }
2022    const newGeometry = geometry.clone();
2023    newGeometry.setIndex(newIndices);
2024    newGeometry.clearGroups();
2025    return newGeometry;
2026  } else {
2027    console.error("THREE.BufferGeometryUtils.toTrianglesDrawMode(): Unknown draw mode:", drawMode);
2028    return geometry;
2029  }
2030}
2031

2032// node_modules/three-stdlib/_polyfill/constants.js
2033var version = /* @__PURE__ */ (() => parseInt(REVISION.replace(/\D+/g, "")))();
2034

2035// node_modules/three-stdlib/_polyfill/LoaderUtils.js
2036function decodeText(array) {
2037  if (typeof TextDecoder !== "undefined") {
2038    return new TextDecoder().decode(array);
2039  }
2040  let s = "";
2041  for (let i = 0, il = array.length; i < il; i++) {
2042    s += String.fromCharCode(array[i]);
2043  }
2044  try {
2045    return decodeURIComponent(escape(s));
2046  } catch (e) {
2047    return s;
2048  }
2049}
2050

2051// node_modules/three-stdlib/loaders/GLTFLoader.js
2052var SRGBColorSpace2 = "srgb";
2053var LinearSRGBColorSpace2 = "srgb-linear";
2054var sRGBEncoding = 3001;
2055var LinearEncoding = 3e3;
2056var GLTFLoader = class extends Loader {
2057  constructor(manager) {
2058    super(manager);
2059    this.dracoLoader = null;
2060    this.ktx2Loader = null;
2061    this.meshoptDecoder = null;
2062    this.pluginCallbacks = [];
2063    this.register(function(parser) {
2064      return new GLTFMaterialsClearcoatExtension(parser);
2065    });
2066    this.register(function(parser) {
2067      return new GLTFMaterialsDispersionExtension(parser);
2068    });
2069    this.register(function(parser) {
2070      return new GLTFTextureBasisUExtension(parser);
2071    });
2072    this.register(function(parser) {
2073      return new GLTFTextureWebPExtension(parser);
2074    });
2075    this.register(function(parser) {
2076      return new GLTFTextureAVIFExtension(parser);
2077    });
2078    this.register(function(parser) {
2079      return new GLTFMaterialsSheenExtension(parser);
2080    });
2081    this.register(function(parser) {
2082      return new GLTFMaterialsTransmissionExtension(parser);
2083    });
2084    this.register(function(parser) {
2085      return new GLTFMaterialsVolumeExtension(parser);
2086    });
2087    this.register(function(parser) {
2088      return new GLTFMaterialsIorExtension(parser);
2089    });
2090    this.register(function(parser) {
2091      return new GLTFMaterialsEmissiveStrengthExtension(parser);
2092    });
2093    this.register(function(parser) {
2094      return new GLTFMaterialsSpecularExtension(parser);
2095    });
2096    this.register(function(parser) {
2097      return new GLTFMaterialsIridescenceExtension(parser);
2098    });
2099    this.register(function(parser) {
2100      return new GLTFMaterialsAnisotropyExtension(parser);
2101    });
2102    this.register(function(parser) {
2103      return new GLTFMaterialsBumpExtension(parser);
2104    });
2105    this.register(function(parser) {
2106      return new GLTFLightsExtension(parser);
2107    });
2108    this.register(function(parser) {
2109      return new GLTFMeshoptCompression(parser);
2110    });
2111    this.register(function(parser) {
2112      return new GLTFMeshGpuInstancing(parser);
2113    });
2114  }
2115  load(url, onLoad, onProgress, onError) {
2116    const scope = this;
2117    let resourcePath;
2118    if (this.resourcePath !== "") {
2119      resourcePath = this.resourcePath;
2120    } else if (this.path !== "") {
2121      const relativeUrl = LoaderUtils.extractUrlBase(url);
2122      resourcePath = LoaderUtils.resolveURL(relativeUrl, this.path);
2123    } else {
2124      resourcePath = LoaderUtils.extractUrlBase(url);
2125    }
2126    this.manager.itemStart(url);
2127    const _onError = function(e) {
2128      if (onError) {
2129        onError(e);
2130      } else {
2131        console.error(e);
2132      }
2133      scope.manager.itemError(url);
2134      scope.manager.itemEnd(url);
2135    };
2136    const loader = new FileLoader(this.manager);
2137    loader.setPath(this.path);
2138    loader.setResponseType("arraybuffer");
2139    loader.setRequestHeader(this.requestHeader);
2140    loader.setWithCredentials(this.withCredentials);
2141    loader.load(
2142      url,
2143      function(data) {
2144        try {
2145          scope.parse(
2146            data,
2147            resourcePath,
2148            function(gltf) {
2149              onLoad(gltf);
2150              scope.manager.itemEnd(url);
2151            },
2152            _onError
2153          );
2154        } catch (e) {
2155          _onError(e);
2156        }
2157      },
2158      onProgress,
2159      _onError
2160    );
2161  }
2162  setDRACOLoader(dracoLoader) {
2163    this.dracoLoader = dracoLoader;
2164    return this;
2165  }
2166  setDDSLoader() {
2167    throw new Error('THREE.GLTFLoader: "MSFT_texture_dds" no longer supported. Please update to "KHR_texture_basisu".');
2168  }
2169  setKTX2Loader(ktx2Loader) {
2170    this.ktx2Loader = ktx2Loader;
2171    return this;
2172  }
2173  setMeshoptDecoder(meshoptDecoder) {
2174    this.meshoptDecoder = meshoptDecoder;
2175    return this;
2176  }
2177  register(callback) {
2178    if (this.pluginCallbacks.indexOf(callback) === -1) {
2179      this.pluginCallbacks.push(callback);
2180    }
2181    return this;
2182  }
2183  unregister(callback) {
2184    if (this.pluginCallbacks.indexOf(callback) !== -1) {
2185      this.pluginCallbacks.splice(this.pluginCallbacks.indexOf(callback), 1);
2186    }
2187    return this;
2188  }
2189  parse(data, path, onLoad, onError) {
2190    let json;
2191    const extensions = {};
2192    const plugins = {};
2193    if (typeof data === "string") {
2194      json = JSON.parse(data);
2195    } else if (data instanceof ArrayBuffer) {
2196      const magic = decodeText(new Uint8Array(data.slice(0, 4)));
2197      if (magic === BINARY_EXTENSION_HEADER_MAGIC) {
2198        try {
2199          extensions[EXTENSIONS.KHR_BINARY_GLTF] = new GLTFBinaryExtension(data);
2200        } catch (error) {
2201          if (onError)
2202            onError(error);
2203          return;
2204        }
2205        json = JSON.parse(extensions[EXTENSIONS.KHR_BINARY_GLTF].content);
2206      } else {
2207        json = JSON.parse(decodeText(new Uint8Array(data)));
2208      }
2209    } else {
2210      json = data;
2211    }
2212    if (json.asset === void 0 || json.asset.version[0] < 2) {
2213      if (onError)
2214        onError(new Error("THREE.GLTFLoader: Unsupported asset. glTF versions >=2.0 are supported."));
2215      return;
2216    }
2217    const parser = new GLTFParser(json, {
2218      path: path || this.resourcePath || "",
2219      crossOrigin: this.crossOrigin,
2220      requestHeader: this.requestHeader,
2221      manager: this.manager,
2222      ktx2Loader: this.ktx2Loader,
2223      meshoptDecoder: this.meshoptDecoder
2224    });
2225    parser.fileLoader.setRequestHeader(this.requestHeader);
2226    for (let i = 0; i < this.pluginCallbacks.length; i++) {
2227      const plugin = this.pluginCallbacks[i](parser);
2228      if (!plugin.name)
2229        console.error("THREE.GLTFLoader: Invalid plugin found: missing name");
2230      plugins[plugin.name] = plugin;
2231      extensions[plugin.name] = true;
2232    }
2233    if (json.extensionsUsed) {
2234      for (let i = 0; i < json.extensionsUsed.length; ++i) {
2235        const extensionName = json.extensionsUsed[i];
2236        const extensionsRequired = json.extensionsRequired || [];
2237        switch (extensionName) {
2238          case EXTENSIONS.KHR_MATERIALS_UNLIT:
2239            extensions[extensionName] = new GLTFMaterialsUnlitExtension();
2240            break;
2241          case EXTENSIONS.KHR_DRACO_MESH_COMPRESSION:
2242            extensions[extensionName] = new GLTFDracoMeshCompressionExtension(json, this.dracoLoader);
2243            break;
2244          case EXTENSIONS.KHR_TEXTURE_TRANSFORM:
2245            extensions[extensionName] = new GLTFTextureTransformExtension();
2246            break;
2247          case EXTENSIONS.KHR_MESH_QUANTIZATION:
2248            extensions[extensionName] = new GLTFMeshQuantizationExtension();
2249            break;
2250          default:
2251            if (extensionsRequired.indexOf(extensionName) >= 0 && plugins[extensionName] === void 0) {
2252              console.warn('THREE.GLTFLoader: Unknown extension "' + extensionName + '".');
2253            }
2254        }
2255      }
2256    }
2257    parser.setExtensions(extensions);
2258    parser.setPlugins(plugins);
2259    parser.parse(onLoad, onError);
2260  }
2261  parseAsync(data, path) {
2262    const scope = this;
2263    return new Promise(function(resolve3, reject) {
2264      scope.parse(data, path, resolve3, reject);
2265    });
2266  }
2267};
2268function GLTFRegistry() {
2269  let objects = {};
2270  return {
2271    get: function(key) {
2272      return objects[key];
2273    },
2274    add: function(key, object) {
2275      objects[key] = object;
2276    },
2277    remove: function(key) {
2278      delete objects[key];
2279    },
2280    removeAll: function() {
2281      objects = {};
2282    }
2283  };
2284}
2285var EXTENSIONS = {
2286  KHR_BINARY_GLTF: "KHR_binary_glTF",
2287  KHR_DRACO_MESH_COMPRESSION: "KHR_draco_mesh_compression",
2288  KHR_LIGHTS_PUNCTUAL: "KHR_lights_punctual",
2289  KHR_MATERIALS_CLEARCOAT: "KHR_materials_clearcoat",
2290  KHR_MATERIALS_DISPERSION: "KHR_materials_dispersion",
2291  KHR_MATERIALS_IOR: "KHR_materials_ior",
2292  KHR_MATERIALS_SHEEN: "KHR_materials_sheen",
2293  KHR_MATERIALS_SPECULAR: "KHR_materials_specular",
2294  KHR_MATERIALS_TRANSMISSION: "KHR_materials_transmission",
2295  KHR_MATERIALS_IRIDESCENCE: "KHR_materials_iridescence",
2296  KHR_MATERIALS_ANISOTROPY: "KHR_materials_anisotropy",
2297  KHR_MATERIALS_UNLIT: "KHR_materials_unlit",
2298  KHR_MATERIALS_VOLUME: "KHR_materials_volume",
2299  KHR_TEXTURE_BASISU: "KHR_texture_basisu",
2300  KHR_TEXTURE_TRANSFORM: "KHR_texture_transform",
2301  KHR_MESH_QUANTIZATION: "KHR_mesh_quantization",
2302  KHR_MATERIALS_EMISSIVE_STRENGTH: "KHR_materials_emissive_strength",
2303  EXT_MATERIALS_BUMP: "EXT_materials_bump",
2304  EXT_TEXTURE_WEBP: "EXT_texture_webp",
2305  EXT_TEXTURE_AVIF: "EXT_texture_avif",
2306  EXT_MESHOPT_COMPRESSION: "EXT_meshopt_compression",
2307  EXT_MESH_GPU_INSTANCING: "EXT_mesh_gpu_instancing"
2308};
2309var GLTFLightsExtension = class {
2310  constructor(parser) {
2311    this.parser = parser;
2312    this.name = EXTENSIONS.KHR_LIGHTS_PUNCTUAL;
2313    this.cache = { refs: {}, uses: {} };
2314  }
2315  _markDefs() {
2316    const parser = this.parser;
2317    const nodeDefs = this.parser.json.nodes || [];
2318    for (let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) {
2319      const nodeDef = nodeDefs[nodeIndex];
2320      if (nodeDef.extensions && nodeDef.extensions[this.name] && nodeDef.extensions[this.name].light !== void 0) {
2321        parser._addNodeRef(this.cache, nodeDef.extensions[this.name].light);
2322      }
2323    }
2324  }
2325  _loadLight(lightIndex) {
2326    const parser = this.parser;
2327    const cacheKey = "light:" + lightIndex;
2328    let dependency = parser.cache.get(cacheKey);
2329    if (dependency)
2330      return dependency;
2331    const json = parser.json;
2332    const extensions = json.extensions && json.extensions[this.name] || {};
2333    const lightDefs = extensions.lights || [];
2334    const lightDef = lightDefs[lightIndex];
2335    let lightNode;
2336    const color = new Color(16777215);
2337    if (lightDef.color !== void 0)
2338      color.setRGB(lightDef.color[0], lightDef.color[1], lightDef.color[2], LinearSRGBColorSpace2);
2339    const range = lightDef.range !== void 0 ? lightDef.range : 0;
2340    switch (lightDef.type) {
2341      case "directional":
2342        lightNode = new DirectionalLight(color);
2343        lightNode.target.position.set(0, 0, -1);
2344        lightNode.add(lightNode.target);
2345        break;
2346      case "point":
2347        lightNode = new PointLight(color);
2348        lightNode.distance = range;
2349        break;
2350      case "spot":
2351        lightNode = new SpotLight(color);
2352        lightNode.distance = range;
2353        lightDef.spot = lightDef.spot || {};
2354        lightDef.spot.innerConeAngle = lightDef.spot.innerConeAngle !== void 0 ? lightDef.spot.innerConeAngle : 0;
2355        lightDef.spot.outerConeAngle = lightDef.spot.outerConeAngle !== void 0 ? lightDef.spot.outerConeAngle : Math.PI / 4;
2356        lightNode.angle = lightDef.spot.outerConeAngle;
2357        lightNode.penumbra = 1 - lightDef.spot.innerConeAngle / lightDef.spot.outerConeAngle;
2358        lightNode.target.position.set(0, 0, -1);
2359        lightNode.add(lightNode.target);
2360        break;
2361      default:
2362        throw new Error("THREE.GLTFLoader: Unexpected light type: " + lightDef.type);
2363    }
2364    lightNode.position.set(0, 0, 0);
2365    lightNode.decay = 2;
2366    assignExtrasToUserData(lightNode, lightDef);
2367    if (lightDef.intensity !== void 0)
2368      lightNode.intensity = lightDef.intensity;
2369    lightNode.name = parser.createUniqueName(lightDef.name || "light_" + lightIndex);
2370    dependency = Promise.resolve(lightNode);
2371    parser.cache.add(cacheKey, dependency);
2372    return dependency;
2373  }
2374  getDependency(type, index) {
2375    if (type !== "light")
2376      return;
2377    return this._loadLight(index);
2378  }
2379  createNodeAttachment(nodeIndex) {
2380    const self2 = this;
2381    const parser = this.parser;
2382    const json = parser.json;
2383    const nodeDef = json.nodes[nodeIndex];
2384    const lightDef = nodeDef.extensions && nodeDef.extensions[this.name] || {};
2385    const lightIndex = lightDef.light;
2386    if (lightIndex === void 0)
2387      return null;
2388    return this._loadLight(lightIndex).then(function(light) {
2389      return parser._getNodeRef(self2.cache, lightIndex, light);
2390    });
2391  }
2392};
2393var GLTFMaterialsUnlitExtension = class {
2394  constructor() {
2395    this.name = EXTENSIONS.KHR_MATERIALS_UNLIT;
2396  }
2397  getMaterialType() {
2398    return MeshBasicMaterial;
2399  }
2400  extendParams(materialParams, materialDef, parser) {
2401    const pending = [];
2402    materialParams.color = new Color(1, 1, 1);
2403    materialParams.opacity = 1;
2404    const metallicRoughness = materialDef.pbrMetallicRoughness;
2405    if (metallicRoughness) {
2406      if (Array.isArray(metallicRoughness.baseColorFactor)) {
2407        const array = metallicRoughness.baseColorFactor;
2408        materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace2);
2409        materialParams.opacity = array[3];
2410      }
2411      if (metallicRoughness.baseColorTexture !== void 0) {
2412        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace2));
2413      }
2414    }
2415    return Promise.all(pending);
2416  }
2417};
2418var GLTFMaterialsEmissiveStrengthExtension = class {
2419  constructor(parser) {
2420    this.parser = parser;
2421    this.name = EXTENSIONS.KHR_MATERIALS_EMISSIVE_STRENGTH;
2422  }
2423  extendMaterialParams(materialIndex, materialParams) {
2424    const parser = this.parser;
2425    const materialDef = parser.json.materials[materialIndex];
2426    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2427      return Promise.resolve();
2428    }
2429    const emissiveStrength = materialDef.extensions[this.name].emissiveStrength;
2430    if (emissiveStrength !== void 0) {
2431      materialParams.emissiveIntensity = emissiveStrength;
2432    }
2433    return Promise.resolve();
2434  }
2435};
2436var GLTFMaterialsClearcoatExtension = class {
2437  constructor(parser) {
2438    this.parser = parser;
2439    this.name = EXTENSIONS.KHR_MATERIALS_CLEARCOAT;
2440  }
2441  getMaterialType(materialIndex) {
2442    const parser = this.parser;
2443    const materialDef = parser.json.materials[materialIndex];
2444    if (!materialDef.extensions || !materialDef.extensions[this.name])
2445      return null;
2446    return MeshPhysicalMaterial;
2447  }
2448  extendMaterialParams(materialIndex, materialParams) {
2449    const parser = this.parser;
2450    const materialDef = parser.json.materials[materialIndex];
2451    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2452      return Promise.resolve();
2453    }
2454    const pending = [];
2455    const extension = materialDef.extensions[this.name];
2456    if (extension.clearcoatFactor !== void 0) {
2457      materialParams.clearcoat = extension.clearcoatFactor;
2458    }
2459    if (extension.clearcoatTexture !== void 0) {
2460      pending.push(parser.assignTexture(materialParams, "clearcoatMap", extension.clearcoatTexture));
2461    }
2462    if (extension.clearcoatRoughnessFactor !== void 0) {
2463      materialParams.clearcoatRoughness = extension.clearcoatRoughnessFactor;
2464    }
2465    if (extension.clearcoatRoughnessTexture !== void 0) {
2466      pending.push(parser.assignTexture(materialParams, "clearcoatRoughnessMap", extension.clearcoatRoughnessTexture));
2467    }
2468    if (extension.clearcoatNormalTexture !== void 0) {
2469      pending.push(parser.assignTexture(materialParams, "clearcoatNormalMap", extension.clearcoatNormalTexture));
2470      if (extension.clearcoatNormalTexture.scale !== void 0) {
2471        const scale = extension.clearcoatNormalTexture.scale;
2472        materialParams.clearcoatNormalScale = new Vector2(scale, scale);
2473      }
2474    }
2475    return Promise.all(pending);
2476  }
2477};
2478var GLTFMaterialsDispersionExtension = class {
2479  constructor(parser) {
2480    this.parser = parser;
2481    this.name = EXTENSIONS.KHR_MATERIALS_DISPERSION;
2482  }
2483  getMaterialType(materialIndex) {
2484    const parser = this.parser;
2485    const materialDef = parser.json.materials[materialIndex];
2486    if (!materialDef.extensions || !materialDef.extensions[this.name])
2487      return null;
2488    return MeshPhysicalMaterial;
2489  }
2490  extendMaterialParams(materialIndex, materialParams) {
2491    const parser = this.parser;
2492    const materialDef = parser.json.materials[materialIndex];
2493    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2494      return Promise.resolve();
2495    }
2496    const extension = materialDef.extensions[this.name];
2497    materialParams.dispersion = extension.dispersion !== void 0 ? extension.dispersion : 0;
2498    return Promise.resolve();
2499  }
2500};
2501var GLTFMaterialsIridescenceExtension = class {
2502  constructor(parser) {
2503    this.parser = parser;
2504    this.name = EXTENSIONS.KHR_MATERIALS_IRIDESCENCE;
2505  }
2506  getMaterialType(materialIndex) {
2507    const parser = this.parser;
2508    const materialDef = parser.json.materials[materialIndex];
2509    if (!materialDef.extensions || !materialDef.extensions[this.name])
2510      return null;
2511    return MeshPhysicalMaterial;
2512  }
2513  extendMaterialParams(materialIndex, materialParams) {
2514    const parser = this.parser;
2515    const materialDef = parser.json.materials[materialIndex];
2516    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2517      return Promise.resolve();
2518    }
2519    const pending = [];
2520    const extension = materialDef.extensions[this.name];
2521    if (extension.iridescenceFactor !== void 0) {
2522      materialParams.iridescence = extension.iridescenceFactor;
2523    }
2524    if (extension.iridescenceTexture !== void 0) {
2525      pending.push(parser.assignTexture(materialParams, "iridescenceMap", extension.iridescenceTexture));
2526    }
2527    if (extension.iridescenceIor !== void 0) {
2528      materialParams.iridescenceIOR = extension.iridescenceIor;
2529    }
2530    if (materialParams.iridescenceThicknessRange === void 0) {
2531      materialParams.iridescenceThicknessRange = [100, 400];
2532    }
2533    if (extension.iridescenceThicknessMinimum !== void 0) {
2534      materialParams.iridescenceThicknessRange[0] = extension.iridescenceThicknessMinimum;
2535    }
2536    if (extension.iridescenceThicknessMaximum !== void 0) {
2537      materialParams.iridescenceThicknessRange[1] = extension.iridescenceThicknessMaximum;
2538    }
2539    if (extension.iridescenceThicknessTexture !== void 0) {
2540      pending.push(
2541        parser.assignTexture(materialParams, "iridescenceThicknessMap", extension.iridescenceThicknessTexture)
2542      );
2543    }
2544    return Promise.all(pending);
2545  }
2546};
2547var GLTFMaterialsSheenExtension = class {
2548  constructor(parser) {
2549    this.parser = parser;
2550    this.name = EXTENSIONS.KHR_MATERIALS_SHEEN;
2551  }
2552  getMaterialType(materialIndex) {
2553    const parser = this.parser;
2554    const materialDef = parser.json.materials[materialIndex];
2555    if (!materialDef.extensions || !materialDef.extensions[this.name])
2556      return null;
2557    return MeshPhysicalMaterial;
2558  }
2559  extendMaterialParams(materialIndex, materialParams) {
2560    const parser = this.parser;
2561    const materialDef = parser.json.materials[materialIndex];
2562    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2563      return Promise.resolve();
2564    }
2565    const pending = [];
2566    materialParams.sheenColor = new Color(0, 0, 0);
2567    materialParams.sheenRoughness = 0;
2568    materialParams.sheen = 1;
2569    const extension = materialDef.extensions[this.name];
2570    if (extension.sheenColorFactor !== void 0) {
2571      const colorFactor = extension.sheenColorFactor;
2572      materialParams.sheenColor.setRGB(colorFactor[0], colorFactor[1], colorFactor[2], LinearSRGBColorSpace2);
2573    }
2574    if (extension.sheenRoughnessFactor !== void 0) {
2575      materialParams.sheenRoughness = extension.sheenRoughnessFactor;
2576    }
2577    if (extension.sheenColorTexture !== void 0) {
2578      pending.push(parser.assignTexture(materialParams, "sheenColorMap", extension.sheenColorTexture, SRGBColorSpace2));
2579    }
2580    if (extension.sheenRoughnessTexture !== void 0) {
2581      pending.push(parser.assignTexture(materialParams, "sheenRoughnessMap", extension.sheenRoughnessTexture));
2582    }
2583    return Promise.all(pending);
2584  }
2585};
2586var GLTFMaterialsTransmissionExtension = class {
2587  constructor(parser) {
2588    this.parser = parser;
2589    this.name = EXTENSIONS.KHR_MATERIALS_TRANSMISSION;
2590  }
2591  getMaterialType(materialIndex) {
2592    const parser = this.parser;
2593    const materialDef = parser.json.materials[materialIndex];
2594    if (!materialDef.extensions || !materialDef.extensions[this.name])
2595      return null;
2596    return MeshPhysicalMaterial;
2597  }
2598  extendMaterialParams(materialIndex, materialParams) {
2599    const parser = this.parser;
2600    const materialDef = parser.json.materials[materialIndex];
2601    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2602      return Promise.resolve();
2603    }
2604    const pending = [];
2605    const extension = materialDef.extensions[this.name];
2606    if (extension.transmissionFactor !== void 0) {
2607      materialParams.transmission = extension.transmissionFactor;
2608    }
2609    if (extension.transmissionTexture !== void 0) {
2610      pending.push(parser.assignTexture(materialParams, "transmissionMap", extension.transmissionTexture));
2611    }
2612    return Promise.all(pending);
2613  }
2614};
2615var GLTFMaterialsVolumeExtension = class {
2616  constructor(parser) {
2617    this.parser = parser;
2618    this.name = EXTENSIONS.KHR_MATERIALS_VOLUME;
2619  }
2620  getMaterialType(materialIndex) {
2621    const parser = this.parser;
2622    const materialDef = parser.json.materials[materialIndex];
2623    if (!materialDef.extensions || !materialDef.extensions[this.name])
2624      return null;
2625    return MeshPhysicalMaterial;
2626  }
2627  extendMaterialParams(materialIndex, materialParams) {
2628    const parser = this.parser;
2629    const materialDef = parser.json.materials[materialIndex];
2630    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2631      return Promise.resolve();
2632    }
2633    const pending = [];
2634    const extension = materialDef.extensions[this.name];
2635    materialParams.thickness = extension.thicknessFactor !== void 0 ? extension.thicknessFactor : 0;
2636    if (extension.thicknessTexture !== void 0) {
2637      pending.push(parser.assignTexture(materialParams, "thicknessMap", extension.thicknessTexture));
2638    }
2639    materialParams.attenuationDistance = extension.attenuationDistance || Infinity;
2640    const colorArray = extension.attenuationColor || [1, 1, 1];
2641    materialParams.attenuationColor = new Color().setRGB(
2642      colorArray[0],
2643      colorArray[1],
2644      colorArray[2],
2645      LinearSRGBColorSpace2
2646    );
2647    return Promise.all(pending);
2648  }
2649};
2650var GLTFMaterialsIorExtension = class {
2651  constructor(parser) {
2652    this.parser = parser;
2653    this.name = EXTENSIONS.KHR_MATERIALS_IOR;
2654  }
2655  getMaterialType(materialIndex) {
2656    const parser = this.parser;
2657    const materialDef = parser.json.materials[materialIndex];
2658    if (!materialDef.extensions || !materialDef.extensions[this.name])
2659      return null;
2660    return MeshPhysicalMaterial;
2661  }
2662  extendMaterialParams(materialIndex, materialParams) {
2663    const parser = this.parser;
2664    const materialDef = parser.json.materials[materialIndex];
2665    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2666      return Promise.resolve();
2667    }
2668    const extension = materialDef.extensions[this.name];
2669    materialParams.ior = extension.ior !== void 0 ? extension.ior : 1.5;
2670    return Promise.resolve();
2671  }
2672};
2673var GLTFMaterialsSpecularExtension = class {
2674  constructor(parser) {
2675    this.parser = parser;
2676    this.name = EXTENSIONS.KHR_MATERIALS_SPECULAR;
2677  }
2678  getMaterialType(materialIndex) {
2679    const parser = this.parser;
2680    const materialDef = parser.json.materials[materialIndex];
2681    if (!materialDef.extensions || !materialDef.extensions[this.name])
2682      return null;
2683    return MeshPhysicalMaterial;
2684  }
2685  extendMaterialParams(materialIndex, materialParams) {
2686    const parser = this.parser;
2687    const materialDef = parser.json.materials[materialIndex];
2688    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2689      return Promise.resolve();
2690    }
2691    const pending = [];
2692    const extension = materialDef.extensions[this.name];
2693    materialParams.specularIntensity = extension.specularFactor !== void 0 ? extension.specularFactor : 1;
2694    if (extension.specularTexture !== void 0) {
2695      pending.push(parser.assignTexture(materialParams, "specularIntensityMap", extension.specularTexture));
2696    }
2697    const colorArray = extension.specularColorFactor || [1, 1, 1];
2698    materialParams.specularColor = new Color().setRGB(colorArray[0], colorArray[1], colorArray[2], LinearSRGBColorSpace2);
2699    if (extension.specularColorTexture !== void 0) {
2700      pending.push(
2701        parser.assignTexture(materialParams, "specularColorMap", extension.specularColorTexture, SRGBColorSpace2)
2702      );
2703    }
2704    return Promise.all(pending);
2705  }
2706};
2707var GLTFMaterialsBumpExtension = class {
2708  constructor(parser) {
2709    this.parser = parser;
2710    this.name = EXTENSIONS.EXT_MATERIALS_BUMP;
2711  }
2712  getMaterialType(materialIndex) {
2713    const parser = this.parser;
2714    const materialDef = parser.json.materials[materialIndex];
2715    if (!materialDef.extensions || !materialDef.extensions[this.name])
2716      return null;
2717    return MeshPhysicalMaterial;
2718  }
2719  extendMaterialParams(materialIndex, materialParams) {
2720    const parser = this.parser;
2721    const materialDef = parser.json.materials[materialIndex];
2722    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2723      return Promise.resolve();
2724    }
2725    const pending = [];
2726    const extension = materialDef.extensions[this.name];
2727    materialParams.bumpScale = extension.bumpFactor !== void 0 ? extension.bumpFactor : 1;
2728    if (extension.bumpTexture !== void 0) {
2729      pending.push(parser.assignTexture(materialParams, "bumpMap", extension.bumpTexture));
2730    }
2731    return Promise.all(pending);
2732  }
2733};
2734var GLTFMaterialsAnisotropyExtension = class {
2735  constructor(parser) {
2736    this.parser = parser;
2737    this.name = EXTENSIONS.KHR_MATERIALS_ANISOTROPY;
2738  }
2739  getMaterialType(materialIndex) {
2740    const parser = this.parser;
2741    const materialDef = parser.json.materials[materialIndex];
2742    if (!materialDef.extensions || !materialDef.extensions[this.name])
2743      return null;
2744    return MeshPhysicalMaterial;
2745  }
2746  extendMaterialParams(materialIndex, materialParams) {
2747    const parser = this.parser;
2748    const materialDef = parser.json.materials[materialIndex];
2749    if (!materialDef.extensions || !materialDef.extensions[this.name]) {
2750      return Promise.resolve();
2751    }
2752    const pending = [];
2753    const extension = materialDef.extensions[this.name];
2754    if (extension.anisotropyStrength !== void 0) {
2755      materialParams.anisotropy = extension.anisotropyStrength;
2756    }
2757    if (extension.anisotropyRotation !== void 0) {
2758      materialParams.anisotropyRotation = extension.anisotropyRotation;
2759    }
2760    if (extension.anisotropyTexture !== void 0) {
2761      pending.push(parser.assignTexture(materialParams, "anisotropyMap", extension.anisotropyTexture));
2762    }
2763    return Promise.all(pending);
2764  }
2765};
2766var GLTFTextureBasisUExtension = class {
2767  constructor(parser) {
2768    this.parser = parser;
2769    this.name = EXTENSIONS.KHR_TEXTURE_BASISU;
2770  }
2771  loadTexture(textureIndex) {
2772    const parser = this.parser;
2773    const json = parser.json;
2774    const textureDef = json.textures[textureIndex];
2775    if (!textureDef.extensions || !textureDef.extensions[this.name]) {
2776      return null;
2777    }
2778    const extension = textureDef.extensions[this.name];
2779    const loader = parser.options.ktx2Loader;
2780    if (!loader) {
2781      if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) {
2782        throw new Error("THREE.GLTFLoader: setKTX2Loader must be called before loading KTX2 textures");
2783      } else {
2784        return null;
2785      }
2786    }
2787    return parser.loadTextureImage(textureIndex, extension.source, loader);
2788  }
2789};
2790var GLTFTextureWebPExtension = class {
2791  constructor(parser) {
2792    this.parser = parser;
2793    this.name = EXTENSIONS.EXT_TEXTURE_WEBP;
2794    this.isSupported = null;
2795  }
2796  loadTexture(textureIndex) {
2797    const name = this.name;
2798    const parser = this.parser;
2799    const json = parser.json;
2800    const textureDef = json.textures[textureIndex];
2801    if (!textureDef.extensions || !textureDef.extensions[name]) {
2802      return null;
2803    }
2804    const extension = textureDef.extensions[name];
2805    const source = json.images[extension.source];
2806    let loader = parser.textureLoader;
2807    if (source.uri) {
2808      const handler = parser.options.manager.getHandler(source.uri);
2809      if (handler !== null)
2810        loader = handler;
2811    }
2812    return this.detectSupport().then(function(isSupported) {
2813      if (isSupported)
2814        return parser.loadTextureImage(textureIndex, extension.source, loader);
2815      if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) {
2816        throw new Error("THREE.GLTFLoader: WebP required by asset but unsupported.");
2817      }
2818      return parser.loadTexture(textureIndex);
2819    });
2820  }
2821  detectSupport() {
2822    if (!this.isSupported) {
2823      this.isSupported = new Promise(function(resolve3) {
2824        const image = new Image();
2825        image.src = "data:image/webp;base64,UklGRiIAAABXRUJQVlA4IBYAAAAwAQCdASoBAAEADsD+JaQAA3AAAAAA";
2826        image.onload = image.onerror = function() {
2827          resolve3(image.height === 1);
2828        };
2829      });
2830    }
2831    return this.isSupported;
2832  }
2833};
2834var GLTFTextureAVIFExtension = class {
2835  constructor(parser) {
2836    this.parser = parser;
2837    this.name = EXTENSIONS.EXT_TEXTURE_AVIF;
2838    this.isSupported = null;
2839  }
2840  loadTexture(textureIndex) {
2841    const name = this.name;
2842    const parser = this.parser;
2843    const json = parser.json;
2844    const textureDef = json.textures[textureIndex];
2845    if (!textureDef.extensions || !textureDef.extensions[name]) {
2846      return null;
2847    }
2848    const extension = textureDef.extensions[name];
2849    const source = json.images[extension.source];
2850    let loader = parser.textureLoader;
2851    if (source.uri) {
2852      const handler = parser.options.manager.getHandler(source.uri);
2853      if (handler !== null)
2854        loader = handler;
2855    }
2856    return this.detectSupport().then(function(isSupported) {
2857      if (isSupported)
2858        return parser.loadTextureImage(textureIndex, extension.source, loader);
2859      if (json.extensionsRequired && json.extensionsRequired.indexOf(name) >= 0) {
2860        throw new Error("THREE.GLTFLoader: AVIF required by asset but unsupported.");
2861      }
2862      return parser.loadTexture(textureIndex);
2863    });
2864  }
2865  detectSupport() {
2866    if (!this.isSupported) {
2867      this.isSupported = new Promise(function(resolve3) {
2868        const image = new Image();
2869        image.src = "data:image/avif;base64,AAAAIGZ0eXBhdmlmAAAAAGF2aWZtaWYxbWlhZk1BMUIAAADybWV0YQAAAAAAAAAoaGRscgAAAAAAAAAAcGljdAAAAAAAAAAAAAAAAGxpYmF2aWYAAAAADnBpdG0AAAAAAAEAAAAeaWxvYwAAAABEAAABAAEAAAABAAABGgAAABcAAAAoaWluZgAAAAAAAQAAABppbmZlAgAAAAABAABhdjAxQ29sb3IAAAAAamlwcnAAAABLaXBjbwAAABRpc3BlAAAAAAAAAAEAAAABAAAAEHBpeGkAAAAAAwgICAAAAAxhdjFDgQAMAAAAABNjb2xybmNseAACAAIABoAAAAAXaXBtYQAAAAAAAAABAAEEAQKDBAAAAB9tZGF0EgAKCBgABogQEDQgMgkQAAAAB8dSLfI=";
2870        image.onload = image.onerror = function() {
2871          resolve3(image.height === 1);
2872        };
2873      });
2874    }
2875    return this.isSupported;
2876  }
2877};
2878var GLTFMeshoptCompression = class {
2879  constructor(parser) {
2880    this.name = EXTENSIONS.EXT_MESHOPT_COMPRESSION;
2881    this.parser = parser;
2882  }
2883  loadBufferView(index) {
2884    const json = this.parser.json;
2885    const bufferView = json.bufferViews[index];
2886    if (bufferView.extensions && bufferView.extensions[this.name]) {
2887      const extensionDef = bufferView.extensions[this.name];
2888      const buffer = this.parser.getDependency("buffer", extensionDef.buffer);
2889      const decoder = this.parser.options.meshoptDecoder;
2890      if (!decoder || !decoder.supported) {
2891        if (json.extensionsRequired && json.extensionsRequired.indexOf(this.name) >= 0) {
2892          throw new Error("THREE.GLTFLoader: setMeshoptDecoder must be called before loading compressed files");
2893        } else {
2894          return null;
2895        }
2896      }
2897      return buffer.then(function(res) {
2898        const byteOffset = extensionDef.byteOffset || 0;
2899        const byteLength = extensionDef.byteLength || 0;
2900        const count = extensionDef.count;
2901        const stride = extensionDef.byteStride;
2902        const source = new Uint8Array(res, byteOffset, byteLength);
2903        if (decoder.decodeGltfBufferAsync) {
2904          return decoder.decodeGltfBufferAsync(count, stride, source, extensionDef.mode, extensionDef.filter).then(function(res2) {
2905            return res2.buffer;
2906          });
2907        } else {
2908          return decoder.ready.then(function() {
2909            const result = new ArrayBuffer(count * stride);
2910            decoder.decodeGltfBuffer(
2911              new Uint8Array(result),
2912              count,
2913              stride,
2914              source,
2915              extensionDef.mode,
2916              extensionDef.filter
2917            );
2918            return result;
2919          });
2920        }
2921      });
2922    } else {
2923      return null;
2924    }
2925  }
2926};
2927var GLTFMeshGpuInstancing = class {
2928  constructor(parser) {
2929    this.name = EXTENSIONS.EXT_MESH_GPU_INSTANCING;
2930    this.parser = parser;
2931  }
2932  createNodeMesh(nodeIndex) {
2933    const json = this.parser.json;
2934    const nodeDef = json.nodes[nodeIndex];
2935    if (!nodeDef.extensions || !nodeDef.extensions[this.name] || nodeDef.mesh === void 0) {
2936      return null;
2937    }
2938    const meshDef = json.meshes[nodeDef.mesh];
2939    for (const primitive of meshDef.primitives) {
2940      if (primitive.mode !== WEBGL_CONSTANTS.TRIANGLES && primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_STRIP && primitive.mode !== WEBGL_CONSTANTS.TRIANGLE_FAN && primitive.mode !== void 0) {
2941        return null;
2942      }
2943    }
2944    const extensionDef = nodeDef.extensions[this.name];
2945    const attributesDef = extensionDef.attributes;
2946    const pending = [];
2947    const attributes = {};
2948    for (const key in attributesDef) {
2949      pending.push(
2950        this.parser.getDependency("accessor", attributesDef[key]).then((accessor) => {
2951          attributes[key] = accessor;
2952          return attributes[key];
2953        })
2954      );
2955    }
2956    if (pending.length < 1) {
2957      return null;
2958    }
2959    pending.push(this.parser.createNodeMesh(nodeIndex));
2960    return Promise.all(pending).then((results) => {
2961      const nodeObject = results.pop();
2962      const meshes = nodeObject.isGroup ? nodeObject.children : [nodeObject];
2963      const count = results[0].count;
2964      const instancedMeshes = [];
2965      for (const mesh of meshes) {
2966        const m = new Matrix4();
2967        const p = new Vector3();
2968        const q = new Quaternion();
2969        const s = new Vector3(1, 1, 1);
2970        const instancedMesh = new InstancedMesh(mesh.geometry, mesh.material, count);
2971        for (let i = 0; i < count; i++) {
2972          if (attributes.TRANSLATION) {
2973            p.fromBufferAttribute(attributes.TRANSLATION, i);
2974          }
2975          if (attributes.ROTATION) {
2976            q.fromBufferAttribute(attributes.ROTATION, i);
2977          }
2978          if (attributes.SCALE) {
2979            s.fromBufferAttribute(attributes.SCALE, i);
2980          }
2981          instancedMesh.setMatrixAt(i, m.compose(p, q, s));
2982        }
2983        for (const attributeName in attributes) {
2984          if (attributeName === "_COLOR_0") {
2985            const attr = attributes[attributeName];
2986            instancedMesh.instanceColor = new InstancedBufferAttribute(attr.array, attr.itemSize, attr.normalized);
2987          } else if (attributeName !== "TRANSLATION" && attributeName !== "ROTATION" && attributeName !== "SCALE") {
2988            mesh.geometry.setAttribute(attributeName, attributes[attributeName]);
2989          }
2990        }
2991        Object3D.prototype.copy.call(instancedMesh, mesh);
2992        this.parser.assignFinalMaterial(instancedMesh);
2993        instancedMeshes.push(instancedMesh);
2994      }
2995      if (nodeObject.isGroup) {
2996        nodeObject.clear();
2997        nodeObject.add(...instancedMeshes);
2998        return nodeObject;
2999      }
3000      return instancedMeshes[0];
3001    });
3002  }
3003};
3004var BINARY_EXTENSION_HEADER_MAGIC = "glTF";
3005var BINARY_EXTENSION_HEADER_LENGTH = 12;
3006var BINARY_EXTENSION_CHUNK_TYPES = { JSON: 1313821514, BIN: 5130562 };
3007var GLTFBinaryExtension = class {
3008  constructor(data) {
3009    this.name = EXTENSIONS.KHR_BINARY_GLTF;
3010    this.content = null;
3011    this.body = null;
3012    const headerView = new DataView(data, 0, BINARY_EXTENSION_HEADER_LENGTH);
3013    this.header = {
3014      magic: decodeText(new Uint8Array(data.slice(0, 4))),
3015      version: headerView.getUint32(4, true),
3016      length: headerView.getUint32(8, true)
3017    };
3018    if (this.header.magic !== BINARY_EXTENSION_HEADER_MAGIC) {
3019      throw new Error("THREE.GLTFLoader: Unsupported glTF-Binary header.");
3020    } else if (this.header.version < 2) {
3021      throw new Error("THREE.GLTFLoader: Legacy binary file detected.");
3022    }
3023    const chunkContentsLength = this.header.length - BINARY_EXTENSION_HEADER_LENGTH;
3024    const chunkView = new DataView(data, BINARY_EXTENSION_HEADER_LENGTH);
3025    let chunkIndex = 0;
3026    while (chunkIndex < chunkContentsLength) {
3027      const chunkLength = chunkView.getUint32(chunkIndex, true);
3028      chunkIndex += 4;
3029      const chunkType = chunkView.getUint32(chunkIndex, true);
3030      chunkIndex += 4;
3031      if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.JSON) {
3032        const contentArray = new Uint8Array(data, BINARY_EXTENSION_HEADER_LENGTH + chunkIndex, chunkLength);
3033        this.content = decodeText(contentArray);
3034      } else if (chunkType === BINARY_EXTENSION_CHUNK_TYPES.BIN) {
3035        const byteOffset = BINARY_EXTENSION_HEADER_LENGTH + chunkIndex;
3036        this.body = data.slice(byteOffset, byteOffset + chunkLength);
3037      }
3038      chunkIndex += chunkLength;
3039    }
3040    if (this.content === null) {
3041      throw new Error("THREE.GLTFLoader: JSON content not found.");
3042    }
3043  }
3044};
3045var GLTFDracoMeshCompressionExtension = class {
3046  constructor(json, dracoLoader) {
3047    if (!dracoLoader) {
3048      throw new Error("THREE.GLTFLoader: No DRACOLoader instance provided.");
3049    }
3050    this.name = EXTENSIONS.KHR_DRACO_MESH_COMPRESSION;
3051    this.json = json;
3052    this.dracoLoader = dracoLoader;
3053    this.dracoLoader.preload();
3054  }
3055  decodePrimitive(primitive, parser) {
3056    const json = this.json;
3057    const dracoLoader = this.dracoLoader;
3058    const bufferViewIndex = primitive.extensions[this.name].bufferView;
3059    const gltfAttributeMap = primitive.extensions[this.name].attributes;
3060    const threeAttributeMap = {};
3061    const attributeNormalizedMap = {};
3062    const attributeTypeMap = {};
3063    for (const attributeName in gltfAttributeMap) {
3064      const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
3065      threeAttributeMap[threeAttributeName] = gltfAttributeMap[attributeName];
3066    }
3067    for (const attributeName in primitive.attributes) {
3068      const threeAttributeName = ATTRIBUTES[attributeName] || attributeName.toLowerCase();
3069      if (gltfAttributeMap[attributeName] !== void 0) {
3070        const accessorDef = json.accessors[primitive.attributes[attributeName]];
3071        const componentType = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
3072        attributeTypeMap[threeAttributeName] = componentType.name;
3073        attributeNormalizedMap[threeAttributeName] = accessorDef.normalized === true;
3074      }
3075    }
3076    return parser.getDependency("bufferView", bufferViewIndex).then(function(bufferView) {
3077      return new Promise(function(resolve3, reject) {
3078        dracoLoader.decodeDracoFile(
3079          bufferView,
3080          function(geometry) {
3081            for (const attributeName in geometry.attributes) {
3082              const attribute = geometry.attributes[attributeName];
3083              const normalized = attributeNormalizedMap[attributeName];
3084              if (normalized !== void 0)
3085                attribute.normalized = normalized;
3086            }
3087            resolve3(geometry);
3088          },
3089          threeAttributeMap,
3090          attributeTypeMap,
3091          LinearSRGBColorSpace2,
3092          reject
3093        );
3094      });
3095    });
3096  }
3097};
3098var GLTFTextureTransformExtension = class {
3099  constructor() {
3100    this.name = EXTENSIONS.KHR_TEXTURE_TRANSFORM;
3101  }
3102  extendTexture(texture, transform) {
3103    if ((transform.texCoord === void 0 || transform.texCoord === texture.channel) && transform.offset === void 0 && transform.rotation === void 0 && transform.scale === void 0) {
3104      return texture;
3105    }
3106    texture = texture.clone();
3107    if (transform.texCoord !== void 0) {
3108      texture.channel = transform.texCoord;
3109    }
3110    if (transform.offset !== void 0) {
3111      texture.offset.fromArray(transform.offset);
3112    }
3113    if (transform.rotation !== void 0) {
3114      texture.rotation = transform.rotation;
3115    }
3116    if (transform.scale !== void 0) {
3117      texture.repeat.fromArray(transform.scale);
3118    }
3119    texture.needsUpdate = true;
3120    return texture;
3121  }
3122};
3123var GLTFMeshQuantizationExtension = class {
3124  constructor() {
3125    this.name = EXTENSIONS.KHR_MESH_QUANTIZATION;
3126  }
3127};
3128var GLTFCubicSplineInterpolant = class extends Interpolant {
3129  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
3130    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
3131  }
3132  copySampleValue_(index) {
3133    const result = this.resultBuffer, values = this.sampleValues, valueSize = this.valueSize, offset = index * valueSize * 3 + valueSize;
3134    for (let i = 0; i !== valueSize; i++) {
3135      result[i] = values[offset + i];
3136    }
3137    return result;
3138  }
3139  interpolate_(i1, t0, t, t1) {
3140    const result = this.resultBuffer;
3141    const values = this.sampleValues;
3142    const stride = this.valueSize;
3143    const stride2 = stride * 2;
3144    const stride3 = stride * 3;
3145    const td = t1 - t0;
3146    const p = (t - t0) / td;
3147    const pp = p * p;
3148    const ppp = pp * p;
3149    const offset1 = i1 * stride3;
3150    const offset0 = offset1 - stride3;
3151    const s2 = -2 * ppp + 3 * pp;
3152    const s3 = ppp - pp;
3153    const s0 = 1 - s2;
3154    const s1 = s3 - pp + p;
3155    for (let i = 0; i !== stride; i++) {
3156      const p0 = values[offset0 + i + stride];
3157      const m0 = values[offset0 + i + stride2] * td;
3158      const p1 = values[offset1 + i + stride];
3159      const m1 = values[offset1 + i] * td;
3160      result[i] = s0 * p0 + s1 * m0 + s2 * p1 + s3 * m1;
3161    }
3162    return result;
3163  }
3164};
3165var _q = /* @__PURE__ */ new Quaternion();
3166var GLTFCubicSplineQuaternionInterpolant = class extends GLTFCubicSplineInterpolant {
3167  interpolate_(i1, t0, t, t1) {
3168    const result = super.interpolate_(i1, t0, t, t1);
3169    _q.fromArray(result).normalize().toArray(result);
3170    return result;
3171  }
3172};
3173var WEBGL_CONSTANTS = {
3174  FLOAT: 5126,
3175  //FLOAT_MAT2: 35674,
3176  FLOAT_MAT3: 35675,
3177  FLOAT_MAT4: 35676,
3178  FLOAT_VEC2: 35664,
3179  FLOAT_VEC3: 35665,
3180  FLOAT_VEC4: 35666,
3181  LINEAR: 9729,
3182  REPEAT: 10497,
3183  SAMPLER_2D: 35678,
3184  POINTS: 0,
3185  LINES: 1,
3186  LINE_LOOP: 2,
3187  LINE_STRIP: 3,
3188  TRIANGLES: 4,
3189  TRIANGLE_STRIP: 5,
3190  TRIANGLE_FAN: 6,
3191  UNSIGNED_BYTE: 5121,
3192  UNSIGNED_SHORT: 5123
3193};
3194var WEBGL_COMPONENT_TYPES = {
3195  5120: Int8Array,
3196  5121: Uint8Array,
3197  5122: Int16Array,
3198  5123: Uint16Array,
3199  5125: Uint32Array,
3200  5126: Float32Array
3201};
3202var WEBGL_FILTERS = {
3203  9728: NearestFilter,
3204  9729: LinearFilter,
3205  9984: NearestMipmapNearestFilter,
3206  9985: LinearMipmapNearestFilter,
3207  9986: NearestMipmapLinearFilter,
3208  9987: LinearMipmapLinearFilter
3209};
3210var WEBGL_WRAPPINGS = {
3211  33071: ClampToEdgeWrapping,
3212  33648: MirroredRepeatWrapping,
3213  10497: RepeatWrapping
3214};
3215var WEBGL_TYPE_SIZES = {
3216  SCALAR: 1,
3217  VEC2: 2,
3218  VEC3: 3,
3219  VEC4: 4,
3220  MAT2: 4,
3221  MAT3: 9,
3222  MAT4: 16
3223};
3224var ATTRIBUTES = {
3225  POSITION: "position",
3226  NORMAL: "normal",
3227  TANGENT: "tangent",
3228  // uv => uv1, 4 uv channels
3229  // https://github.com/mrdoob/three.js/pull/25943
3230  // https://github.com/mrdoob/three.js/pull/25788
3231  ...version >= 152 ? {
3232    TEXCOORD_0: "uv",
3233    TEXCOORD_1: "uv1",
3234    TEXCOORD_2: "uv2",
3235    TEXCOORD_3: "uv3"
3236  } : {
3237    TEXCOORD_0: "uv",
3238    TEXCOORD_1: "uv2"
3239  },
3240  COLOR_0: "color",
3241  WEIGHTS_0: "skinWeight",
3242  JOINTS_0: "skinIndex"
3243};
3244var PATH_PROPERTIES = {
3245  scale: "scale",
3246  translation: "position",
3247  rotation: "quaternion",
3248  weights: "morphTargetInfluences"
3249};
3250var INTERPOLATION = {
3251  CUBICSPLINE: void 0,
3252  // We use a custom interpolant (GLTFCubicSplineInterpolation) for CUBICSPLINE tracks. Each
3253  // keyframe track will be initialized with a default interpolation type, then modified.
3254  LINEAR: InterpolateLinear,
3255  STEP: InterpolateDiscrete
3256};
3257var ALPHA_MODES = {
3258  OPAQUE: "OPAQUE",
3259  MASK: "MASK",
3260  BLEND: "BLEND"
3261};
3262function createDefaultMaterial(cache) {
3263  if (cache["DefaultMaterial"] === void 0) {
3264    cache["DefaultMaterial"] = new MeshStandardMaterial({
3265      color: 16777215,
3266      emissive: 0,
3267      metalness: 1,
3268      roughness: 1,
3269      transparent: false,
3270      depthTest: true,
3271      side: FrontSide
3272    });
3273  }
3274  return cache["DefaultMaterial"];
3275}
3276function addUnknownExtensionsToUserData(knownExtensions, object, objectDef) {
3277  for (const name in objectDef.extensions) {
3278    if (knownExtensions[name] === void 0) {
3279      object.userData.gltfExtensions = object.userData.gltfExtensions || {};
3280      object.userData.gltfExtensions[name] = objectDef.extensions[name];
3281    }
3282  }
3283}
3284function assignExtrasToUserData(object, gltfDef) {
3285  if (gltfDef.extras !== void 0) {
3286    if (typeof gltfDef.extras === "object") {
3287      Object.assign(object.userData, gltfDef.extras);
3288    } else {
3289      console.warn("THREE.GLTFLoader: Ignoring primitive type .extras, " + gltfDef.extras);
3290    }
3291  }
3292}
3293function addMorphTargets(geometry, targets, parser) {
3294  let hasMorphPosition = false;
3295  let hasMorphNormal = false;
3296  let hasMorphColor = false;
3297  for (let i = 0, il = targets.length; i < il; i++) {
3298    const target = targets[i];
3299    if (target.POSITION !== void 0)
3300      hasMorphPosition = true;
3301    if (target.NORMAL !== void 0)
3302      hasMorphNormal = true;
3303    if (target.COLOR_0 !== void 0)
3304      hasMorphColor = true;
3305    if (hasMorphPosition && hasMorphNormal && hasMorphColor)
3306      break;
3307  }
3308  if (!hasMorphPosition && !hasMorphNormal && !hasMorphColor)
3309    return Promise.resolve(geometry);
3310  const pendingPositionAccessors = [];
3311  const pendingNormalAccessors = [];
3312  const pendingColorAccessors = [];
3313  for (let i = 0, il = targets.length; i < il; i++) {
3314    const target = targets[i];
3315    if (hasMorphPosition) {
3316      const pendingAccessor = target.POSITION !== void 0 ? parser.getDependency("accessor", target.POSITION) : geometry.attributes.position;
3317      pendingPositionAccessors.push(pendingAccessor);
3318    }
3319    if (hasMorphNormal) {
3320      const pendingAccessor = target.NORMAL !== void 0 ? parser.getDependency("accessor", target.NORMAL) : geometry.attributes.normal;
3321      pendingNormalAccessors.push(pendingAccessor);
3322    }
3323    if (hasMorphColor) {
3324      const pendingAccessor = target.COLOR_0 !== void 0 ? parser.getDependency("accessor", target.COLOR_0) : geometry.attributes.color;
3325      pendingColorAccessors.push(pendingAccessor);
3326    }
3327  }
3328  return Promise.all([
3329    Promise.all(pendingPositionAccessors),
3330    Promise.all(pendingNormalAccessors),
3331    Promise.all(pendingColorAccessors)
3332  ]).then(function(accessors) {
3333    const morphPositions = accessors[0];
3334    const morphNormals = accessors[1];
3335    const morphColors = accessors[2];
3336    if (hasMorphPosition)
3337      geometry.morphAttributes.position = morphPositions;
3338    if (hasMorphNormal)
3339      geometry.morphAttributes.normal = morphNormals;
3340    if (hasMorphColor)
3341      geometry.morphAttributes.color = morphColors;
3342    geometry.morphTargetsRelative = true;
3343    return geometry;
3344  });
3345}
3346function updateMorphTargets(mesh, meshDef) {
3347  mesh.updateMorphTargets();
3348  if (meshDef.weights !== void 0) {
3349    for (let i = 0, il = meshDef.weights.length; i < il; i++) {
3350      mesh.morphTargetInfluences[i] = meshDef.weights[i];
3351    }
3352  }
3353  if (meshDef.extras && Array.isArray(meshDef.extras.targetNames)) {
3354    const targetNames = meshDef.extras.targetNames;
3355    if (mesh.morphTargetInfluences.length === targetNames.length) {
3356      mesh.morphTargetDictionary = {};
3357      for (let i = 0, il = targetNames.length; i < il; i++) {
3358        mesh.morphTargetDictionary[targetNames[i]] = i;
3359      }
3360    } else {
3361      console.warn("THREE.GLTFLoader: Invalid extras.targetNames length. Ignoring names.");
3362    }
3363  }
3364}
3365function createPrimitiveKey(primitiveDef) {
3366  let geometryKey;
3367  const dracoExtension = primitiveDef.extensions && primitiveDef.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION];
3368  if (dracoExtension) {
3369    geometryKey = "draco:" + dracoExtension.bufferView + ":" + dracoExtension.indices + ":" + createAttributesKey(dracoExtension.attributes);
3370  } else {
3371    geometryKey = primitiveDef.indices + ":" + createAttributesKey(primitiveDef.attributes) + ":" + primitiveDef.mode;
3372  }
3373  if (primitiveDef.targets !== void 0) {
3374    for (let i = 0, il = primitiveDef.targets.length; i < il; i++) {
3375      geometryKey += ":" + createAttributesKey(primitiveDef.targets[i]);
3376    }
3377  }
3378  return geometryKey;
3379}
3380function createAttributesKey(attributes) {
3381  let attributesKey = "";
3382  const keys2 = Object.keys(attributes).sort();
3383  for (let i = 0, il = keys2.length; i < il; i++) {
3384    attributesKey += keys2[i] + ":" + attributes[keys2[i]] + ";";
3385  }
3386  return attributesKey;
3387}
3388function getNormalizedComponentScale(constructor) {
3389  switch (constructor) {
3390    case Int8Array:
3391      return 1 / 127;
3392    case Uint8Array:
3393      return 1 / 255;
3394    case Int16Array:
3395      return 1 / 32767;
3396    case Uint16Array:
3397      return 1 / 65535;
3398    default:
3399      throw new Error("THREE.GLTFLoader: Unsupported normalized accessor component type.");
3400  }
3401}
3402function getImageURIMimeType(uri) {
3403  if (uri.search(/\.jpe?g($|\?)/i) > 0 || uri.search(/^data\:image\/jpeg/) === 0)
3404    return "image/jpeg";
3405  if (uri.search(/\.webp($|\?)/i) > 0 || uri.search(/^data\:image\/webp/) === 0)
3406    return "image/webp";
3407  return "image/png";
3408}
3409var _identityMatrix = /* @__PURE__ */ new Matrix4();
3410var GLTFParser = class {
3411  constructor(json = {}, options = {}) {
3412    this.json = json;
3413    this.extensions = {};
3414    this.plugins = {};
3415    this.options = options;
3416    this.cache = new GLTFRegistry();
3417    this.associations = /* @__PURE__ */ new Map();
3418    this.primitiveCache = {};
3419    this.nodeCache = {};
3420    this.meshCache = { refs: {}, uses: {} };
3421    this.cameraCache = { refs: {}, uses: {} };
3422    this.lightCache = { refs: {}, uses: {} };
3423    this.sourceCache = {};
3424    this.textureCache = {};
3425    this.nodeNamesUsed = {};
3426    let isSafari = false;
3427    let isFirefox = false;
3428    let firefoxVersion = -1;
3429    if (typeof navigator !== "undefined" && typeof navigator.userAgent !== "undefined") {
3430      isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent) === true;
3431      isFirefox = navigator.userAgent.indexOf("Firefox") > -1;
3432      firefoxVersion = isFirefox ? navigator.userAgent.match(/Firefox\/([0-9]+)\./)[1] : -1;
3433    }
3434    if (typeof createImageBitmap === "undefined" || isSafari || isFirefox && firefoxVersion < 98) {
3435      this.textureLoader = new TextureLoader(this.options.manager);
3436    } else {
3437      this.textureLoader = new ImageBitmapLoader(this.options.manager);
3438    }
3439    this.textureLoader.setCrossOrigin(this.options.crossOrigin);
3440    this.textureLoader.setRequestHeader(this.options.requestHeader);
3441    this.fileLoader = new FileLoader(this.options.manager);
3442    this.fileLoader.setResponseType("arraybuffer");
3443    if (this.options.crossOrigin === "use-credentials") {
3444      this.fileLoader.setWithCredentials(true);
3445    }
3446  }
3447  setExtensions(extensions) {
3448    this.extensions = extensions;
3449  }
3450  setPlugins(plugins) {
3451    this.plugins = plugins;
3452  }
3453  parse(onLoad, onError) {
3454    const parser = this;
3455    const json = this.json;
3456    const extensions = this.extensions;
3457    this.cache.removeAll();
3458    this.nodeCache = {};
3459    this._invokeAll(function(ext) {
3460      return ext._markDefs && ext._markDefs();
3461    });
3462    Promise.all(
3463      this._invokeAll(function(ext) {
3464        return ext.beforeRoot && ext.beforeRoot();
3465      })
3466    ).then(function() {
3467      return Promise.all([
3468        parser.getDependencies("scene"),
3469        parser.getDependencies("animation"),
3470        parser.getDependencies("camera")
3471      ]);
3472    }).then(function(dependencies) {
3473      const result = {
3474        scene: dependencies[0][json.scene || 0],
3475        scenes: dependencies[0],
3476        animations: dependencies[1],
3477        cameras: dependencies[2],
3478        asset: json.asset,
3479        parser,
3480        userData: {}
3481      };
3482      addUnknownExtensionsToUserData(extensions, result, json);
3483      assignExtrasToUserData(result, json);
3484      return Promise.all(
3485        parser._invokeAll(function(ext) {
3486          return ext.afterRoot && ext.afterRoot(result);
3487        })
3488      ).then(function() {
3489        for (const scene of result.scenes) {
3490          scene.updateMatrixWorld();
3491        }
3492        onLoad(result);
3493      });
3494    }).catch(onError);
3495  }
3496  /**
3497   * Marks the special nodes/meshes in json for efficient parse.
3498   */
3499  _markDefs() {
3500    const nodeDefs = this.json.nodes || [];
3501    const skinDefs = this.json.skins || [];
3502    const meshDefs = this.json.meshes || [];
3503    for (let skinIndex = 0, skinLength = skinDefs.length; skinIndex < skinLength; skinIndex++) {
3504      const joints = skinDefs[skinIndex].joints;
3505      for (let i = 0, il = joints.length; i < il; i++) {
3506        nodeDefs[joints[i]].isBone = true;
3507      }
3508    }
3509    for (let nodeIndex = 0, nodeLength = nodeDefs.length; nodeIndex < nodeLength; nodeIndex++) {
3510      const nodeDef = nodeDefs[nodeIndex];
3511      if (nodeDef.mesh !== void 0) {
3512        this._addNodeRef(this.meshCache, nodeDef.mesh);
3513        if (nodeDef.skin !== void 0) {
3514          meshDefs[nodeDef.mesh].isSkinnedMesh = true;
3515        }
3516      }
3517      if (nodeDef.camera !== void 0) {
3518        this._addNodeRef(this.cameraCache, nodeDef.camera);
3519      }
3520    }
3521  }
3522  /**
3523   * Counts references to shared node / Object3D resources. These resources
3524   * can be reused, or "instantiated", at multiple nodes in the scene
3525   * hierarchy. Mesh, Camera, and Light instances are instantiated and must
3526   * be marked. Non-scenegraph resources (like Materials, Geometries, and
3527   * Textures) can be reused directly and are not marked here.
3528   *
3529   * Example: CesiumMilkTruck sample model reuses "Wheel" meshes.
3530   */
3531  _addNodeRef(cache, index) {
3532    if (index === void 0)
3533      return;
3534    if (cache.refs[index] === void 0) {
3535      cache.refs[index] = cache.uses[index] = 0;
3536    }
3537    cache.refs[index]++;
3538  }
3539  /** Returns a reference to a shared resource, cloning it if necessary. */
3540  _getNodeRef(cache, index, object) {
3541    if (cache.refs[index] <= 1)
3542      return object;
3543    const ref = object.clone();
3544    const updateMappings = (original, clone) => {
3545      const mappings = this.associations.get(original);
3546      if (mappings != null) {
3547        this.associations.set(clone, mappings);
3548      }
3549      for (const [i, child] of original.children.entries()) {
3550        updateMappings(child, clone.children[i]);
3551      }
3552    };
3553    updateMappings(object, ref);
3554    ref.name += "_instance_" + cache.uses[index]++;
3555    return ref;
3556  }
3557  _invokeOne(func) {
3558    const extensions = Object.values(this.plugins);
3559    extensions.push(this);
3560    for (let i = 0; i < extensions.length; i++) {
3561      const result = func(extensions[i]);
3562      if (result)
3563        return result;
3564    }
3565    return null;
3566  }
3567  _invokeAll(func) {
3568    const extensions = Object.values(this.plugins);
3569    extensions.unshift(this);
3570    const pending = [];
3571    for (let i = 0; i < extensions.length; i++) {
3572      const result = func(extensions[i]);
3573      if (result)
3574        pending.push(result);
3575    }
3576    return pending;
3577  }
3578  /**
3579   * Requests the specified dependency asynchronously, with caching.
3580   * @param {string} type
3581   * @param {number} index
3582   * @return {Promise<Object3D|Material|THREE.Texture|AnimationClip|ArrayBuffer|Object>}
3583   */
3584  getDependency(type, index) {
3585    const cacheKey = type + ":" + index;
3586    let dependency = this.cache.get(cacheKey);
3587    if (!dependency) {
3588      switch (type) {
3589        case "scene":
3590          dependency = this.loadScene(index);
3591          break;
3592        case "node":
3593          dependency = this._invokeOne(function(ext) {
3594            return ext.loadNode && ext.loadNode(index);
3595          });
3596          break;
3597        case "mesh":
3598          dependency = this._invokeOne(function(ext) {
3599            return ext.loadMesh && ext.loadMesh(index);
3600          });
3601          break;
3602        case "accessor":
3603          dependency = this.loadAccessor(index);
3604          break;
3605        case "bufferView":
3606          dependency = this._invokeOne(function(ext) {
3607            return ext.loadBufferView && ext.loadBufferView(index);
3608          });
3609          break;
3610        case "buffer":
3611          dependency = this.loadBuffer(index);
3612          break;
3613        case "material":
3614          dependency = this._invokeOne(function(ext) {
3615            return ext.loadMaterial && ext.loadMaterial(index);
3616          });
3617          break;
3618        case "texture":
3619          dependency = this._invokeOne(function(ext) {
3620            return ext.loadTexture && ext.loadTexture(index);
3621          });
3622          break;
3623        case "skin":
3624          dependency = this.loadSkin(index);
3625          break;
3626        case "animation":
3627          dependency = this._invokeOne(function(ext) {
3628            return ext.loadAnimation && ext.loadAnimation(index);
3629          });
3630          break;
3631        case "camera":
3632          dependency = this.loadCamera(index);
3633          break;
3634        default:
3635          dependency = this._invokeOne(function(ext) {
3636            return ext != this && ext.getDependency && ext.getDependency(type, index);
3637          });
3638          if (!dependency) {
3639            throw new Error("Unknown type: " + type);
3640          }
3641          break;
3642      }
3643      this.cache.add(cacheKey, dependency);
3644    }
3645    return dependency;
3646  }
3647  /**
3648   * Requests all dependencies of the specified type asynchronously, with caching.
3649   * @param {string} type
3650   * @return {Promise<Array<Object>>}
3651   */
3652  getDependencies(type) {
3653    let dependencies = this.cache.get(type);
3654    if (!dependencies) {
3655      const parser = this;
3656      const defs = this.json[type + (type === "mesh" ? "es" : "s")] || [];
3657      dependencies = Promise.all(
3658        defs.map(function(def, index) {
3659          return parser.getDependency(type, index);
3660        })
3661      );
3662      this.cache.add(type, dependencies);
3663    }
3664    return dependencies;
3665  }
3666  /**
3667   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
3668   * @param {number} bufferIndex
3669   * @return {Promise<ArrayBuffer>}
3670   */
3671  loadBuffer(bufferIndex) {
3672    const bufferDef = this.json.buffers[bufferIndex];
3673    const loader = this.fileLoader;
3674    if (bufferDef.type && bufferDef.type !== "arraybuffer") {
3675      throw new Error("THREE.GLTFLoader: " + bufferDef.type + " buffer type is not supported.");
3676    }
3677    if (bufferDef.uri === void 0 && bufferIndex === 0) {
3678      return Promise.resolve(this.extensions[EXTENSIONS.KHR_BINARY_GLTF].body);
3679    }
3680    const options = this.options;
3681    return new Promise(function(resolve3, reject) {
3682      loader.load(LoaderUtils.resolveURL(bufferDef.uri, options.path), resolve3, void 0, function() {
3683        reject(new Error('THREE.GLTFLoader: Failed to load buffer "' + bufferDef.uri + '".'));
3684      });
3685    });
3686  }
3687  /**
3688   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#buffers-and-buffer-views
3689   * @param {number} bufferViewIndex
3690   * @return {Promise<ArrayBuffer>}
3691   */
3692  loadBufferView(bufferViewIndex) {
3693    const bufferViewDef = this.json.bufferViews[bufferViewIndex];
3694    return this.getDependency("buffer", bufferViewDef.buffer).then(function(buffer) {
3695      const byteLength = bufferViewDef.byteLength || 0;
3696      const byteOffset = bufferViewDef.byteOffset || 0;
3697      return buffer.slice(byteOffset, byteOffset + byteLength);
3698    });
3699  }
3700  /**
3701   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#accessors
3702   * @param {number} accessorIndex
3703   * @return {Promise<BufferAttribute|InterleavedBufferAttribute>}
3704   */
3705  loadAccessor(accessorIndex) {
3706    const parser = this;
3707    const json = this.json;
3708    const accessorDef = this.json.accessors[accessorIndex];
3709    if (accessorDef.bufferView === void 0 && accessorDef.sparse === void 0) {
3710      const itemSize = WEBGL_TYPE_SIZES[accessorDef.type];
3711      const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
3712      const normalized = accessorDef.normalized === true;
3713      const array = new TypedArray(accessorDef.count * itemSize);
3714      return Promise.resolve(new BufferAttribute(array, itemSize, normalized));
3715    }
3716    const pendingBufferViews = [];
3717    if (accessorDef.bufferView !== void 0) {
3718      pendingBufferViews.push(this.getDependency("bufferView", accessorDef.bufferView));
3719    } else {
3720      pendingBufferViews.push(null);
3721    }
3722    if (accessorDef.sparse !== void 0) {
3723      pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.indices.bufferView));
3724      pendingBufferViews.push(this.getDependency("bufferView", accessorDef.sparse.values.bufferView));
3725    }
3726    return Promise.all(pendingBufferViews).then(function(bufferViews) {
3727      const bufferView = bufferViews[0];
3728      const itemSize = WEBGL_TYPE_SIZES[accessorDef.type];
3729      const TypedArray = WEBGL_COMPONENT_TYPES[accessorDef.componentType];
3730      const elementBytes = TypedArray.BYTES_PER_ELEMENT;
3731      const itemBytes = elementBytes * itemSize;
3732      const byteOffset = accessorDef.byteOffset || 0;
3733      const byteStride = accessorDef.bufferView !== void 0 ? json.bufferViews[accessorDef.bufferView].byteStride : void 0;
3734      const normalized = accessorDef.normalized === true;
3735      let array, bufferAttribute;
3736      if (byteStride && byteStride !== itemBytes) {
3737        const ibSlice = Math.floor(byteOffset / byteStride);
3738        const ibCacheKey = "InterleavedBuffer:" + accessorDef.bufferView + ":" + accessorDef.componentType + ":" + ibSlice + ":" + accessorDef.count;
3739        let ib = parser.cache.get(ibCacheKey);
3740        if (!ib) {
3741          array = new TypedArray(bufferView, ibSlice * byteStride, accessorDef.count * byteStride / elementBytes);
3742          ib = new InterleavedBuffer(array, byteStride / elementBytes);
3743          parser.cache.add(ibCacheKey, ib);
3744        }
3745        bufferAttribute = new InterleavedBufferAttribute(
3746          ib,
3747          itemSize,
3748          byteOffset % byteStride / elementBytes,
3749          normalized
3750        );
3751      } else {
3752        if (bufferView === null) {
3753          array = new TypedArray(accessorDef.count * itemSize);
3754        } else {
3755          array = new TypedArray(bufferView, byteOffset, accessorDef.count * itemSize);
3756        }
3757        bufferAttribute = new BufferAttribute(array, itemSize, normalized);
3758      }
3759      if (accessorDef.sparse !== void 0) {
3760        const itemSizeIndices = WEBGL_TYPE_SIZES.SCALAR;
3761        const TypedArrayIndices = WEBGL_COMPONENT_TYPES[accessorDef.sparse.indices.componentType];
3762        const byteOffsetIndices = accessorDef.sparse.indices.byteOffset || 0;
3763        const byteOffsetValues = accessorDef.sparse.values.byteOffset || 0;
3764        const sparseIndices = new TypedArrayIndices(
3765          bufferViews[1],
3766          byteOffsetIndices,
3767          accessorDef.sparse.count * itemSizeIndices
3768        );
3769        const sparseValues = new TypedArray(bufferViews[2], byteOffsetValues, accessorDef.sparse.count * itemSize);
3770        if (bufferView !== null) {
3771          bufferAttribute = new BufferAttribute(
3772            bufferAttribute.array.slice(),
3773            bufferAttribute.itemSize,
3774            bufferAttribute.normalized
3775          );
3776        }
3777        for (let i = 0, il = sparseIndices.length; i < il; i++) {
3778          const index = sparseIndices[i];
3779          bufferAttribute.setX(index, sparseValues[i * itemSize]);
3780          if (itemSize >= 2)
3781            bufferAttribute.setY(index, sparseValues[i * itemSize + 1]);
3782          if (itemSize >= 3)
3783            bufferAttribute.setZ(index, sparseValues[i * itemSize + 2]);
3784          if (itemSize >= 4)
3785            bufferAttribute.setW(index, sparseValues[i * itemSize + 3]);
3786          if (itemSize >= 5)
3787            throw new Error("THREE.GLTFLoader: Unsupported itemSize in sparse BufferAttribute.");
3788        }
3789      }
3790      return bufferAttribute;
3791    });
3792  }
3793  /**
3794   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#textures
3795   * @param {number} textureIndex
3796   * @return {Promise<THREE.Texture|null>}
3797   */
3798  loadTexture(textureIndex) {
3799    const json = this.json;
3800    const options = this.options;
3801    const textureDef = json.textures[textureIndex];
3802    const sourceIndex = textureDef.source;
3803    const sourceDef = json.images[sourceIndex];
3804    let loader = this.textureLoader;
3805    if (sourceDef.uri) {
3806      const handler = options.manager.getHandler(sourceDef.uri);
3807      if (handler !== null)
3808        loader = handler;
3809    }
3810    return this.loadTextureImage(textureIndex, sourceIndex, loader);
3811  }
3812  loadTextureImage(textureIndex, sourceIndex, loader) {
3813    const parser = this;
3814    const json = this.json;
3815    const textureDef = json.textures[textureIndex];
3816    const sourceDef = json.images[sourceIndex];
3817    const cacheKey = (sourceDef.uri || sourceDef.bufferView) + ":" + textureDef.sampler;
3818    if (this.textureCache[cacheKey]) {
3819      return this.textureCache[cacheKey];
3820    }
3821    const promise = this.loadImageSource(sourceIndex, loader).then(function(texture) {
3822      texture.flipY = false;
3823      texture.name = textureDef.name || sourceDef.name || "";
3824      if (texture.name === "" && typeof sourceDef.uri === "string" && sourceDef.uri.startsWith("data:image/") === false) {
3825        texture.name = sourceDef.uri;
3826      }
3827      const samplers = json.samplers || {};
3828      const sampler = samplers[textureDef.sampler] || {};
3829      texture.magFilter = WEBGL_FILTERS[sampler.magFilter] || LinearFilter;
3830      texture.minFilter = WEBGL_FILTERS[sampler.minFilter] || LinearMipmapLinearFilter;
3831      texture.wrapS = WEBGL_WRAPPINGS[sampler.wrapS] || RepeatWrapping;
3832      texture.wrapT = WEBGL_WRAPPINGS[sampler.wrapT] || RepeatWrapping;
3833      parser.associations.set(texture, { textures: textureIndex });
3834      return texture;
3835    }).catch(function() {
3836      return null;
3837    });
3838    this.textureCache[cacheKey] = promise;
3839    return promise;
3840  }
3841  loadImageSource(sourceIndex, loader) {
3842    const parser = this;
3843    const json = this.json;
3844    const options = this.options;
3845    if (this.sourceCache[sourceIndex] !== void 0) {
3846      return this.sourceCache[sourceIndex].then((texture) => texture.clone());
3847    }
3848    const sourceDef = json.images[sourceIndex];
3849    const URL2 = self.URL || self.webkitURL;
3850    let sourceURI = sourceDef.uri || "";
3851    let isObjectURL = false;
3852    if (sourceDef.bufferView !== void 0) {
3853      sourceURI = parser.getDependency("bufferView", sourceDef.bufferView).then(function(bufferView) {
3854        isObjectURL = true;
3855        const blob = new Blob([bufferView], { type: sourceDef.mimeType });
3856        sourceURI = URL2.createObjectURL(blob);
3857        return sourceURI;
3858      });
3859    } else if (sourceDef.uri === void 0) {
3860      throw new Error("THREE.GLTFLoader: Image " + sourceIndex + " is missing URI and bufferView");
3861    }
3862    const promise = Promise.resolve(sourceURI).then(function(sourceURI2) {
3863      return new Promise(function(resolve3, reject) {
3864        let onLoad = resolve3;
3865        if (loader.isImageBitmapLoader === true) {
3866          onLoad = function(imageBitmap) {
3867            const texture = new Texture(imageBitmap);
3868            texture.needsUpdate = true;
3869            resolve3(texture);
3870          };
3871        }
3872        loader.load(LoaderUtils.resolveURL(sourceURI2, options.path), onLoad, void 0, reject);
3873      });
3874    }).then(function(texture) {
3875      if (isObjectURL === true) {
3876        URL2.revokeObjectURL(sourceURI);
3877      }
3878      assignExtrasToUserData(texture, sourceDef);
3879      texture.userData.mimeType = sourceDef.mimeType || getImageURIMimeType(sourceDef.uri);
3880      return texture;
3881    }).catch(function(error) {
3882      console.error("THREE.GLTFLoader: Couldn't load texture", sourceURI);
3883      throw error;
3884    });
3885    this.sourceCache[sourceIndex] = promise;
3886    return promise;
3887  }
3888  /**
3889   * Asynchronously assigns a texture to the given material parameters.
3890   * @param {Object} materialParams
3891   * @param {string} mapName
3892   * @param {Object} mapDef
3893   * @return {Promise<Texture>}
3894   */
3895  assignTexture(materialParams, mapName, mapDef, colorSpace) {
3896    const parser = this;
3897    return this.getDependency("texture", mapDef.index).then(function(texture) {
3898      if (!texture)
3899        return null;
3900      if (mapDef.texCoord !== void 0 && mapDef.texCoord > 0) {
3901        texture = texture.clone();
3902        texture.channel = mapDef.texCoord;
3903      }
3904      if (parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM]) {
3905        const transform = mapDef.extensions !== void 0 ? mapDef.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM] : void 0;
3906        if (transform) {
3907          const gltfReference = parser.associations.get(texture);
3908          texture = parser.extensions[EXTENSIONS.KHR_TEXTURE_TRANSFORM].extendTexture(texture, transform);
3909          parser.associations.set(texture, gltfReference);
3910        }
3911      }
3912      if (colorSpace !== void 0) {
3913        if (typeof colorSpace === "number")
3914          colorSpace = colorSpace === sRGBEncoding ? SRGBColorSpace2 : LinearSRGBColorSpace2;
3915        if ("colorSpace" in texture)
3916          texture.colorSpace = colorSpace;
3917        else
3918          texture.encoding = colorSpace === SRGBColorSpace2 ? sRGBEncoding : LinearEncoding;
3919      }
3920      materialParams[mapName] = texture;
3921      return texture;
3922    });
3923  }
3924  /**
3925   * Assigns final material to a Mesh, Line, or Points instance. The instance
3926   * already has a material (generated from the glTF material options alone)
3927   * but reuse of the same glTF material may require multiple threejs materials
3928   * to accommodate different primitive types, defines, etc. New materials will
3929   * be created if necessary, and reused from a cache.
3930   * @param  {Object3D} mesh Mesh, Line, or Points instance.
3931   */
3932  assignFinalMaterial(mesh) {
3933    const geometry = mesh.geometry;
3934    let material = mesh.material;
3935    const useDerivativeTangents = geometry.attributes.tangent === void 0;
3936    const useVertexColors = geometry.attributes.color !== void 0;
3937    const useFlatShading = geometry.attributes.normal === void 0;
3938    if (mesh.isPoints) {
3939      const cacheKey = "PointsMaterial:" + material.uuid;
3940      let pointsMaterial = this.cache.get(cacheKey);
3941      if (!pointsMaterial) {
3942        pointsMaterial = new PointsMaterial();
3943        Material.prototype.copy.call(pointsMaterial, material);
3944        pointsMaterial.color.copy(material.color);
3945        pointsMaterial.map = material.map;
3946        pointsMaterial.sizeAttenuation = false;
3947        this.cache.add(cacheKey, pointsMaterial);
3948      }
3949      material = pointsMaterial;
3950    } else if (mesh.isLine) {
3951      const cacheKey = "LineBasicMaterial:" + material.uuid;
3952      let lineMaterial = this.cache.get(cacheKey);
3953      if (!lineMaterial) {
3954        lineMaterial = new LineBasicMaterial();
3955        Material.prototype.copy.call(lineMaterial, material);
3956        lineMaterial.color.copy(material.color);
3957        lineMaterial.map = material.map;
3958        this.cache.add(cacheKey, lineMaterial);
3959      }
3960      material = lineMaterial;
3961    }
3962    if (useDerivativeTangents || useVertexColors || useFlatShading) {
3963      let cacheKey = "ClonedMaterial:" + material.uuid + ":";
3964      if (useDerivativeTangents)
3965        cacheKey += "derivative-tangents:";
3966      if (useVertexColors)
3967        cacheKey += "vertex-colors:";
3968      if (useFlatShading)
3969        cacheKey += "flat-shading:";
3970      let cachedMaterial = this.cache.get(cacheKey);
3971      if (!cachedMaterial) {
3972        cachedMaterial = material.clone();
3973        if (useVertexColors)
3974          cachedMaterial.vertexColors = true;
3975        if (useFlatShading)
3976          cachedMaterial.flatShading = true;
3977        if (useDerivativeTangents) {
3978          if (cachedMaterial.normalScale)
3979            cachedMaterial.normalScale.y *= -1;
3980          if (cachedMaterial.clearcoatNormalScale)
3981            cachedMaterial.clearcoatNormalScale.y *= -1;
3982        }
3983        this.cache.add(cacheKey, cachedMaterial);
3984        this.associations.set(cachedMaterial, this.associations.get(material));
3985      }
3986      material = cachedMaterial;
3987    }
3988    mesh.material = material;
3989  }
3990  getMaterialType() {
3991    return MeshStandardMaterial;
3992  }
3993  /**
3994   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#materials
3995   * @param {number} materialIndex
3996   * @return {Promise<Material>}
3997   */
3998  loadMaterial(materialIndex) {
3999    const parser = this;
4000    const json = this.json;
4001    const extensions = this.extensions;
4002    const materialDef = json.materials[materialIndex];
4003    let materialType;
4004    const materialParams = {};
4005    const materialExtensions = materialDef.extensions || {};
4006    const pending = [];
4007    if (materialExtensions[EXTENSIONS.KHR_MATERIALS_UNLIT]) {
4008      const kmuExtension = extensions[EXTENSIONS.KHR_MATERIALS_UNLIT];
4009      materialType = kmuExtension.getMaterialType();
4010      pending.push(kmuExtension.extendParams(materialParams, materialDef, parser));
4011    } else {
4012      const metallicRoughness = materialDef.pbrMetallicRoughness || {};
4013      materialParams.color = new Color(1, 1, 1);
4014      materialParams.opacity = 1;
4015      if (Array.isArray(metallicRoughness.baseColorFactor)) {
4016        const array = metallicRoughness.baseColorFactor;
4017        materialParams.color.setRGB(array[0], array[1], array[2], LinearSRGBColorSpace2);
4018        materialParams.opacity = array[3];
4019      }
4020      if (metallicRoughness.baseColorTexture !== void 0) {
4021        pending.push(parser.assignTexture(materialParams, "map", metallicRoughness.baseColorTexture, SRGBColorSpace2));
4022      }
4023      materialParams.metalness = metallicRoughness.metallicFactor !== void 0 ? metallicRoughness.metallicFactor : 1;
4024      materialParams.roughness = metallicRoughness.roughnessFactor !== void 0 ? metallicRoughness.roughnessFactor : 1;
4025      if (metallicRoughness.metallicRoughnessTexture !== void 0) {
4026        pending.push(parser.assignTexture(materialParams, "metalnessMap", metallicRoughness.metallicRoughnessTexture));
4027        pending.push(parser.assignTexture(materialParams, "roughnessMap", metallicRoughness.metallicRoughnessTexture));
4028      }
4029      materialType = this._invokeOne(function(ext) {
4030        return ext.getMaterialType && ext.getMaterialType(materialIndex);
4031      });
4032      pending.push(
4033        Promise.all(
4034          this._invokeAll(function(ext) {
4035            return ext.extendMaterialParams && ext.extendMaterialParams(materialIndex, materialParams);
4036          })
4037        )
4038      );
4039    }
4040    if (materialDef.doubleSided === true) {
4041      materialParams.side = DoubleSide;
4042    }
4043    const alphaMode = materialDef.alphaMode || ALPHA_MODES.OPAQUE;
4044    if (alphaMode === ALPHA_MODES.BLEND) {
4045      materialParams.transparent = true;
4046      materialParams.depthWrite = false;
4047    } else {
4048      materialParams.transparent = false;
4049      if (alphaMode === ALPHA_MODES.MASK) {
4050        materialParams.alphaTest = materialDef.alphaCutoff !== void 0 ? materialDef.alphaCutoff : 0.5;
4051      }
4052    }
4053    if (materialDef.normalTexture !== void 0 && materialType !== MeshBasicMaterial) {
4054      pending.push(parser.assignTexture(materialParams, "normalMap", materialDef.normalTexture));
4055      materialParams.normalScale = new Vector2(1, 1);
4056      if (materialDef.normalTexture.scale !== void 0) {
4057        const scale = materialDef.normalTexture.scale;
4058        materialParams.normalScale.set(scale, scale);
4059      }
4060    }
4061    if (materialDef.occlusionTexture !== void 0 && materialType !== MeshBasicMaterial) {
4062      pending.push(parser.assignTexture(materialParams, "aoMap", materialDef.occlusionTexture));
4063      if (materialDef.occlusionTexture.strength !== void 0) {
4064        materialParams.aoMapIntensity = materialDef.occlusionTexture.strength;
4065      }
4066    }
4067    if (materialDef.emissiveFactor !== void 0 && materialType !== MeshBasicMaterial) {
4068      const emissiveFactor = materialDef.emissiveFactor;
4069      materialParams.emissive = new Color().setRGB(
4070        emissiveFactor[0],
4071        emissiveFactor[1],
4072        emissiveFactor[2],
4073        LinearSRGBColorSpace2
4074      );
4075    }
4076    if (materialDef.emissiveTexture !== void 0 && materialType !== MeshBasicMaterial) {
4077      pending.push(parser.assignTexture(materialParams, "emissiveMap", materialDef.emissiveTexture, SRGBColorSpace2));
4078    }
4079    return Promise.all(pending).then(function() {
4080      const material = new materialType(materialParams);
4081      if (materialDef.name)
4082        material.name = materialDef.name;
4083      assignExtrasToUserData(material, materialDef);
4084      parser.associations.set(material, { materials: materialIndex });
4085      if (materialDef.extensions)
4086        addUnknownExtensionsToUserData(extensions, material, materialDef);
4087      return material;
4088    });
4089  }
4090  /** When Object3D instances are targeted by animation, they need unique names. */
4091  createUniqueName(originalName) {
4092    const sanitizedName = PropertyBinding.sanitizeNodeName(originalName || "");
4093    if (sanitizedName in this.nodeNamesUsed) {
4094      return sanitizedName + "_" + ++this.nodeNamesUsed[sanitizedName];
4095    } else {
4096      this.nodeNamesUsed[sanitizedName] = 0;
4097      return sanitizedName;
4098    }
4099  }
4100  /**
4101   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#geometry
4102   *
4103   * Creates BufferGeometries from primitives.
4104   *
4105   * @param {Array<GLTF.Primitive>} primitives
4106   * @return {Promise<Array<BufferGeometry>>}
4107   */
4108  loadGeometries(primitives) {
4109    const parser = this;
4110    const extensions = this.extensions;
4111    const cache = this.primitiveCache;
4112    function createDracoPrimitive(primitive) {
4113      return extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION].decodePrimitive(primitive, parser).then(function(geometry) {
4114        return addPrimitiveAttributes(geometry, primitive, parser);
4115      });
4116    }
4117    const pending = [];
4118    for (let i = 0, il = primitives.length; i < il; i++) {
4119      const primitive = primitives[i];
4120      const cacheKey = createPrimitiveKey(primitive);
4121      const cached = cache[cacheKey];
4122      if (cached) {
4123        pending.push(cached.promise);
4124      } else {
4125        let geometryPromise;
4126        if (primitive.extensions && primitive.extensions[EXTENSIONS.KHR_DRACO_MESH_COMPRESSION]) {
4127          geometryPromise = createDracoPrimitive(primitive);
4128        } else {
4129          geometryPromise = addPrimitiveAttributes(new BufferGeometry(), primitive, parser);
4130        }
4131        cache[cacheKey] = { primitive, promise: geometryPromise };
4132        pending.push(geometryPromise);
4133      }
4134    }
4135    return Promise.all(pending);
4136  }
4137  /**
4138   * Specification: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/README.md#meshes
4139   * @param {number} meshIndex
4140   * @return {Promise<Group|Mesh|SkinnedMesh>}
4141   */
4142  loadMesh(meshIndex) {
4143    const parser = this;
4144    const json = this.json;
4145    const extensions = this.extensions;
4146    const meshDef = json.meshes[meshIndex];
4147    const primitives = meshDef.primitives;
4148    const pending = [];
4149    for (let i = 0, il = primitives.length; i < il; i++) {
4150      const material = primitives[i].material === void 0 ? createDefaultMaterial(this.cache) : this.getDependency("material", primitives[i].material);
4151      pending.push(material);
4152    }
4153    pending.push(parser.loadGeometries(primitives));
4154    return Promise.all(pending).then(function(results) {
4155      const materials = results.slice(0, results.length - 1);
4156      const geometries = results[results.length - 1];
4157      const meshes = [];
4158      for (let i = 0, il = geometries.length; i < il; i++) {
4159        const geometry = geometries[i];
4160        const primitive = primitives[i];
4161        let mesh;
4162        const material = materials[i];
4163        if (primitive.mode === WEBGL_CONSTANTS.TRIANGLES || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP || primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN || primitive.mode === void 0) {
4164          mesh = meshDef.isSkinnedMesh === true ? new SkinnedMesh(geometry, material) : new Mesh(geometry, material);
4165          if (mesh.isSkinnedMesh === true) {
4166            mesh.normalizeSkinWeights();
4167          }
4168          if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_STRIP) {
4169            mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleStripDrawMode);
4170          } else if (primitive.mode === WEBGL_CONSTANTS.TRIANGLE_FAN) {
4171            mesh.geometry = toTrianglesDrawMode(mesh.geometry, TriangleFanDrawMode);
4172          }
4173        } else if (primitive.mode === WEBGL_CONSTANTS.LINES) {
4174          mesh = new LineSegments(geometry, material);
4175        } else if (primitive.mode === WEBGL_CONSTANTS.LINE_STRIP) {
4176          mesh = new Line(geometry, material);
4177        } else if (primitive.mode === WEBGL_CONSTANTS.LINE_LOOP) {
4178          mesh = new LineLoop(geometry, material);
4179        } else if (primitive.mode === WEBGL_CONSTANTS.POINTS) {
4180          mesh = new Points(geometry, material);
4181        } else {
4182          throw new Error("THREE.GLTFLoader: Primitive mode unsupported: " + primitive.mode);
4183        }
4184        if (Object.keys(mesh.geometry.morphAttributes).length > 0) {
4185          updateMorphTargets(mesh, meshDef);
4186        }
4187        mesh.name = parser.createUniqueName(meshDef.name || "mesh_" + meshIndex);
4188        assignExtrasToUserData(mesh, meshDef);
4189        if (primitive.extensions)
4190          addUnknownExtensionsToUserData(extensions, mesh, primitive);
4191        parser.assignFinalMaterial(mesh);
4192        meshes.push(mesh);
4193      }
4194      for (let i = 0, il = meshes.length; i < il; i++) {
4195        parser.associations.set(meshes[i], {
4196          meshes: meshIndex,
4197          primitives: i
4198        });
4199      }
4200      if (meshes.length === 1) {
4201        if (meshDef.extensions)
4202          addUnknownExtensionsToUserData(extensions, meshes[0], meshDef);
4203        return meshes[0];
4204      }
4205      const group = new Group();
4206      if (meshDef.extensions)
4207        addUnknownExtensionsToUserData(extensions, group, meshDef);
4208      parser.associations.set(group, { meshes: meshIndex });
4209      for (let i = 0, il = meshes.length; i < il; i++) {
4210        group.add(meshes[i]);
4211      }
4212      return group;
4213    });
4214  }
4215  /**
4216   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#cameras
4217   * @param {number} cameraIndex
4218   * @return {Promise<THREE.Camera>}
4219   */
4220  loadCamera(cameraIndex) {
4221    let camera;
4222    const cameraDef = this.json.cameras[cameraIndex];
4223    const params = cameraDef[cameraDef.type];
4224    if (!params) {
4225      console.warn("THREE.GLTFLoader: Missing camera parameters.");
4226      return;
4227    }
4228    if (cameraDef.type === "perspective") {
4229      camera = new PerspectiveCamera(
4230        MathUtils.radToDeg(params.yfov),
4231        params.aspectRatio || 1,
4232        params.znear || 1,
4233        params.zfar || 2e6
4234      );
4235    } else if (cameraDef.type === "orthographic") {
4236      camera = new OrthographicCamera(-params.xmag, params.xmag, params.ymag, -params.ymag, params.znear, params.zfar);
4237    }
4238    if (cameraDef.name)
4239      camera.name = this.createUniqueName(cameraDef.name);
4240    assignExtrasToUserData(camera, cameraDef);
4241    return Promise.resolve(camera);
4242  }
4243  /**
4244   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#skins
4245   * @param {number} skinIndex
4246   * @return {Promise<Skeleton>}
4247   */
4248  loadSkin(skinIndex) {
4249    const skinDef = this.json.skins[skinIndex];
4250    const pending = [];
4251    for (let i = 0, il = skinDef.joints.length; i < il; i++) {
4252      pending.push(this._loadNodeShallow(skinDef.joints[i]));
4253    }
4254    if (skinDef.inverseBindMatrices !== void 0) {
4255      pending.push(this.getDependency("accessor", skinDef.inverseBindMatrices));
4256    } else {
4257      pending.push(null);
4258    }
4259    return Promise.all(pending).then(function(results) {
4260      const inverseBindMatrices = results.pop();
4261      const jointNodes = results;
4262      const bones = [];
4263      const boneInverses = [];
4264      for (let i = 0, il = jointNodes.length; i < il; i++) {
4265        const jointNode = jointNodes[i];
4266        if (jointNode) {
4267          bones.push(jointNode);
4268          const mat = new Matrix4();
4269          if (inverseBindMatrices !== null) {
4270            mat.fromArray(inverseBindMatrices.array, i * 16);
4271          }
4272          boneInverses.push(mat);
4273        } else {
4274          console.warn('THREE.GLTFLoader: Joint "%s" could not be found.', skinDef.joints[i]);
4275        }
4276      }
4277      return new Skeleton(bones, boneInverses);
4278    });
4279  }
4280  /**
4281   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#animations
4282   * @param {number} animationIndex
4283   * @return {Promise<AnimationClip>}
4284   */
4285  loadAnimation(animationIndex) {
4286    const json = this.json;
4287    const parser = this;
4288    const animationDef = json.animations[animationIndex];
4289    const animationName = animationDef.name ? animationDef.name : "animation_" + animationIndex;
4290    const pendingNodes = [];
4291    const pendingInputAccessors = [];
4292    const pendingOutputAccessors = [];
4293    const pendingSamplers = [];
4294    const pendingTargets = [];
4295    for (let i = 0, il = animationDef.channels.length; i < il; i++) {
4296      const channel = animationDef.channels[i];
4297      const sampler = animationDef.samplers[channel.sampler];
4298      const target = channel.target;
4299      const name = target.node;
4300      const input = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.input] : sampler.input;
4301      const output = animationDef.parameters !== void 0 ? animationDef.parameters[sampler.output] : sampler.output;
4302      if (target.node === void 0)
4303        continue;
4304      pendingNodes.push(this.getDependency("node", name));
4305      pendingInputAccessors.push(this.getDependency("accessor", input));
4306      pendingOutputAccessors.push(this.getDependency("accessor", output));
4307      pendingSamplers.push(sampler);
4308      pendingTargets.push(target);
4309    }
4310    return Promise.all([
4311      Promise.all(pendingNodes),
4312      Promise.all(pendingInputAccessors),
4313      Promise.all(pendingOutputAccessors),
4314      Promise.all(pendingSamplers),
4315      Promise.all(pendingTargets)
4316    ]).then(function(dependencies) {
4317      const nodes = dependencies[0];
4318      const inputAccessors = dependencies[1];
4319      const outputAccessors = dependencies[2];
4320      const samplers = dependencies[3];
4321      const targets = dependencies[4];
4322      const tracks = [];
4323      for (let i = 0, il = nodes.length; i < il; i++) {
4324        const node = nodes[i];
4325        const inputAccessor = inputAccessors[i];
4326        const outputAccessor = outputAccessors[i];
4327        const sampler = samplers[i];
4328        const target = targets[i];
4329        if (node === void 0)
4330          continue;
4331        if (node.updateMatrix) {
4332          node.updateMatrix();
4333        }
4334        const createdTracks = parser._createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target);
4335        if (createdTracks) {
4336          for (let k = 0; k < createdTracks.length; k++) {
4337            tracks.push(createdTracks[k]);
4338          }
4339        }
4340      }
4341      return new AnimationClip(animationName, void 0, tracks);
4342    });
4343  }
4344  createNodeMesh(nodeIndex) {
4345    const json = this.json;
4346    const parser = this;
4347    const nodeDef = json.nodes[nodeIndex];
4348    if (nodeDef.mesh === void 0)
4349      return null;
4350    return parser.getDependency("mesh", nodeDef.mesh).then(function(mesh) {
4351      const node = parser._getNodeRef(parser.meshCache, nodeDef.mesh, mesh);
4352      if (nodeDef.weights !== void 0) {
4353        node.traverse(function(o) {
4354          if (!o.isMesh)
4355            return;
4356          for (let i = 0, il = nodeDef.weights.length; i < il; i++) {
4357            o.morphTargetInfluences[i] = nodeDef.weights[i];
4358          }
4359        });
4360      }
4361      return node;
4362    });
4363  }
4364  /**
4365   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#nodes-and-hierarchy
4366   * @param {number} nodeIndex
4367   * @return {Promise<Object3D>}
4368   */
4369  loadNode(nodeIndex) {
4370    const json = this.json;
4371    const parser = this;
4372    const nodeDef = json.nodes[nodeIndex];
4373    const nodePending = parser._loadNodeShallow(nodeIndex);
4374    const childPending = [];
4375    const childrenDef = nodeDef.children || [];
4376    for (let i = 0, il = childrenDef.length; i < il; i++) {
4377      childPending.push(parser.getDependency("node", childrenDef[i]));
4378    }
4379    const skeletonPending = nodeDef.skin === void 0 ? Promise.resolve(null) : parser.getDependency("skin", nodeDef.skin);
4380    return Promise.all([nodePending, Promise.all(childPending), skeletonPending]).then(function(results) {
4381      const node = results[0];
4382      const children2 = results[1];
4383      const skeleton = results[2];
4384      if (skeleton !== null) {
4385        node.traverse(function(mesh) {
4386          if (!mesh.isSkinnedMesh)
4387            return;
4388          mesh.bind(skeleton, _identityMatrix);
4389        });
4390      }
4391      for (let i = 0, il = children2.length; i < il; i++) {
4392        node.add(children2[i]);
4393      }
4394      return node;
4395    });
4396  }
4397  // ._loadNodeShallow() parses a single node.
4398  // skin and child nodes are created and added in .loadNode() (no '_' prefix).
4399  _loadNodeShallow(nodeIndex) {
4400    const json = this.json;
4401    const extensions = this.extensions;
4402    const parser = this;
4403    if (this.nodeCache[nodeIndex] !== void 0) {
4404      return this.nodeCache[nodeIndex];
4405    }
4406    const nodeDef = json.nodes[nodeIndex];
4407    const nodeName = nodeDef.name ? parser.createUniqueName(nodeDef.name) : "";
4408    const pending = [];
4409    const meshPromise = parser._invokeOne(function(ext) {
4410      return ext.createNodeMesh && ext.createNodeMesh(nodeIndex);
4411    });
4412    if (meshPromise) {
4413      pending.push(meshPromise);
4414    }
4415    if (nodeDef.camera !== void 0) {
4416      pending.push(
4417        parser.getDependency("camera", nodeDef.camera).then(function(camera) {
4418          return parser._getNodeRef(parser.cameraCache, nodeDef.camera, camera);
4419        })
4420      );
4421    }
4422    parser._invokeAll(function(ext) {
4423      return ext.createNodeAttachment && ext.createNodeAttachment(nodeIndex);
4424    }).forEach(function(promise) {
4425      pending.push(promise);
4426    });
4427    this.nodeCache[nodeIndex] = Promise.all(pending).then(function(objects) {
4428      let node;
4429      if (nodeDef.isBone === true) {
4430        node = new Bone();
4431      } else if (objects.length > 1) {
4432        node = new Group();
4433      } else if (objects.length === 1) {
4434        node = objects[0];
4435      } else {
4436        node = new Object3D();
4437      }
4438      if (node !== objects[0]) {
4439        for (let i = 0, il = objects.length; i < il; i++) {
4440          node.add(objects[i]);
4441        }
4442      }
4443      if (nodeDef.name) {
4444        node.userData.name = nodeDef.name;
4445        node.name = nodeName;
4446      }
4447      assignExtrasToUserData(node, nodeDef);
4448      if (nodeDef.extensions)
4449        addUnknownExtensionsToUserData(extensions, node, nodeDef);
4450      if (nodeDef.matrix !== void 0) {
4451        const matrix = new Matrix4();
4452        matrix.fromArray(nodeDef.matrix);
4453        node.applyMatrix4(matrix);
4454      } else {
4455        if (nodeDef.translation !== void 0) {
4456          node.position.fromArray(nodeDef.translation);
4457        }
4458        if (nodeDef.rotation !== void 0) {
4459          node.quaternion.fromArray(nodeDef.rotation);
4460        }
4461        if (nodeDef.scale !== void 0) {
4462          node.scale.fromArray(nodeDef.scale);
4463        }
4464      }
4465      if (!parser.associations.has(node)) {
4466        parser.associations.set(node, {});
4467      }
4468      parser.associations.get(node).nodes = nodeIndex;
4469      return node;
4470    });
4471    return this.nodeCache[nodeIndex];
4472  }
4473  /**
4474   * Specification: https://github.com/KhronosGroup/glTF/tree/master/specification/2.0#scenes
4475   * @param {number} sceneIndex
4476   * @return {Promise<Group>}
4477   */
4478  loadScene(sceneIndex) {
4479    const extensions = this.extensions;
4480    const sceneDef = this.json.scenes[sceneIndex];
4481    const parser = this;
4482    const scene = new Group();
4483    if (sceneDef.name)
4484      scene.name = parser.createUniqueName(sceneDef.name);
4485    assignExtrasToUserData(scene, sceneDef);
4486    if (sceneDef.extensions)
4487      addUnknownExtensionsToUserData(extensions, scene, sceneDef);
4488    const nodeIds = sceneDef.nodes || [];
4489    const pending = [];
4490    for (let i = 0, il = nodeIds.length; i < il; i++) {
4491      pending.push(parser.getDependency("node", nodeIds[i]));
4492    }
4493    return Promise.all(pending).then(function(nodes) {
4494      for (let i = 0, il = nodes.length; i < il; i++) {
4495        scene.add(nodes[i]);
4496      }
4497      const reduceAssociations = (node) => {
4498        const reducedAssociations = /* @__PURE__ */ new Map();
4499        for (const [key, value] of parser.associations) {
4500          if (key instanceof Material || key instanceof Texture) {
4501            reducedAssociations.set(key, value);
4502          }
4503        }
4504        node.traverse((node2) => {
4505          const mappings = parser.associations.get(node2);
4506          if (mappings != null) {
4507            reducedAssociations.set(node2, mappings);
4508          }
4509        });
4510        return reducedAssociations;
4511      };
4512      parser.associations = reduceAssociations(scene);
4513      return scene;
4514    });
4515  }
4516  _createAnimationTracks(node, inputAccessor, outputAccessor, sampler, target) {
4517    const tracks = [];
4518    const targetName = node.name ? node.name : node.uuid;
4519    const targetNames = [];
4520    if (PATH_PROPERTIES[target.path] === PATH_PROPERTIES.weights) {
4521      node.traverse(function(object) {
4522        if (object.morphTargetInfluences) {
4523          targetNames.push(object.name ? object.name : object.uuid);
4524        }
4525      });
4526    } else {
4527      targetNames.push(targetName);
4528    }
4529    let TypedKeyframeTrack;
4530    switch (PATH_PROPERTIES[target.path]) {
4531      case PATH_PROPERTIES.weights:
4532        TypedKeyframeTrack = NumberKeyframeTrack;
4533        break;
4534      case PATH_PROPERTIES.rotation:
4535        TypedKeyframeTrack = QuaternionKeyframeTrack;
4536        break;
4537      case PATH_PROPERTIES.position:
4538      case PATH_PROPERTIES.scale:
4539        TypedKeyframeTrack = VectorKeyframeTrack;
4540        break;
4541      default:
4542        switch (outputAccessor.itemSize) {
4543          case 1:
4544            TypedKeyframeTrack = NumberKeyframeTrack;
4545            break;
4546          case 2:
4547          case 3:
4548          default:
4549            TypedKeyframeTrack = VectorKeyframeTrack;
4550            break;
4551        }
4552        break;
4553    }
4554    const interpolation = sampler.interpolation !== void 0 ? INTERPOLATION[sampler.interpolation] : InterpolateLinear;
4555    const outputArray = this._getArrayFromAccessor(outputAccessor);
4556    for (let j = 0, jl = targetNames.length; j < jl; j++) {
4557      const track = new TypedKeyframeTrack(
4558        targetNames[j] + "." + PATH_PROPERTIES[target.path],
4559        inputAccessor.array,
4560        outputArray,
4561        interpolation
4562      );
4563      if (sampler.interpolation === "CUBICSPLINE") {
4564        this._createCubicSplineTrackInterpolant(track);
4565      }
4566      tracks.push(track);
4567    }
4568    return tracks;
4569  }
4570  _getArrayFromAccessor(accessor) {
4571    let outputArray = accessor.array;
4572    if (accessor.normalized) {
4573      const scale = getNormalizedComponentScale(outputArray.constructor);
4574      const scaled = new Float32Array(outputArray.length);
4575      for (let j = 0, jl = outputArray.length; j < jl; j++) {
4576        scaled[j] = outputArray[j] * scale;
4577      }
4578      outputArray = scaled;
4579    }
4580    return outputArray;
4581  }
4582  _createCubicSplineTrackInterpolant(track) {
4583    track.createInterpolant = function InterpolantFactoryMethodGLTFCubicSpline(result) {
4584      const interpolantType = this instanceof QuaternionKeyframeTrack ? GLTFCubicSplineQuaternionInterpolant : GLTFCubicSplineInterpolant;
4585      return new interpolantType(this.times, this.values, this.getValueSize() / 3, result);
4586    };
4587    track.createInterpolant.isInterpolantFactoryMethodGLTFCubicSpline = true;
4588  }
4589};
4590function computeBounds(geometry, primitiveDef, parser) {
4591  const attributes = primitiveDef.attributes;
4592  const box = new Box3();
4593  if (attributes.POSITION !== void 0) {
4594    const accessor = parser.json.accessors[attributes.POSITION];
4595    const min = accessor.min;
4596    const max = accessor.max;
4597    if (min !== void 0 && max !== void 0) {
4598      box.set(new Vector3(min[0], min[1], min[2]), new Vector3(max[0], max[1], max[2]));
4599      if (accessor.normalized) {
4600        const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]);
4601        box.min.multiplyScalar(boxScale);
4602        box.max.multiplyScalar(boxScale);
4603      }
4604    } else {
4605      console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
4606      return;
4607    }
4608  } else {
4609    return;
4610  }
4611  const targets = primitiveDef.targets;
4612  if (targets !== void 0) {
4613    const maxDisplacement = new Vector3();
4614    const vector = new Vector3();
4615    for (let i = 0, il = targets.length; i < il; i++) {
4616      const target = targets[i];
4617      if (target.POSITION !== void 0) {
4618        const accessor = parser.json.accessors[target.POSITION];
4619        const min = accessor.min;
4620        const max = accessor.max;
4621        if (min !== void 0 && max !== void 0) {
4622          vector.setX(Math.max(Math.abs(min[0]), Math.abs(max[0])));
4623          vector.setY(Math.max(Math.abs(min[1]), Math.abs(max[1])));
4624          vector.setZ(Math.max(Math.abs(min[2]), Math.abs(max[2])));
4625          if (accessor.normalized) {
4626            const boxScale = getNormalizedComponentScale(WEBGL_COMPONENT_TYPES[accessor.componentType]);
4627            vector.multiplyScalar(boxScale);
4628          }
4629          maxDisplacement.max(vector);
4630        } else {
4631          console.warn("THREE.GLTFLoader: Missing min/max properties for accessor POSITION.");
4632        }
4633      }
4634    }
4635    box.expandByVector(maxDisplacement);
4636  }
4637  geometry.boundingBox = box;
4638  const sphere = new Sphere();
4639  box.getCenter(sphere.center);
4640  sphere.radius = box.min.distanceTo(box.max) / 2;
4641  geometry.boundingSphere = sphere;
4642}
4643function addPrimitiveAttributes(geometry, primitiveDef, parser) {
4644  const attributes = primitiveDef.attributes;
4645  const pending = [];
4646  function assignAttributeAccessor(accessorIndex, attributeName) {
4647    return parser.getDependency("accessor", accessorIndex).then(function(accessor) {
4648      geometry.setAttribute(attributeName, accessor);
4649    });
4650  }
4651  for (const gltfAttributeName in attributes) {
4652    const threeAttributeName = ATTRIBUTES[gltfAttributeName] || gltfAttributeName.toLowerCase();
4653    if (threeAttributeName in geometry.attributes)
4654      continue;
4655    pending.push(assignAttributeAccessor(attributes[gltfAttributeName], threeAttributeName));
4656  }
4657  if (primitiveDef.indices !== void 0 && !geometry.index) {
4658    const accessor = parser.getDependency("accessor", primitiveDef.indices).then(function(accessor2) {
4659      geometry.setIndex(accessor2);
4660    });
4661    pending.push(accessor);
4662  }
4663  assignExtrasToUserData(geometry, primitiveDef);
4664  computeBounds(geometry, primitiveDef, parser);
4665  return Promise.all(pending).then(function() {
4666    return primitiveDef.targets !== void 0 ? addMorphTargets(geometry, primitiveDef.targets, parser) : geometry;
4667  });
4668}
4669