roavatar-renderer 1.5.15 → 1.5.16

package/dist/index.js

@@ -1117,6 +1117,11 @@ const RED_GREEN_RGTC2_Format = 36285;
 const SIGNED_RED_GREEN_RGTC2_Format = 36286;
 const InterpolateDiscrete = 2300;
 const InterpolateLinear = 2301;
+const InterpolateSmooth = 2302;
+const ZeroCurvatureEnding = 2400;
+const ZeroSlopeEnding = 2401;
+const WrapAroundEnding = 2402;
+const NormalAnimationBlendMode = 2500;
 const BasicDepthPacking = 3200;
 const RGBADepthPacking = 3201;
 const TangentSpaceNormalMap = 0;
@@ -15538,6 +15543,1128 @@ class MeshDistanceMaterial extends Material {
     return this;
   }
 }
+function convertArray(array, type) {
+  if (!array || array.constructor === type) return array;
+  if (typeof type.BYTES_PER_ELEMENT === "number") {
+    return new type(array);
+  }
+  return Array.prototype.slice.call(array);
+}
+function isTypedArray(object) {
+  return ArrayBuffer.isView(object) && !(object instanceof DataView);
+}
+function getKeyframeOrder(times) {
+  function compareTime(i, j) {
+    return times[i] - times[j];
+  }
+  const n = times.length;
+  const result = new Array(n);
+  for (let i = 0; i !== n; ++i) result[i] = i;
+  result.sort(compareTime);
+  return result;
+}
+function sortedArray(values, stride, order) {
+  const nValues = values.length;
+  const result = new values.constructor(nValues);
+  for (let i = 0, dstOffset = 0; dstOffset !== nValues; ++i) {
+    const srcOffset = order[i] * stride;
+    for (let j = 0; j !== stride; ++j) {
+      result[dstOffset++] = values[srcOffset + j];
+    }
+  }
+  return result;
+}
+function flattenJSON(jsonKeys, times, values, valuePropertyName) {
+  let i = 1, key = jsonKeys[0];
+  while (key !== void 0 && key[valuePropertyName] === void 0) {
+    key = jsonKeys[i++];
+  }
+  if (key === void 0) return;
+  let value = key[valuePropertyName];
+  if (value === void 0) return;
+  if (Array.isArray(value)) {
+    do {
+      value = key[valuePropertyName];
+      if (value !== void 0) {
+        times.push(key.time);
+        values.push(...value);
+      }
+      key = jsonKeys[i++];
+    } while (key !== void 0);
+  } else if (value.toArray !== void 0) {
+    do {
+      value = key[valuePropertyName];
+      if (value !== void 0) {
+        times.push(key.time);
+        value.toArray(values, values.length);
+      }
+      key = jsonKeys[i++];
+    } while (key !== void 0);
+  } else {
+    do {
+      value = key[valuePropertyName];
+      if (value !== void 0) {
+        times.push(key.time);
+        values.push(value);
+      }
+      key = jsonKeys[i++];
+    } while (key !== void 0);
+  }
+}
+class Interpolant {
+  /**
+   * Constructs a new interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    this.parameterPositions = parameterPositions;
+    this._cachedIndex = 0;
+    this.resultBuffer = resultBuffer !== void 0 ? resultBuffer : new sampleValues.constructor(sampleSize);
+    this.sampleValues = sampleValues;
+    this.valueSize = sampleSize;
+    this.settings = null;
+    this.DefaultSettings_ = {};
+  }
+  /**
+   * Evaluate the interpolant at position `t`.
+   *
+   * @param {number} t - The interpolation factor.
+   * @return {TypedArray} The result buffer.
+   */
+  evaluate(t) {
+    const pp = this.parameterPositions;
+    let i1 = this._cachedIndex, t1 = pp[i1], t0 = pp[i1 - 1];
+    validate_interval: {
+      seek: {
+        let right;
+        linear_scan: {
+          forward_scan: if (!(t < t1)) {
+            for (let giveUpAt = i1 + 2; ; ) {
+              if (t1 === void 0) {
+                if (t < t0) break forward_scan;
+                i1 = pp.length;
+                this._cachedIndex = i1;
+                return this.copySampleValue_(i1 - 1);
+              }
+              if (i1 === giveUpAt) break;
+              t0 = t1;
+              t1 = pp[++i1];
+              if (t < t1) {
+                break seek;
+              }
+            }
+            right = pp.length;
+            break linear_scan;
+          }
+          if (!(t >= t0)) {
+            const t1global = pp[1];
+            if (t < t1global) {
+              i1 = 2;
+              t0 = t1global;
+            }
+            for (let giveUpAt = i1 - 2; ; ) {
+              if (t0 === void 0) {
+                this._cachedIndex = 0;
+                return this.copySampleValue_(0);
+              }
+              if (i1 === giveUpAt) break;
+              t1 = t0;
+              t0 = pp[--i1 - 1];
+              if (t >= t0) {
+                break seek;
+              }
+            }
+            right = i1;
+            i1 = 0;
+            break linear_scan;
+          }
+          break validate_interval;
+        }
+        while (i1 < right) {
+          const mid = i1 + right >>> 1;
+          if (t < pp[mid]) {
+            right = mid;
+          } else {
+            i1 = mid + 1;
+          }
+        }
+        t1 = pp[i1];
+        t0 = pp[i1 - 1];
+        if (t0 === void 0) {
+          this._cachedIndex = 0;
+          return this.copySampleValue_(0);
+        }
+        if (t1 === void 0) {
+          i1 = pp.length;
+          this._cachedIndex = i1;
+          return this.copySampleValue_(i1 - 1);
+        }
+      }
+      this._cachedIndex = i1;
+      this.intervalChanged_(i1, t0, t1);
+    }
+    return this.interpolate_(i1, t0, t, t1);
+  }
+  /**
+   * Returns the interpolation settings.
+   *
+   * @return {Object} The interpolation settings.
+   */
+  getSettings_() {
+    return this.settings || this.DefaultSettings_;
+  }
+  /**
+   * Copies a sample value to the result buffer.
+   *
+   * @param {number} index - An index into the sample value buffer.
+   * @return {TypedArray} The result buffer.
+   */
+  copySampleValue_(index) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset = index * stride;
+    for (let i = 0; i !== stride; ++i) {
+      result[i] = values[offset + i];
+    }
+    return result;
+  }
+  /**
+   * Copies a sample value to the result buffer.
+   *
+   * @abstract
+   * @param {number} i1 - An index into the sample value buffer.
+   * @param {number} t0 - The previous interpolation factor.
+   * @param {number} t - The current interpolation factor.
+   * @param {number} t1 - The next interpolation factor.
+   * @return {TypedArray} The result buffer.
+   */
+  interpolate_() {
+    throw new Error("call to abstract method");
+  }
+  /**
+   * Optional method that is executed when the interval has changed.
+   *
+   * @param {number} i1 - An index into the sample value buffer.
+   * @param {number} t0 - The previous interpolation factor.
+   * @param {number} t - The current interpolation factor.
+   */
+  intervalChanged_() {
+  }
+}
+class CubicInterpolant extends Interpolant {
+  /**
+   * Constructs a new cubic interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+    this._weightPrev = -0;
+    this._offsetPrev = -0;
+    this._weightNext = -0;
+    this._offsetNext = -0;
+    this.DefaultSettings_ = {
+      endingStart: ZeroCurvatureEnding,
+      endingEnd: ZeroCurvatureEnding
+    };
+  }
+  intervalChanged_(i1, t0, t1) {
+    const pp = this.parameterPositions;
+    let iPrev = i1 - 2, iNext = i1 + 1, tPrev = pp[iPrev], tNext = pp[iNext];
+    if (tPrev === void 0) {
+      switch (this.getSettings_().endingStart) {
+        case ZeroSlopeEnding:
+          iPrev = i1;
+          tPrev = 2 * t0 - t1;
+          break;
+        case WrapAroundEnding:
+          iPrev = pp.length - 2;
+          tPrev = t0 + pp[iPrev] - pp[iPrev + 1];
+          break;
+        default:
+          iPrev = i1;
+          tPrev = t1;
+      }
+    }
+    if (tNext === void 0) {
+      switch (this.getSettings_().endingEnd) {
+        case ZeroSlopeEnding:
+          iNext = i1;
+          tNext = 2 * t1 - t0;
+          break;
+        case WrapAroundEnding:
+          iNext = 1;
+          tNext = t1 + pp[1] - pp[0];
+          break;
+        default:
+          iNext = i1 - 1;
+          tNext = t0;
+      }
+    }
+    const halfDt = (t1 - t0) * 0.5, stride = this.valueSize;
+    this._weightPrev = halfDt / (t0 - tPrev);
+    this._weightNext = halfDt / (tNext - t1);
+    this._offsetPrev = iPrev * stride;
+    this._offsetNext = iNext * stride;
+  }
+  interpolate_(i1, t0, t, t1) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, o1 = i1 * stride, o0 = o1 - stride, oP = this._offsetPrev, oN = this._offsetNext, wP = this._weightPrev, wN = this._weightNext, p2 = (t - t0) / (t1 - t0), pp = p2 * p2, ppp = pp * p2;
+    const sP = -wP * ppp + 2 * wP * pp - wP * p2;
+    const s0 = (1 + wP) * ppp + (-1.5 - 2 * wP) * pp + (-0.5 + wP) * p2 + 1;
+    const s1 = (-1 - wN) * ppp + (1.5 + wN) * pp + 0.5 * p2;
+    const sN = wN * ppp - wN * pp;
+    for (let i = 0; i !== stride; ++i) {
+      result[i] = sP * values[oP + i] + s0 * values[o0 + i] + s1 * values[o1 + i] + sN * values[oN + i];
+    }
+    return result;
+  }
+}
+class LinearInterpolant extends Interpolant {
+  /**
+   * Constructs a new linear interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+  }
+  interpolate_(i1, t0, t, t1) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, offset1 = i1 * stride, offset0 = offset1 - stride, weight1 = (t - t0) / (t1 - t0), weight0 = 1 - weight1;
+    for (let i = 0; i !== stride; ++i) {
+      result[i] = values[offset0 + i] * weight0 + values[offset1 + i] * weight1;
+    }
+    return result;
+  }
+}
+class DiscreteInterpolant extends Interpolant {
+  /**
+   * Constructs a new discrete interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+  }
+  interpolate_(i1) {
+    return this.copySampleValue_(i1 - 1);
+  }
+}
+class KeyframeTrack {
+  /**
+   * Constructs a new keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number|string|boolean>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    if (name === void 0) throw new Error("THREE.KeyframeTrack: track name is undefined");
+    if (times === void 0 || times.length === 0) throw new Error("THREE.KeyframeTrack: no keyframes in track named " + name);
+    this.name = name;
+    this.times = convertArray(times, this.TimeBufferType);
+    this.values = convertArray(values, this.ValueBufferType);
+    this.setInterpolation(interpolation || this.DefaultInterpolation);
+  }
+  /**
+   * Converts the keyframe track to JSON.
+   *
+   * @static
+   * @param {KeyframeTrack} track - The keyframe track to serialize.
+   * @return {Object} The serialized keyframe track as JSON.
+   */
+  static toJSON(track) {
+    const trackType = track.constructor;
+    let json;
+    if (trackType.toJSON !== this.toJSON) {
+      json = trackType.toJSON(track);
+    } else {
+      json = {
+        "name": track.name,
+        "times": convertArray(track.times, Array),
+        "values": convertArray(track.values, Array)
+      };
+      const interpolation = track.getInterpolation();
+      if (interpolation !== track.DefaultInterpolation) {
+        json.interpolation = interpolation;
+      }
+    }
+    json.type = track.ValueTypeName;
+    return json;
+  }
+  /**
+   * Factory method for creating a new discrete interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {DiscreteInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodDiscrete(result) {
+    return new DiscreteInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+  /**
+   * Factory method for creating a new linear interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {LinearInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodLinear(result) {
+    return new LinearInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+  /**
+   * Factory method for creating a new smooth interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {CubicInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodSmooth(result) {
+    return new CubicInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+  /**
+   * Defines the interpolation factor method for this keyframe track.
+   *
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} interpolation - The interpolation type.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  setInterpolation(interpolation) {
+    let factoryMethod;
+    switch (interpolation) {
+      case InterpolateDiscrete:
+        factoryMethod = this.InterpolantFactoryMethodDiscrete;
+        break;
+      case InterpolateLinear:
+        factoryMethod = this.InterpolantFactoryMethodLinear;
+        break;
+      case InterpolateSmooth:
+        factoryMethod = this.InterpolantFactoryMethodSmooth;
+        break;
+    }
+    if (factoryMethod === void 0) {
+      const message = "unsupported interpolation for " + this.ValueTypeName + " keyframe track named " + this.name;
+      if (this.createInterpolant === void 0) {
+        if (interpolation !== this.DefaultInterpolation) {
+          this.setInterpolation(this.DefaultInterpolation);
+        } else {
+          throw new Error(message);
+        }
+      }
+      console.warn("THREE.KeyframeTrack:", message);
+      return this;
+    }
+    this.createInterpolant = factoryMethod;
+    return this;
+  }
+  /**
+   * Returns the current interpolation type.
+   *
+   * @return {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} The interpolation type.
+   */
+  getInterpolation() {
+    switch (this.createInterpolant) {
+      case this.InterpolantFactoryMethodDiscrete:
+        return InterpolateDiscrete;
+      case this.InterpolantFactoryMethodLinear:
+        return InterpolateLinear;
+      case this.InterpolantFactoryMethodSmooth:
+        return InterpolateSmooth;
+    }
+  }
+  /**
+   * Returns the value size.
+   *
+   * @return {number} The value size.
+   */
+  getValueSize() {
+    return this.values.length / this.times.length;
+  }
+  /**
+   * Moves all keyframes either forward or backward in time.
+   *
+   * @param {number} timeOffset - The offset to move the time values.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  shift(timeOffset) {
+    if (timeOffset !== 0) {
+      const times = this.times;
+      for (let i = 0, n = times.length; i !== n; ++i) {
+        times[i] += timeOffset;
+      }
+    }
+    return this;
+  }
+  /**
+   * Scale all keyframe times by a factor (useful for frame - seconds conversions).
+   *
+   * @param {number} timeScale - The time scale.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  scale(timeScale) {
+    if (timeScale !== 1) {
+      const times = this.times;
+      for (let i = 0, n = times.length; i !== n; ++i) {
+        times[i] *= timeScale;
+      }
+    }
+    return this;
+  }
+  /**
+   * Removes keyframes before and after animation without changing any values within the defined time range.
+   *
+   * Note: The method does not shift around keys to the start of the track time, because for interpolated
+   * keys this will change their values
+   *
+   * @param {number} startTime - The start time.
+   * @param {number} endTime - The end time.
+   * @return {KeyframeTrack} A reference to this keyframe track.
+   */
+  trim(startTime, endTime) {
+    const times = this.times, nKeys = times.length;
+    let from = 0, to = nKeys - 1;
+    while (from !== nKeys && times[from] < startTime) {
+      ++from;
+    }
+    while (to !== -1 && times[to] > endTime) {
+      --to;
+    }
+    ++to;
+    if (from !== 0 || to !== nKeys) {
+      if (from >= to) {
+        to = Math.max(to, 1);
+        from = to - 1;
+      }
+      const stride = this.getValueSize();
+      this.times = times.slice(from, to);
+      this.values = this.values.slice(from * stride, to * stride);
+    }
+    return this;
+  }
+  /**
+   * Performs minimal validation on the keyframe track. Returns `true` if the values
+   * are valid.
+   *
+   * @return {boolean} Whether the keyframes are valid or not.
+   */
+  validate() {
+    let valid = true;
+    const valueSize = this.getValueSize();
+    if (valueSize - Math.floor(valueSize) !== 0) {
+      console.error("THREE.KeyframeTrack: Invalid value size in track.", this);
+      valid = false;
+    }
+    const times = this.times, values = this.values, nKeys = times.length;
+    if (nKeys === 0) {
+      console.error("THREE.KeyframeTrack: Track is empty.", this);
+      valid = false;
+    }
+    let prevTime = null;
+    for (let i = 0; i !== nKeys; i++) {
+      const currTime = times[i];
+      if (typeof currTime === "number" && isNaN(currTime)) {
+        console.error("THREE.KeyframeTrack: Time is not a valid number.", this, i, currTime);
+        valid = false;
+        break;
+      }
+      if (prevTime !== null && prevTime > currTime) {
+        console.error("THREE.KeyframeTrack: Out of order keys.", this, i, currTime, prevTime);
+        valid = false;
+        break;
+      }
+      prevTime = currTime;
+    }
+    if (values !== void 0) {
+      if (isTypedArray(values)) {
+        for (let i = 0, n = values.length; i !== n; ++i) {
+          const value = values[i];
+          if (isNaN(value)) {
+            console.error("THREE.KeyframeTrack: Value is not a valid number.", this, i, value);
+            valid = false;
+            break;
+          }
+        }
+      }
+    }
+    return valid;
+  }
+  /**
+   * Optimizes this keyframe track by removing equivalent sequential keys (which are
+   * common in morph target sequences).
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  optimize() {
+    const times = this.times.slice(), values = this.values.slice(), stride = this.getValueSize(), smoothInterpolation = this.getInterpolation() === InterpolateSmooth, lastIndex = times.length - 1;
+    let writeIndex = 1;
+    for (let i = 1; i < lastIndex; ++i) {
+      let keep = false;
+      const time2 = times[i];
+      const timeNext = times[i + 1];
+      if (time2 !== timeNext && (i !== 1 || time2 !== times[0])) {
+        if (!smoothInterpolation) {
+          const offset = i * stride, offsetP = offset - stride, offsetN = offset + stride;
+          for (let j = 0; j !== stride; ++j) {
+            const value = values[offset + j];
+            if (value !== values[offsetP + j] || value !== values[offsetN + j]) {
+              keep = true;
+              break;
+            }
+          }
+        } else {
+          keep = true;
+        }
+      }
+      if (keep) {
+        if (i !== writeIndex) {
+          times[writeIndex] = times[i];
+          const readOffset = i * stride, writeOffset = writeIndex * stride;
+          for (let j = 0; j !== stride; ++j) {
+            values[writeOffset + j] = values[readOffset + j];
+          }
+        }
+        ++writeIndex;
+      }
+    }
+    if (lastIndex > 0) {
+      times[writeIndex] = times[lastIndex];
+      for (let readOffset = lastIndex * stride, writeOffset = writeIndex * stride, j = 0; j !== stride; ++j) {
+        values[writeOffset + j] = values[readOffset + j];
+      }
+      ++writeIndex;
+    }
+    if (writeIndex !== times.length) {
+      this.times = times.slice(0, writeIndex);
+      this.values = values.slice(0, writeIndex * stride);
+    } else {
+      this.times = times;
+      this.values = values;
+    }
+    return this;
+  }
+  /**
+   * Returns a new keyframe track with copied values from this instance.
+   *
+   * @return {KeyframeTrack} A clone of this instance.
+   */
+  clone() {
+    const times = this.times.slice();
+    const values = this.values.slice();
+    const TypedKeyframeTrack = this.constructor;
+    const track = new TypedKeyframeTrack(this.name, times, values);
+    track.createInterpolant = this.createInterpolant;
+    return track;
+  }
+}
+KeyframeTrack.prototype.ValueTypeName = "";
+KeyframeTrack.prototype.TimeBufferType = Float32Array;
+KeyframeTrack.prototype.ValueBufferType = Float32Array;
+KeyframeTrack.prototype.DefaultInterpolation = InterpolateLinear;
+class BooleanKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new boolean keyframe track.
+   *
+   * This keyframe track type has no `interpolation` parameter because the
+   * interpolation is always discrete.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<boolean>} values - A list of keyframe values.
+   */
+  constructor(name, times, values) {
+    super(name, times, values);
+  }
+}
+BooleanKeyframeTrack.prototype.ValueTypeName = "bool";
+BooleanKeyframeTrack.prototype.ValueBufferType = Array;
+BooleanKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
+BooleanKeyframeTrack.prototype.InterpolantFactoryMethodLinear = void 0;
+BooleanKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0;
+class ColorKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new color keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+}
+ColorKeyframeTrack.prototype.ValueTypeName = "color";
+class NumberKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new number keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+}
+NumberKeyframeTrack.prototype.ValueTypeName = "number";
+class QuaternionLinearInterpolant extends Interpolant {
+  /**
+   * Constructs a new SLERP interpolant.
+   *
+   * @param {TypedArray} parameterPositions - The parameter positions hold the interpolation factors.
+   * @param {TypedArray} sampleValues - The sample values.
+   * @param {number} sampleSize - The sample size
+   * @param {TypedArray} [resultBuffer] - The result buffer.
+   */
+  constructor(parameterPositions, sampleValues, sampleSize, resultBuffer) {
+    super(parameterPositions, sampleValues, sampleSize, resultBuffer);
+  }
+  interpolate_(i1, t0, t, t1) {
+    const result = this.resultBuffer, values = this.sampleValues, stride = this.valueSize, alpha = (t - t0) / (t1 - t0);
+    let offset = i1 * stride;
+    for (let end = offset + stride; offset !== end; offset += 4) {
+      Quaternion.slerpFlat(result, 0, values, offset - stride, values, offset, alpha);
+    }
+    return result;
+  }
+}
+class QuaternionKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new Quaternion keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+  /**
+   * Overwritten so the method returns Quaternion based interpolant.
+   *
+   * @static
+   * @param {TypedArray} [result] - The result buffer.
+   * @return {QuaternionLinearInterpolant} The new interpolant.
+   */
+  InterpolantFactoryMethodLinear(result) {
+    return new QuaternionLinearInterpolant(this.times, this.values, this.getValueSize(), result);
+  }
+}
+QuaternionKeyframeTrack.prototype.ValueTypeName = "quaternion";
+QuaternionKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0;
+class StringKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new string keyframe track.
+   *
+   * This keyframe track type has no `interpolation` parameter because the
+   * interpolation is always discrete.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<string>} values - A list of keyframe values.
+   */
+  constructor(name, times, values) {
+    super(name, times, values);
+  }
+}
+StringKeyframeTrack.prototype.ValueTypeName = "string";
+StringKeyframeTrack.prototype.ValueBufferType = Array;
+StringKeyframeTrack.prototype.DefaultInterpolation = InterpolateDiscrete;
+StringKeyframeTrack.prototype.InterpolantFactoryMethodLinear = void 0;
+StringKeyframeTrack.prototype.InterpolantFactoryMethodSmooth = void 0;
+class VectorKeyframeTrack extends KeyframeTrack {
+  /**
+   * Constructs a new vector keyframe track.
+   *
+   * @param {string} name - The keyframe track's name.
+   * @param {Array<number>} times - A list of keyframe times.
+   * @param {Array<number>} values - A list of keyframe values.
+   * @param {(InterpolateLinear|InterpolateDiscrete|InterpolateSmooth)} [interpolation] - The interpolation type.
+   */
+  constructor(name, times, values, interpolation) {
+    super(name, times, values, interpolation);
+  }
+}
+VectorKeyframeTrack.prototype.ValueTypeName = "vector";
+class AnimationClip {
+  /**
+   * Constructs a new animation clip.
+   *
+   * Note: Instead of instantiating an AnimationClip directly with the constructor, you can
+   * use the static interface of this class for creating clips. In most cases though, animation clips
+   * will automatically be created by loaders when importing animated 3D assets.
+   *
+   * @param {string} [name=''] - The clip's name.
+   * @param {number} [duration=-1] - The clip's duration in seconds. If a negative value is passed,
+   * the duration will be calculated from the passed keyframes.
+   * @param {Array<KeyframeTrack>} tracks - An array of keyframe tracks.
+   * @param {(NormalAnimationBlendMode|AdditiveAnimationBlendMode)} [blendMode=NormalAnimationBlendMode] - Defines how the animation
+   * is blended/combined when two or more animations are simultaneously played.
+   */
+  constructor(name = "", duration = -1, tracks = [], blendMode = NormalAnimationBlendMode) {
+    this.name = name;
+    this.tracks = tracks;
+    this.duration = duration;
+    this.blendMode = blendMode;
+    this.uuid = generateUUID();
+    this.userData = {};
+    if (this.duration < 0) {
+      this.resetDuration();
+    }
+  }
+  /**
+   * Factory method for creating an animation clip from the given JSON.
+   *
+   * @static
+   * @param {Object} json - The serialized animation clip.
+   * @return {AnimationClip} The new animation clip.
+   */
+  static parse(json) {
+    const tracks = [], jsonTracks = json.tracks, frameTime = 1 / (json.fps || 1);
+    for (let i = 0, n = jsonTracks.length; i !== n; ++i) {
+      tracks.push(parseKeyframeTrack(jsonTracks[i]).scale(frameTime));
+    }
+    const clip = new this(json.name, json.duration, tracks, json.blendMode);
+    clip.uuid = json.uuid;
+    clip.userData = JSON.parse(json.userData || "{}");
+    return clip;
+  }
+  /**
+   * Serializes the given animation clip into JSON.
+   *
+   * @static
+   * @param {AnimationClip} clip - The animation clip to serialize.
+   * @return {Object} The JSON object.
+   */
+  static toJSON(clip) {
+    const tracks = [], clipTracks = clip.tracks;
+    const json = {
+      "name": clip.name,
+      "duration": clip.duration,
+      "tracks": tracks,
+      "uuid": clip.uuid,
+      "blendMode": clip.blendMode,
+      "userData": JSON.stringify(clip.userData)
+    };
+    for (let i = 0, n = clipTracks.length; i !== n; ++i) {
+      tracks.push(KeyframeTrack.toJSON(clipTracks[i]));
+    }
+    return json;
+  }
+  /**
+   * Returns a new animation clip from the passed morph targets array of a
+   * geometry, taking a name and the number of frames per second.
+   *
+   * Note: The fps parameter is required, but the animation speed can be
+   * overridden via {@link AnimationAction#setDuration}.
+   *
+   * @static
+   * @param {string} name - The name of the animation clip.
+   * @param {Array<Object>} morphTargetSequence - A sequence of morph targets.
+   * @param {number} fps - The Frames-Per-Second value.
+   * @param {boolean} noLoop - Whether the clip should be no loop or not.
+   * @return {AnimationClip} The new animation clip.
+   */
+  static CreateFromMorphTargetSequence(name, morphTargetSequence, fps, noLoop) {
+    const numMorphTargets = morphTargetSequence.length;
+    const tracks = [];
+    for (let i = 0; i < numMorphTargets; i++) {
+      let times = [];
+      let values = [];
+      times.push(
+        (i + numMorphTargets - 1) % numMorphTargets,
+        i,
+        (i + 1) % numMorphTargets
+      );
+      values.push(0, 1, 0);
+      const order = getKeyframeOrder(times);
+      times = sortedArray(times, 1, order);
+      values = sortedArray(values, 1, order);
+      if (!noLoop && times[0] === 0) {
+        times.push(numMorphTargets);
+        values.push(values[0]);
+      }
+      tracks.push(
+        new NumberKeyframeTrack(
+          ".morphTargetInfluences[" + morphTargetSequence[i].name + "]",
+          times,
+          values
+        ).scale(1 / fps)
+      );
+    }
+    return new this(name, -1, tracks);
+  }
+  /**
+   * Searches for an animation clip by name, taking as its first parameter
+   * either an array of clips, or a mesh or geometry that contains an
+   * array named "animations" property.
+   *
+   * @static
+   * @param {(Array<AnimationClip>|Object3D)} objectOrClipArray - The array or object to search through.
+   * @param {string} name - The name to search for.
+   * @return {?AnimationClip} The found animation clip. Returns `null` if no clip has been found.
+   */
+  static findByName(objectOrClipArray, name) {
+    let clipArray = objectOrClipArray;
+    if (!Array.isArray(objectOrClipArray)) {
+      const o = objectOrClipArray;
+      clipArray = o.geometry && o.geometry.animations || o.animations;
+    }
+    for (let i = 0; i < clipArray.length; i++) {
+      if (clipArray[i].name === name) {
+        return clipArray[i];
+      }
+    }
+    return null;
+  }
+  /**
+   * Returns an array of new AnimationClips created from the morph target
+   * sequences of a geometry, trying to sort morph target names into
+   * animation-group-based patterns like "Walk_001, Walk_002, Run_001, Run_002...".
+   *
+   * See {@link MD2Loader#parse} as an example for how the method should be used.
+   *
+   * @static
+   * @param {Array<Object>} morphTargets - A sequence of morph targets.
+   * @param {number} fps - The Frames-Per-Second value.
+   * @param {boolean} noLoop - Whether the clip should be no loop or not.
+   * @return {Array<AnimationClip>} An array of new animation clips.
+   */
+  static CreateClipsFromMorphTargetSequences(morphTargets, fps, noLoop) {
+    const animationToMorphTargets = {};
+    const pattern = /^([\w-]*?)([\d]+)$/;
+    for (let i = 0, il = morphTargets.length; i < il; i++) {
+      const morphTarget = morphTargets[i];
+      const parts = morphTarget.name.match(pattern);
+      if (parts && parts.length > 1) {
+        const name = parts[1];
+        let animationMorphTargets = animationToMorphTargets[name];
+        if (!animationMorphTargets) {
+          animationToMorphTargets[name] = animationMorphTargets = [];
+        }
+        animationMorphTargets.push(morphTarget);
+      }
+    }
+    const clips = [];
+    for (const name in animationToMorphTargets) {
+      clips.push(this.CreateFromMorphTargetSequence(name, animationToMorphTargets[name], fps, noLoop));
+    }
+    return clips;
+  }
+  /**
+   * Parses the `animation.hierarchy` format and returns a new animation clip.
+   *
+   * @static
+   * @deprecated since r175.
+   * @param {Object} animation - A serialized animation clip as JSON.
+   * @param {Array<Bones>} bones - An array of bones.
+   * @return {?AnimationClip} The new animation clip.
+   */
+  static parseAnimation(animation, bones) {
+    console.warn("THREE.AnimationClip: parseAnimation() is deprecated and will be removed with r185");
+    if (!animation) {
+      console.error("THREE.AnimationClip: No animation in JSONLoader data.");
+      return null;
+    }
+    const addNonemptyTrack = function(trackType, trackName, animationKeys, propertyName, destTracks) {
+      if (animationKeys.length !== 0) {
+        const times = [];
+        const values = [];
+        flattenJSON(animationKeys, times, values, propertyName);
+        if (times.length !== 0) {
+          destTracks.push(new trackType(trackName, times, values));
+        }
+      }
+    };
+    const tracks = [];
+    const clipName = animation.name || "default";
+    const fps = animation.fps || 30;
+    const blendMode = animation.blendMode;
+    let duration = animation.length || -1;
+    const hierarchyTracks = animation.hierarchy || [];
+    for (let h = 0; h < hierarchyTracks.length; h++) {
+      const animationKeys = hierarchyTracks[h].keys;
+      if (!animationKeys || animationKeys.length === 0) continue;
+      if (animationKeys[0].morphTargets) {
+        const morphTargetNames = {};
+        let k;
+        for (k = 0; k < animationKeys.length; k++) {
+          if (animationKeys[k].morphTargets) {
+            for (let m = 0; m < animationKeys[k].morphTargets.length; m++) {
+              morphTargetNames[animationKeys[k].morphTargets[m]] = -1;
+            }
+          }
+        }
+        for (const morphTargetName in morphTargetNames) {
+          const times = [];
+          const values = [];
+          for (let m = 0; m !== animationKeys[k].morphTargets.length; ++m) {
+            const animationKey = animationKeys[k];
+            times.push(animationKey.time);
+            values.push(animationKey.morphTarget === morphTargetName ? 1 : 0);
+          }
+          tracks.push(new NumberKeyframeTrack(".morphTargetInfluence[" + morphTargetName + "]", times, values));
+        }
+        duration = morphTargetNames.length * fps;
+      } else {
+        const boneName = ".bones[" + bones[h].name + "]";
+        addNonemptyTrack(
+          VectorKeyframeTrack,
+          boneName + ".position",
+          animationKeys,
+          "pos",
+          tracks
+        );
+        addNonemptyTrack(
+          QuaternionKeyframeTrack,
+          boneName + ".quaternion",
+          animationKeys,
+          "rot",
+          tracks
+        );
+        addNonemptyTrack(
+          VectorKeyframeTrack,
+          boneName + ".scale",
+          animationKeys,
+          "scl",
+          tracks
+        );
+      }
+    }
+    if (tracks.length === 0) {
+      return null;
+    }
+    const clip = new this(clipName, duration, tracks, blendMode);
+    return clip;
+  }
+  /**
+   * Sets the duration of this clip to the duration of its longest keyframe track.
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  resetDuration() {
+    const tracks = this.tracks;
+    let duration = 0;
+    for (let i = 0, n = tracks.length; i !== n; ++i) {
+      const track = this.tracks[i];
+      duration = Math.max(duration, track.times[track.times.length - 1]);
+    }
+    this.duration = duration;
+    return this;
+  }
+  /**
+   * Trims all tracks to the clip's duration.
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  trim() {
+    for (let i = 0; i < this.tracks.length; i++) {
+      this.tracks[i].trim(0, this.duration);
+    }
+    return this;
+  }
+  /**
+   * Performs minimal validation on each track in the clip. Returns `true` if all
+   * tracks are valid.
+   *
+   * @return {boolean} Whether the clip's keyframes are valid or not.
+   */
+  validate() {
+    let valid = true;
+    for (let i = 0; i < this.tracks.length; i++) {
+      valid = valid && this.tracks[i].validate();
+    }
+    return valid;
+  }
+  /**
+   * Optimizes each track by removing equivalent sequential keys (which are
+   * common in morph target sequences).
+   *
+   * @return {AnimationClip} A reference to this animation clip.
+   */
+  optimize() {
+    for (let i = 0; i < this.tracks.length; i++) {
+      this.tracks[i].optimize();
+    }
+    return this;
+  }
+  /**
+   * Returns a new animation clip with copied values from this instance.
+   *
+   * @return {AnimationClip} A clone of this instance.
+   */
+  clone() {
+    const tracks = [];
+    for (let i = 0; i < this.tracks.length; i++) {
+      tracks.push(this.tracks[i].clone());
+    }
+    const clip = new this.constructor(this.name, this.duration, tracks, this.blendMode);
+    clip.userData = JSON.parse(JSON.stringify(this.userData));
+    return clip;
+  }
+  /**
+   * Serializes this animation clip into JSON.
+   *
+   * @return {Object} The JSON object.
+   */
+  toJSON() {
+    return this.constructor.toJSON(this);
+  }
+}
+function getTrackTypeForValueTypeName(typeName) {
+  switch (typeName.toLowerCase()) {
+    case "scalar":
+    case "double":
+    case "float":
+    case "number":
+    case "integer":
+      return NumberKeyframeTrack;
+    case "vector":
+    case "vector2":
+    case "vector3":
+    case "vector4":
+      return VectorKeyframeTrack;
+    case "color":
+      return ColorKeyframeTrack;
+    case "quaternion":
+      return QuaternionKeyframeTrack;
+    case "bool":
+    case "boolean":
+      return BooleanKeyframeTrack;
+    case "string":
+      return StringKeyframeTrack;
+  }
+  throw new Error("THREE.KeyframeTrack: Unsupported typeName: " + typeName);
+}
+function parseKeyframeTrack(json) {
+  if (json.type === void 0) {
+    throw new Error("THREE.KeyframeTrack: track type undefined, can not parse");
+  }
+  const trackType = getTrackTypeForValueTypeName(json.type);
+  if (json.times === void 0) {
+    const times = [], values = [];
+    flattenJSON(json.keys, times, values, "value");
+    json.times = times;
+    json.values = values;
+  }
+  if (trackType.parse !== void 0) {
+    return trackType.parse(json);
+  } else {
+    return new trackType(json.name, json.times, json.values, json.interpolation);
+  }
+}
 class Light extends Object3D {
   /**
    * Constructs a new light.
@@ -30421,7 +31548,9 @@ class Event {
     return new Connection(callback, this);
   }
   Fire(...args) {
-    for (const callback of this._callbacks) {
+    for (let i = this._callbacks.length - 1; i >= 0; i--) {
+      const callback = this._callbacks[i];
+      if (!callback) return;
       callback(...args);
     }
   }
@@ -30432,7 +31561,9 @@ class Event {
     }
   }
   Clear() {
-    for (const callback of this._callbacks) {
+    for (let i = this._callbacks.length - 1; i >= 0; i--) {
+      const callback = this._callbacks[i];
+      if (!callback) return;
       this.Disconnect(callback);
     }
     this._callbacks = [];
@@ -42738,6 +43869,7 @@ class ModelLayersDesc {
   targetDeformers;
   targetParents;
   layers;
+  destroyConnection;
   //requires compilation
   _targetMeshes;
   uvToHits;
@@ -43017,16 +44149,23 @@ function getModelLayersDesc(model) {
   if (oldLayerDesc && newLayerDesc.isSame(oldLayerDesc)) {
     return oldLayerDesc;
   } else {
+    oldLayerDesc?.destroyConnection?.Disconnect();
     modelLayers.set(model, newLayerDesc);
+    newLayerDesc.destroyConnection = model.Destroying.Connect(() => {
+      modelLayers.delete(model);
+      newLayerDesc.destroyConnection?.Disconnect();
+      newLayerDesc.destroyConnection = void 0;
+    });
     return newLayerDesc;
   }
 }
 const modelHSRDescs = /* @__PURE__ */ new Map();
-const CACHE_uvToHits = /* @__PURE__ */ new Map();
+const CACHE_uvToHits = new Cache();
 class HSRDesc {
   layers;
   layerTransparent;
   uvsToHits;
+  destroyConnection;
   isSame(other) {
     if (!this.layers && other.layers || this.layers && !other.layers) {
       return false;
@@ -43212,7 +44351,13 @@ function getModelHSRDesc(model) {
   if (oldLayerDesc && newHSRDesc.isSame(oldLayerDesc)) {
     return oldLayerDesc;
   } else {
+    oldLayerDesc?.destroyConnection?.Disconnect();
     modelHSRDescs.set(model, newHSRDesc);
+    newHSRDesc.destroyConnection = model.Destroying.Connect(() => {
+      modelHSRDescs.delete(model);
+      newHSRDesc.destroyConnection?.Disconnect();
+      newHSRDesc.destroyConnection = void 0;
+    });
     return newHSRDesc;
   }
 }
@@ -43266,7 +44411,7 @@ function buildWedge(x, y, z) {
   mesh.coreMesh.increaseFaces(2 * 5);
   let totalVerts = 0;
   let totalFaces = 0;
-  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, -y, -z], [x, -y, -z], [x, y, z], [-x, y, z], [0, 1, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
+  totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, -y, -z], [x, -y, -z], [x, y, z], [-x, y, z], normalize([0, 1, -1]), void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
   totalFaces += 2;
   totalVerts = addQuad(mesh, totalVerts, totalFaces, [-x, -y, z], [x, -y, z], [x, -y, -z], [-x, -y, -z], [0, -1, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
   totalFaces += 2;
@@ -43277,7 +44422,7 @@ function buildWedge(x, y, z) {
   addQuad(mesh, totalVerts, totalFaces, [x, y, z], [x, -y, -z], [x, -y, -z], [x, -y, z], [1, 0, 0], void 0, void 0, void 0, [0, 0], [1, 0], [1, 1], [0, 1]);
   return mesh;
 }
-const HSR_CACHE = /* @__PURE__ */ new Map();
+const HSR_CACHE = new Cache();
 function doHSR(totalUvToHits, targetCage, mesh, moveVerts = true, cacheStr) {
   let closestVertIndexArr = void 0;
   if (cacheStr) {
@@ -43785,7 +44930,7 @@ class MeshDesc {
     }
     threeMesh.castShadow = true;
     threeMesh.geometry = geometry;
-    threeMesh.name = this.instance?.PropOrDefault("Name", "Mesh");
+    threeMesh.name = this.instance?.PropOrDefault("Name", "Mesh") + "_" + this.instance?.id;
     threeMesh.scale.set(mesh.size[0], mesh.size[1], mesh.size[2]);
     this.compilationTimestamp = Date.now() / 1e3;
     return threeMesh;
@@ -43818,6 +44963,11 @@ class MeshDesc {
   fromPart(child) {
     this.canHaveSkinning = false;
     if (child.className === "WedgePart") this.shape = "wedge";
+    switch (child.PropOrDefault("Shape", PartType.Block)) {
+      case PartType.Wedge:
+        this.shape = "wedge";
+        break;
+    }
     const specialMesh = child.FindFirstChildOfClass("SpecialMesh");
     if (specialMesh) {
       switch (specialMesh.Property("MeshType")) {
@@ -45324,10 +46474,13 @@ const __vite_glob_0_11 = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.de
 function diffCFrame(parent, child) {
   return parent.inverse().multiply(child);
 }
+function getBoneName(bone) {
+  return bone.userData.name || bone.name.split("_").pop();
+}
 function boneIsChildOf(bone, parentName) {
   let nextParent = bone.parent;
   while (nextParent) {
-    if (nextParent.name === parentName) {
+    if (getBoneName(nextParent) === parentName) {
       return true;
     }
     nextParent = nextParent.parent;
@@ -45355,13 +46508,15 @@ class SkeletonDesc {
     const boneArr = [];
     for (let i = 0; i < skinning.bones.length; i++) {
       const threeBone = new Bone();
-      threeBone.name = skinning.bones[i].name || "";
-      if (threeBone.name === "HumanoidRootNode") {
-        threeBone.name = "HumanoidRootPart";
+      let boneName = skinning.bones[i].name || "";
+      if (boneName === "HumanoidRootNode") {
+        boneName = "HumanoidRootPart";
       }
-      if (threeBone.name === "root") {
-        threeBone.name = "Root";
+      if (boneName === "root") {
+        boneName = "Root";
       }
+      threeBone.name = "Skeleton_" + this.meshDesc.instance?.id + "_" + boneName;
+      threeBone.userData.name = boneName;
       boneArr.push(threeBone);
     }
     this.bones = boneArr;
@@ -45396,9 +46551,10 @@ class SkeletonDesc {
       throw new Error("FileMesh has no root bone");
     } else {
       log(false, rootBone);
-      if (rootBone && rootBone.name !== "Root") {
+      if (rootBone && getBoneName(rootBone) !== "Root") {
         const trueRootBone = new Bone();
-        trueRootBone.name = "Root";
+        trueRootBone.name = "Skeleton_" + this.meshDesc.instance?.id + "_Root";
+        trueRootBone.userData.name = "Root";
         trueRootBone.position.set(0, 0, 0);
         trueRootBone.rotation.set(0, 0, 0, "YXZ");
         this.boneSourceParts.unshift(void 0);
@@ -45426,7 +46582,7 @@ class SkeletonDesc {
   }
   getBoneWithName(name) {
     for (const bone of this.bones) {
-      if (bone.name === name) {
+      if (getBoneName(bone) === name) {
         return bone;
       }
     }
@@ -45475,13 +46631,13 @@ class SkeletonDesc {
     return sourceNode;
   }
   getBoneWorldCFrame(bone, assembly, selfInstance, includeTransform) {
-    const node = assembly.getNode(bone.name);
+    const node = assembly.getNode(getBoneName(bone));
     const selfNode = selfInstance.w.GetAssemblyNode();
     const sourceNode = this.getSourceNode(selfNode, bone, assembly);
-    if (bone.name === "Root") {
+    if (getBoneName(bone) === "Root") {
       return assembly.traverseCFrame(selfNode, includeTransform, true);
     } else if (node) {
-      if (this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned && bone.name === "Head") {
+      if (this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned && getBoneName(bone) === "Head") {
         const ogCF = assembly.traverseCFrame(node, includeTransform, true);
         const connectorOffset = node.getConnectorOffset(includeTransform).inverse();
         connectorOffset.Orientation = [0, 0, 0];
@@ -45498,7 +46654,7 @@ class SkeletonDesc {
     return this.meshDesc.fileMesh?.facs?.faceBoneNames.includes(boneName);
   }
   addFACS(restCF, bone, assembly) {
-    const isFACS = this.isFACS(bone.name);
+    const isFACS = this.isFACS(getBoneName(bone));
     if (!isFACS) return restCF;
     const facsMesh = this.meshDesc.fileMesh;
     const facs = this.meshDesc.fileMesh?.facs;
@@ -45513,7 +46669,7 @@ class SkeletonDesc {
       new FaceControlsWrapper(faceControls);
       for (let j = 0; j < facs.faceBoneNames.length; j++) {
         const boneName = facs.faceBoneNames[j];
-        if (boneName === bone.name) {
+        if (boneName === getBoneName(bone)) {
           let totalPosition = new Vector32();
           let totalRotation = new Vector32();
           for (let i = 0; i < facs.faceControlNames.length; i++) {
@@ -45576,7 +46732,7 @@ class SkeletonDesc {
       let parentBone = bone.parent;
       if (!(parentBone instanceof Bone)) parentBone = null;
       if (bone && parentBone) {
-        if ((boneIsChildOf(bone, "DynamicHead") || bone.name === "DynamicHead") && this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned) {
+        if ((boneIsChildOf(bone, "DynamicHead") || getBoneName(bone) === "DynamicHead") && this.meshDesc.wasDeformed && !this.meshDesc.wasAutoSkinned) {
           const parentBoneWorldCFrame = this.getOriginalWorldCFrameNoChange(parentBone);
           const boneWorldCFrameNoChange = this.getOriginalWorldCFrameNoChange(bone);
           let diffCF = diffCFrame(parentBoneWorldCFrame, boneWorldCFrameNoChange);
@@ -50589,7 +51745,125 @@ class RBXRendererScene {
    * @param autoDownload If resulting file should be auto downloaded
    * @returns The GLB (buffer) or GLTF (object)
    */
-  async exportGLTF(name = "scene", autoDownload = true) {
+  async exportGLTF(name = "scene", autoDownload = true, options) {
+    const actualOptions = {
+      includeAnimations: false,
+      binary: false
+    };
+    if (options) Object.assign(actualOptions, options);
+    const clips = [];
+    let animator = void 0;
+    let allInstances = [];
+    let rootInstance = void 0;
+    const allRenderedInstances = Array.from(this.renderDescs.keys());
+    let parent = allRenderedInstances[0].parent;
+    while (parent !== void 0) {
+      if (parent.parent === void 0) {
+        rootInstance = parent;
+        allInstances = [parent, ...parent.GetDescendants()];
+        break;
+      }
+      parent = parent.parent;
+    }
+    for (const instance of allInstances) {
+      if (instance.className === "Animator") {
+        animator = instance;
+        break;
+      }
+    }
+    const GLTF_FPS = 30;
+    if (animator && actualOptions.includeAnimations && rootInstance) {
+      const w = animator.w;
+      for (const animationEntryKey of Object.keys(w.data.animationSet)) {
+        let trackIndex = 0;
+        for (const animationEntry of w.data.animationSet[animationEntryKey]) {
+          const track = w._getTrack(animationEntry.id);
+          if (track) {
+            const objectPositions = /* @__PURE__ */ new Map();
+            const objectRotations = /* @__PURE__ */ new Map();
+            const bonePositions = /* @__PURE__ */ new Map();
+            const boneQuaternions = /* @__PURE__ */ new Map();
+            track.weight = 1;
+            const times = [];
+            for (let i = 0; i < Math.max(1, Math.ceil(track.length * GLTF_FPS)); i++) {
+              w.restPose();
+              track.setTime(i / GLTF_FPS);
+              if (w.data.currentMoodAnimationTrack) w.data.currentMoodAnimationTrack.setTime(0);
+              times.push(i / GLTF_FPS);
+              rootInstance.preRender();
+              RBXRenderer.addInstance(rootInstance, new Authentication(), this);
+              for (const instance of allRenderedInstances) {
+                if (instance.className === "Attachment") continue;
+                let isSkinned = false;
+                const renderDesc = this.renderDescs.get(instance);
+                if (renderDesc && renderDesc instanceof ObjectDesc && renderDesc.skeletonDesc) {
+                  isSkinned = true;
+                  const bones = renderDesc.skeletonDesc.bones;
+                  for (const bone of bones) {
+                    if (!bonePositions.has(bone)) bonePositions.set(bone, []);
+                    if (!boneQuaternions.has(bone)) boneQuaternions.set(bone, []);
+                    bonePositions.get(bone).push(bone.position.toArray());
+                    boneQuaternions.get(bone).push(bone.quaternion.toArray());
+                  }
+                }
+                let partToUse = instance;
+                if (partToUse.className === "Decal" && partToUse.parent) {
+                  partToUse = partToUse.parent;
+                }
+                let cf = partToUse.PropOrDefault("CFrame", new CFrame());
+                if (isSkinned) {
+                  cf = new CFrame();
+                }
+                if (!objectPositions.has(instance)) objectPositions.set(instance, []);
+                if (!objectRotations.has(instance)) objectRotations.set(instance, []);
+                objectPositions.get(instance).push(cf.Position);
+                objectRotations.get(instance).push([rad(cf.Orientation[0]), rad(cf.Orientation[1]), rad(cf.Orientation[2])]);
+              }
+            }
+            const keyframeTracks = [];
+            for (const instance of allRenderedInstances) {
+              if (instance.className === "Attachment") continue;
+              const thisPositions = objectPositions.get(instance);
+              const thisRotations = objectRotations.get(instance);
+              if (thisPositions && thisRotations) {
+                const instanceName = instance.PropOrDefault("Name", "Mesh") + "_" + instance.id;
+                keyframeTracks.push(new VectorKeyframeTrack(instanceName + ".position", times, thisPositions.flat()));
+                const quaternionValues = [];
+                for (const rotationValue of thisRotations) {
+                  const quat = new Quaternion().setFromEuler(new Euler(...rotationValue, "YXZ"));
+                  quaternionValues.push(quat.x, quat.y, quat.z, quat.w);
+                }
+                keyframeTracks.push(new QuaternionKeyframeTrack(instanceName + ".quaternion", times, quaternionValues));
+              }
+              const renderDesc = this.renderDescs.get(instance);
+              if (renderDesc && renderDesc instanceof ObjectDesc && renderDesc.skeletonDesc) {
+                const bones = renderDesc.skeletonDesc.bones;
+                for (const bone of bones) {
+                  const thisBonePositions = bonePositions.get(bone);
+                  const thisBoneQuaternions = boneQuaternions.get(bone);
+                  if (thisBonePositions && thisBoneQuaternions) {
+                    keyframeTracks.push(new VectorKeyframeTrack(bone.name + ".position", times, thisBonePositions.flat()));
+                    keyframeTracks.push(new QuaternionKeyframeTrack(bone.name + ".quaternion", times, thisBoneQuaternions.flat()));
+                  }
+                }
+              }
+            }
+            const clip = new AnimationClip(animationEntryKey + "_" + trackIndex, track.length, keyframeTracks);
+            clips.push(clip);
+            console.log(`Generated clip (${clip.name}) with ${clip.tracks.length} tracks and length of ${track.length}`);
+          }
+          trackIndex += 1;
+        }
+      }
+      w.restPose();
+      rootInstance.preRender();
+      RBXRenderer.addInstance(rootInstance, new Authentication(), this);
+    }
+    for (const renderedInstance of allRenderedInstances) {
+      if (this.renderDescs.get(renderedInstance) instanceof EmitterGroupDesc) {
+        RBXRenderer.removeInstance(renderedInstance, this);
+      }
+    }
     return new Promise((resolve, reject) => {
       const exporter = new GLTFExporter();
       exporter.parse(this.scene, (gltf) => {
@@ -50603,6 +51877,9 @@ class RBXRendererScene {
         resolve(gltf);
       }, (error2) => {
         reject(error2);
+      }, {
+        animations: clips,
+        binary: actualOptions.binary
       });
     });
   }
@@ -51772,7 +53049,7 @@ async function renderTargetToCanvas(renderTarget) {
   await rbxRenderer.readRenderTargetPixelsAsync(renderTarget, 0, 0, width, height, data);
   return imageDataToCanvas(data, width, height);
 }
-async function generateModelThumbnail(auth, renderScene, model, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
+async function generateModelThumbnail(auth, renderScene, model, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false, includeAnimations = false) {
   return new Promise((resolve) => {
     const cameraCFrame = getThumbnailCameraCFrame(model);
     if (cameraCFrame) {
@@ -51791,11 +53068,14 @@ async function generateModelThumbnail(auth, renderScene, model, size = [150, 150
     });
     async function doExport() {
       onLoadingConnection.Disconnect();
-      if (type === "gltf") {
+      if (type === "gltf" || type === "glb") {
         if (!FLAGS.RENDERTARGET_TO_CANVASTEXTURE && FLAGS.USE_RENDERTARGET) {
           warn(true, "FLAGS.RENDERTARGET_TO_CANVASTEXTURE is false, GLTF export cannot export render target textures, consider setting this flag to true");
         }
-        resolve(await renderScene.exportGLTF(`result`, gltfAutoDownload));
+        resolve(await renderScene.exportGLTF(`result`, gltfAutoDownload, {
+          includeAnimations,
+          binary: type === "glb"
+        }));
       } else {
         const renderTarget = renderToRenderTarget(...size, renderScene);
         const canvasTarget = await renderTargetToCanvas(renderTarget);
@@ -51809,7 +53089,7 @@ async function generateModelThumbnail(auth, renderScene, model, size = [150, 150
     }
   });
 }
-async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false) {
+async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "png", quality = 1, gltfAutoDownload = false, includeAnimations = false) {
   return new Promise((resolve) => {
     const startTime = performance.now();
     const renderScene = RBXRenderer.addScene();
@@ -51849,7 +53129,7 @@ async function generateOutfitThumbnail(auth, outfit, size = [150, 150], type = "
       onLoadingConnection.Disconnect();
       if (outfitRenderer.currentRig) {
         outfitRenderer.animateOnce(!outfit.containsAssetType("Gear") && outfit.playerAvatarType === AvatarType.R6 ? 0 : 1);
-        const thumbnailResult = await generateModelThumbnail(auth, renderScene, outfitRenderer.currentRig, size, type, quality, gltfAutoDownload);
+        const thumbnailResult = await generateModelThumbnail(auth, renderScene, outfitRenderer.currentRig, size, type, quality, gltfAutoDownload, includeAnimations);
         console.log("Generated outfit thumbnail after seconds:", (performance.now() - startTime) / 1e3);
         resolve(thumbnailResult);
         if (outfitRenderer.currentRig) outfitRenderer.currentRig.Destroy();
@@ -51934,6 +53214,7 @@ export {
   CACHE,
   CFrame,
   COREMESH,
+  Cache,
   CatalogBundleTypes,
   CategoryDictionary,
   Color3,