arcanumcube 0.1.2 → 0.1.4

package/dist/esm/arcanumcube.module.js

@@ -662,7 +662,9 @@ function getStickerPermutationGroup(position, position2, twists, reverse = false
 
 // src/skins.ts
 import * as THREE from "three";
-function createDefaultLogoTexture() {
+var DefaultLogoTextures;
+function loadDefaultLogoTexture() {
+  if (DefaultLogoTextures) return DefaultLogoTextures;
   const image = document.createElementNS("http://www.w3.org/1999/xhtml", "img");
   image.src = DefaultLogo;
   const texture = new THREE.Texture(image);
@@ -690,7 +692,7 @@ var standardSkin = {
   cube: {
     material: () => {
       return new THREE.MeshStandardMaterial({
-        color: 1118481,
+        color: 3092271,
         metalness: 0.8,
         roughness: 0.4
       });
@@ -726,10 +728,6 @@ var standardSkin = {
       ];
       const col = ColorList[color];
       let texture = void 0;
-      if (x === SIDE_MIDDLE && y === SIDE_MAX && z === SIDE_MIDDLE) {
-        texture = createDefaultLogoTexture();
-        texture.flipY = false;
-      }
       const mat = new THREE.MeshStandardMaterial({
         color: col,
         metalness: 0.4,
@@ -806,10 +804,6 @@ var metalicSkin = {
       ];
       const col = ColorList[color];
       let texture = void 0;
-      if (x === SIDE_MIDDLE && y === SIDE_MAX && z === SIDE_MIDDLE) {
-        texture = createDefaultLogoTexture();
-        texture.flipY = false;
-      }
       const mat = new THREE.MeshStandardMaterial({
         color: col,
         metalness: 0.7,
@@ -883,10 +877,6 @@ var goldSkin = {
       ];
       const col = ColorList[color];
       let texture = void 0;
-      if (x === SIDE_MIDDLE && y === SIDE_MAX && z === SIDE_MIDDLE) {
-        texture = createDefaultLogoTexture();
-        texture.flipY = false;
-      }
       const mat = new THREE.MeshStandardMaterial({
         color: col,
         metalness: 1,
@@ -960,10 +950,6 @@ var acrylicSkin = {
       ];
       const col = ColorList[color];
       let texture = void 0;
-      if (x === SIDE_MIDDLE && y === SIDE_MAX && z === SIDE_MIDDLE) {
-        texture = createDefaultLogoTexture();
-        texture.flipY = false;
-      }
       const mat = new THREE.MeshStandardMaterial({
         color: col,
         metalness: 1,
@@ -1038,10 +1024,6 @@ var crystalSkin = {
       ];
       const col = ColorList[color];
       let texture = void 0;
-      if (x === SIDE_MIDDLE && y === SIDE_MAX && z === SIDE_MIDDLE) {
-        texture = createDefaultLogoTexture();
-        texture.flipY = false;
-      }
       const mat = new THREE.MeshBasicMaterial({
         color: col,
         refractionRatio: 0.75,
@@ -1085,7 +1067,838 @@ var DefaultLogo = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAABAAAAAQACAIAAAD
 import * as THREE3 from "three";
 import { GLTFLoader } from "three/examples/jsm/loaders/GLTFLoader.js";
 import * as BufferGeometryUtils from "three/examples/jsm/utils/BufferGeometryUtils.js";
-import * as TWEEN from "@tweenjs/tween.js";
+
+// node_modules/@tweenjs/tween.js/dist/tween.esm.js
+var Easing = Object.freeze({
+  Linear: Object.freeze({
+    None: function(amount) {
+      return amount;
+    },
+    In: function(amount) {
+      return amount;
+    },
+    Out: function(amount) {
+      return amount;
+    },
+    InOut: function(amount) {
+      return amount;
+    }
+  }),
+  Quadratic: Object.freeze({
+    In: function(amount) {
+      return amount * amount;
+    },
+    Out: function(amount) {
+      return amount * (2 - amount);
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount;
+      }
+      return -0.5 * (--amount * (amount - 2) - 1);
+    }
+  }),
+  Cubic: Object.freeze({
+    In: function(amount) {
+      return amount * amount * amount;
+    },
+    Out: function(amount) {
+      return --amount * amount * amount + 1;
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount * amount;
+      }
+      return 0.5 * ((amount -= 2) * amount * amount + 2);
+    }
+  }),
+  Quartic: Object.freeze({
+    In: function(amount) {
+      return amount * amount * amount * amount;
+    },
+    Out: function(amount) {
+      return 1 - --amount * amount * amount * amount;
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount * amount * amount;
+      }
+      return -0.5 * ((amount -= 2) * amount * amount * amount - 2);
+    }
+  }),
+  Quintic: Object.freeze({
+    In: function(amount) {
+      return amount * amount * amount * amount * amount;
+    },
+    Out: function(amount) {
+      return --amount * amount * amount * amount * amount + 1;
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return 0.5 * amount * amount * amount * amount * amount;
+      }
+      return 0.5 * ((amount -= 2) * amount * amount * amount * amount + 2);
+    }
+  }),
+  Sinusoidal: Object.freeze({
+    In: function(amount) {
+      return 1 - Math.sin((1 - amount) * Math.PI / 2);
+    },
+    Out: function(amount) {
+      return Math.sin(amount * Math.PI / 2);
+    },
+    InOut: function(amount) {
+      return 0.5 * (1 - Math.sin(Math.PI * (0.5 - amount)));
+    }
+  }),
+  Exponential: Object.freeze({
+    In: function(amount) {
+      return amount === 0 ? 0 : Math.pow(1024, amount - 1);
+    },
+    Out: function(amount) {
+      return amount === 1 ? 1 : 1 - Math.pow(2, -10 * amount);
+    },
+    InOut: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      if ((amount *= 2) < 1) {
+        return 0.5 * Math.pow(1024, amount - 1);
+      }
+      return 0.5 * (-Math.pow(2, -10 * (amount - 1)) + 2);
+    }
+  }),
+  Circular: Object.freeze({
+    In: function(amount) {
+      return 1 - Math.sqrt(1 - amount * amount);
+    },
+    Out: function(amount) {
+      return Math.sqrt(1 - --amount * amount);
+    },
+    InOut: function(amount) {
+      if ((amount *= 2) < 1) {
+        return -0.5 * (Math.sqrt(1 - amount * amount) - 1);
+      }
+      return 0.5 * (Math.sqrt(1 - (amount -= 2) * amount) + 1);
+    }
+  }),
+  Elastic: Object.freeze({
+    In: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      return -Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
+    },
+    Out: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      return Math.pow(2, -10 * amount) * Math.sin((amount - 0.1) * 5 * Math.PI) + 1;
+    },
+    InOut: function(amount) {
+      if (amount === 0) {
+        return 0;
+      }
+      if (amount === 1) {
+        return 1;
+      }
+      amount *= 2;
+      if (amount < 1) {
+        return -0.5 * Math.pow(2, 10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI);
+      }
+      return 0.5 * Math.pow(2, -10 * (amount - 1)) * Math.sin((amount - 1.1) * 5 * Math.PI) + 1;
+    }
+  }),
+  Back: Object.freeze({
+    In: function(amount) {
+      var s = 1.70158;
+      return amount === 1 ? 1 : amount * amount * ((s + 1) * amount - s);
+    },
+    Out: function(amount) {
+      var s = 1.70158;
+      return amount === 0 ? 0 : --amount * amount * ((s + 1) * amount + s) + 1;
+    },
+    InOut: function(amount) {
+      var s = 1.70158 * 1.525;
+      if ((amount *= 2) < 1) {
+        return 0.5 * (amount * amount * ((s + 1) * amount - s));
+      }
+      return 0.5 * ((amount -= 2) * amount * ((s + 1) * amount + s) + 2);
+    }
+  }),
+  Bounce: Object.freeze({
+    In: function(amount) {
+      return 1 - Easing.Bounce.Out(1 - amount);
+    },
+    Out: function(amount) {
+      if (amount < 1 / 2.75) {
+        return 7.5625 * amount * amount;
+      } else if (amount < 2 / 2.75) {
+        return 7.5625 * (amount -= 1.5 / 2.75) * amount + 0.75;
+      } else if (amount < 2.5 / 2.75) {
+        return 7.5625 * (amount -= 2.25 / 2.75) * amount + 0.9375;
+      } else {
+        return 7.5625 * (amount -= 2.625 / 2.75) * amount + 0.984375;
+      }
+    },
+    InOut: function(amount) {
+      if (amount < 0.5) {
+        return Easing.Bounce.In(amount * 2) * 0.5;
+      }
+      return Easing.Bounce.Out(amount * 2 - 1) * 0.5 + 0.5;
+    }
+  }),
+  generatePow: function(power) {
+    if (power === void 0) {
+      power = 4;
+    }
+    power = power < Number.EPSILON ? Number.EPSILON : power;
+    power = power > 1e4 ? 1e4 : power;
+    return {
+      In: function(amount) {
+        return Math.pow(amount, power);
+      },
+      Out: function(amount) {
+        return 1 - Math.pow(1 - amount, power);
+      },
+      InOut: function(amount) {
+        if (amount < 0.5) {
+          return Math.pow(amount * 2, power) / 2;
+        }
+        return (1 - Math.pow(2 - amount * 2, power)) / 2 + 0.5;
+      }
+    };
+  }
+});
+var now = function() {
+  return performance.now();
+};
+var Group = (
+  /** @class */
+  function() {
+    function Group3() {
+      var tweens = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        tweens[_i] = arguments[_i];
+      }
+      this._tweens = {};
+      this._tweensAddedDuringUpdate = {};
+      this.add.apply(this, tweens);
+    }
+    Group3.prototype.getAll = function() {
+      var _this = this;
+      return Object.keys(this._tweens).map(function(tweenId) {
+        return _this._tweens[tweenId];
+      });
+    };
+    Group3.prototype.removeAll = function() {
+      this._tweens = {};
+    };
+    Group3.prototype.add = function() {
+      var _a;
+      var tweens = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        tweens[_i] = arguments[_i];
+      }
+      for (var _b = 0, tweens_1 = tweens; _b < tweens_1.length; _b++) {
+        var tween = tweens_1[_b];
+        (_a = tween._group) === null || _a === void 0 ? void 0 : _a.remove(tween);
+        tween._group = this;
+        this._tweens[tween.getId()] = tween;
+        this._tweensAddedDuringUpdate[tween.getId()] = tween;
+      }
+    };
+    Group3.prototype.remove = function() {
+      var tweens = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        tweens[_i] = arguments[_i];
+      }
+      for (var _a = 0, tweens_2 = tweens; _a < tweens_2.length; _a++) {
+        var tween = tweens_2[_a];
+        tween._group = void 0;
+        delete this._tweens[tween.getId()];
+        delete this._tweensAddedDuringUpdate[tween.getId()];
+      }
+    };
+    Group3.prototype.allStopped = function() {
+      return this.getAll().every(function(tween) {
+        return !tween.isPlaying();
+      });
+    };
+    Group3.prototype.update = function(time, preserve) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (preserve === void 0) {
+        preserve = true;
+      }
+      var tweenIds = Object.keys(this._tweens);
+      if (tweenIds.length === 0)
+        return;
+      while (tweenIds.length > 0) {
+        this._tweensAddedDuringUpdate = {};
+        for (var i = 0; i < tweenIds.length; i++) {
+          var tween = this._tweens[tweenIds[i]];
+          var autoStart = !preserve;
+          if (tween && tween.update(time, autoStart) === false && !preserve)
+            this.remove(tween);
+        }
+        tweenIds = Object.keys(this._tweensAddedDuringUpdate);
+      }
+    };
+    return Group3;
+  }()
+);
+var Interpolation = {
+  Linear: function(v, k) {
+    var m = v.length - 1;
+    var f = m * k;
+    var i = Math.floor(f);
+    var fn = Interpolation.Utils.Linear;
+    if (k < 0) {
+      return fn(v[0], v[1], f);
+    }
+    if (k > 1) {
+      return fn(v[m], v[m - 1], m - f);
+    }
+    return fn(v[i], v[i + 1 > m ? m : i + 1], f - i);
+  },
+  Bezier: function(v, k) {
+    var b = 0;
+    var n = v.length - 1;
+    var pw = Math.pow;
+    var bn = Interpolation.Utils.Bernstein;
+    for (var i = 0; i <= n; i++) {
+      b += pw(1 - k, n - i) * pw(k, i) * v[i] * bn(n, i);
+    }
+    return b;
+  },
+  CatmullRom: function(v, k) {
+    var m = v.length - 1;
+    var f = m * k;
+    var i = Math.floor(f);
+    var fn = Interpolation.Utils.CatmullRom;
+    if (v[0] === v[m]) {
+      if (k < 0) {
+        i = Math.floor(f = m * (1 + k));
+      }
+      return fn(v[(i - 1 + m) % m], v[i], v[(i + 1) % m], v[(i + 2) % m], f - i);
+    } else {
+      if (k < 0) {
+        return v[0] - (fn(v[0], v[0], v[1], v[1], -f) - v[0]);
+      }
+      if (k > 1) {
+        return v[m] - (fn(v[m], v[m], v[m - 1], v[m - 1], f - m) - v[m]);
+      }
+      return fn(v[i ? i - 1 : 0], v[i], v[m < i + 1 ? m : i + 1], v[m < i + 2 ? m : i + 2], f - i);
+    }
+  },
+  Utils: {
+    Linear: function(p0, p1, t) {
+      return (p1 - p0) * t + p0;
+    },
+    Bernstein: function(n, i) {
+      var fc = Interpolation.Utils.Factorial;
+      return fc(n) / fc(i) / fc(n - i);
+    },
+    Factorial: /* @__PURE__ */ function() {
+      var a = [1];
+      return function(n) {
+        var s = 1;
+        if (a[n]) {
+          return a[n];
+        }
+        for (var i = n; i > 1; i--) {
+          s *= i;
+        }
+        a[n] = s;
+        return s;
+      };
+    }(),
+    CatmullRom: function(p0, p1, p2, p3, t) {
+      var v0 = (p2 - p0) * 0.5;
+      var v1 = (p3 - p1) * 0.5;
+      var t2 = t * t;
+      var t3 = t * t2;
+      return (2 * p1 - 2 * p2 + v0 + v1) * t3 + (-3 * p1 + 3 * p2 - 2 * v0 - v1) * t2 + v0 * t + p1;
+    }
+  }
+};
+var Sequence = (
+  /** @class */
+  function() {
+    function Sequence2() {
+    }
+    Sequence2.nextId = function() {
+      return Sequence2._nextId++;
+    };
+    Sequence2._nextId = 0;
+    return Sequence2;
+  }()
+);
+var mainGroup = new Group();
+var Tween = (
+  /** @class */
+  function() {
+    function Tween2(object, group) {
+      this._isPaused = false;
+      this._pauseStart = 0;
+      this._valuesStart = {};
+      this._valuesEnd = {};
+      this._valuesStartRepeat = {};
+      this._duration = 1e3;
+      this._isDynamic = false;
+      this._initialRepeat = 0;
+      this._repeat = 0;
+      this._yoyo = false;
+      this._isPlaying = false;
+      this._reversed = false;
+      this._delayTime = 0;
+      this._startTime = 0;
+      this._easingFunction = Easing.Linear.None;
+      this._interpolationFunction = Interpolation.Linear;
+      this._chainedTweens = [];
+      this._onStartCallbackFired = false;
+      this._onEveryStartCallbackFired = false;
+      this._id = Sequence.nextId();
+      this._isChainStopped = false;
+      this._propertiesAreSetUp = false;
+      this._goToEnd = false;
+      this._object = object;
+      if (typeof group === "object") {
+        this._group = group;
+        group.add(this);
+      } else if (group === true) {
+        this._group = mainGroup;
+        mainGroup.add(this);
+      }
+    }
+    Tween2.prototype.getId = function() {
+      return this._id;
+    };
+    Tween2.prototype.isPlaying = function() {
+      return this._isPlaying;
+    };
+    Tween2.prototype.isPaused = function() {
+      return this._isPaused;
+    };
+    Tween2.prototype.getDuration = function() {
+      return this._duration;
+    };
+    Tween2.prototype.to = function(target, duration) {
+      if (duration === void 0) {
+        duration = 1e3;
+      }
+      if (this._isPlaying)
+        throw new Error("Can not call Tween.to() while Tween is already started or paused. Stop the Tween first.");
+      this._valuesEnd = target;
+      this._propertiesAreSetUp = false;
+      this._duration = duration < 0 ? 0 : duration;
+      return this;
+    };
+    Tween2.prototype.duration = function(duration) {
+      if (duration === void 0) {
+        duration = 1e3;
+      }
+      this._duration = duration < 0 ? 0 : duration;
+      return this;
+    };
+    Tween2.prototype.dynamic = function(dynamic) {
+      if (dynamic === void 0) {
+        dynamic = false;
+      }
+      this._isDynamic = dynamic;
+      return this;
+    };
+    Tween2.prototype.start = function(time, overrideStartingValues) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (overrideStartingValues === void 0) {
+        overrideStartingValues = false;
+      }
+      if (this._isPlaying) {
+        return this;
+      }
+      this._repeat = this._initialRepeat;
+      if (this._reversed) {
+        this._reversed = false;
+        for (var property in this._valuesStartRepeat) {
+          this._swapEndStartRepeatValues(property);
+          this._valuesStart[property] = this._valuesStartRepeat[property];
+        }
+      }
+      this._isPlaying = true;
+      this._isPaused = false;
+      this._onStartCallbackFired = false;
+      this._onEveryStartCallbackFired = false;
+      this._isChainStopped = false;
+      this._startTime = time;
+      this._startTime += this._delayTime;
+      if (!this._propertiesAreSetUp || overrideStartingValues) {
+        this._propertiesAreSetUp = true;
+        if (!this._isDynamic) {
+          var tmp = {};
+          for (var prop in this._valuesEnd)
+            tmp[prop] = this._valuesEnd[prop];
+          this._valuesEnd = tmp;
+        }
+        this._setupProperties(this._object, this._valuesStart, this._valuesEnd, this._valuesStartRepeat, overrideStartingValues);
+      }
+      return this;
+    };
+    Tween2.prototype.startFromCurrentValues = function(time) {
+      return this.start(time, true);
+    };
+    Tween2.prototype._setupProperties = function(_object, _valuesStart, _valuesEnd, _valuesStartRepeat, overrideStartingValues) {
+      for (var property in _valuesEnd) {
+        var startValue = _object[property];
+        var startValueIsArray = Array.isArray(startValue);
+        var propType = startValueIsArray ? "array" : typeof startValue;
+        var isInterpolationList = !startValueIsArray && Array.isArray(_valuesEnd[property]);
+        if (propType === "undefined" || propType === "function") {
+          continue;
+        }
+        if (isInterpolationList) {
+          var endValues = _valuesEnd[property];
+          if (endValues.length === 0) {
+            continue;
+          }
+          var temp = [startValue];
+          for (var i = 0, l = endValues.length; i < l; i += 1) {
+            var value = this._handleRelativeValue(startValue, endValues[i]);
+            if (isNaN(value)) {
+              isInterpolationList = false;
+              console.warn("Found invalid interpolation list. Skipping.");
+              break;
+            }
+            temp.push(value);
+          }
+          if (isInterpolationList) {
+            _valuesEnd[property] = temp;
+          }
+        }
+        if ((propType === "object" || startValueIsArray) && startValue && !isInterpolationList) {
+          _valuesStart[property] = startValueIsArray ? [] : {};
+          var nestedObject = startValue;
+          for (var prop in nestedObject) {
+            _valuesStart[property][prop] = nestedObject[prop];
+          }
+          _valuesStartRepeat[property] = startValueIsArray ? [] : {};
+          var endValues = _valuesEnd[property];
+          if (!this._isDynamic) {
+            var tmp = {};
+            for (var prop in endValues)
+              tmp[prop] = endValues[prop];
+            _valuesEnd[property] = endValues = tmp;
+          }
+          this._setupProperties(nestedObject, _valuesStart[property], endValues, _valuesStartRepeat[property], overrideStartingValues);
+        } else {
+          if (typeof _valuesStart[property] === "undefined" || overrideStartingValues) {
+            _valuesStart[property] = startValue;
+          }
+          if (!startValueIsArray) {
+            _valuesStart[property] *= 1;
+          }
+          if (isInterpolationList) {
+            _valuesStartRepeat[property] = _valuesEnd[property].slice().reverse();
+          } else {
+            _valuesStartRepeat[property] = _valuesStart[property] || 0;
+          }
+        }
+      }
+    };
+    Tween2.prototype.stop = function() {
+      if (!this._isChainStopped) {
+        this._isChainStopped = true;
+        this.stopChainedTweens();
+      }
+      if (!this._isPlaying) {
+        return this;
+      }
+      this._isPlaying = false;
+      this._isPaused = false;
+      if (this._onStopCallback) {
+        this._onStopCallback(this._object);
+      }
+      return this;
+    };
+    Tween2.prototype.end = function() {
+      this._goToEnd = true;
+      this.update(this._startTime + this._duration);
+      return this;
+    };
+    Tween2.prototype.pause = function(time) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (this._isPaused || !this._isPlaying) {
+        return this;
+      }
+      this._isPaused = true;
+      this._pauseStart = time;
+      return this;
+    };
+    Tween2.prototype.resume = function(time) {
+      if (time === void 0) {
+        time = now();
+      }
+      if (!this._isPaused || !this._isPlaying) {
+        return this;
+      }
+      this._isPaused = false;
+      this._startTime += time - this._pauseStart;
+      this._pauseStart = 0;
+      return this;
+    };
+    Tween2.prototype.stopChainedTweens = function() {
+      for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
+        this._chainedTweens[i].stop();
+      }
+      return this;
+    };
+    Tween2.prototype.group = function(group) {
+      if (!group) {
+        console.warn("tween.group() without args has been removed, use group.add(tween) instead.");
+        return this;
+      }
+      group.add(this);
+      return this;
+    };
+    Tween2.prototype.remove = function() {
+      var _a;
+      (_a = this._group) === null || _a === void 0 ? void 0 : _a.remove(this);
+      return this;
+    };
+    Tween2.prototype.delay = function(amount) {
+      if (amount === void 0) {
+        amount = 0;
+      }
+      this._delayTime = amount;
+      return this;
+    };
+    Tween2.prototype.repeat = function(times) {
+      if (times === void 0) {
+        times = 0;
+      }
+      this._initialRepeat = times;
+      this._repeat = times;
+      return this;
+    };
+    Tween2.prototype.repeatDelay = function(amount) {
+      this._repeatDelayTime = amount;
+      return this;
+    };
+    Tween2.prototype.yoyo = function(yoyo) {
+      if (yoyo === void 0) {
+        yoyo = false;
+      }
+      this._yoyo = yoyo;
+      return this;
+    };
+    Tween2.prototype.easing = function(easingFunction) {
+      if (easingFunction === void 0) {
+        easingFunction = Easing.Linear.None;
+      }
+      this._easingFunction = easingFunction;
+      return this;
+    };
+    Tween2.prototype.interpolation = function(interpolationFunction) {
+      if (interpolationFunction === void 0) {
+        interpolationFunction = Interpolation.Linear;
+      }
+      this._interpolationFunction = interpolationFunction;
+      return this;
+    };
+    Tween2.prototype.chain = function() {
+      var tweens = [];
+      for (var _i = 0; _i < arguments.length; _i++) {
+        tweens[_i] = arguments[_i];
+      }
+      this._chainedTweens = tweens;
+      return this;
+    };
+    Tween2.prototype.onStart = function(callback) {
+      this._onStartCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onEveryStart = function(callback) {
+      this._onEveryStartCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onUpdate = function(callback) {
+      this._onUpdateCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onRepeat = function(callback) {
+      this._onRepeatCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onComplete = function(callback) {
+      this._onCompleteCallback = callback;
+      return this;
+    };
+    Tween2.prototype.onStop = function(callback) {
+      this._onStopCallback = callback;
+      return this;
+    };
+    Tween2.prototype.update = function(time, autoStart) {
+      var _this = this;
+      var _a;
+      if (time === void 0) {
+        time = now();
+      }
+      if (autoStart === void 0) {
+        autoStart = Tween2.autoStartOnUpdate;
+      }
+      if (this._isPaused)
+        return true;
+      var property;
+      if (!this._goToEnd && !this._isPlaying) {
+        if (autoStart)
+          this.start(time, true);
+        else
+          return false;
+      }
+      this._goToEnd = false;
+      if (time < this._startTime) {
+        return true;
+      }
+      if (this._onStartCallbackFired === false) {
+        if (this._onStartCallback) {
+          this._onStartCallback(this._object);
+        }
+        this._onStartCallbackFired = true;
+      }
+      if (this._onEveryStartCallbackFired === false) {
+        if (this._onEveryStartCallback) {
+          this._onEveryStartCallback(this._object);
+        }
+        this._onEveryStartCallbackFired = true;
+      }
+      var elapsedTime = time - this._startTime;
+      var durationAndDelay = this._duration + ((_a = this._repeatDelayTime) !== null && _a !== void 0 ? _a : this._delayTime);
+      var totalTime = this._duration + this._repeat * durationAndDelay;
+      var calculateElapsedPortion = function() {
+        if (_this._duration === 0)
+          return 1;
+        if (elapsedTime > totalTime) {
+          return 1;
+        }
+        var timesRepeated = Math.trunc(elapsedTime / durationAndDelay);
+        var timeIntoCurrentRepeat = elapsedTime - timesRepeated * durationAndDelay;
+        var portion = Math.min(timeIntoCurrentRepeat / _this._duration, 1);
+        if (portion === 0 && elapsedTime === _this._duration) {
+          return 1;
+        }
+        return portion;
+      };
+      var elapsed = calculateElapsedPortion();
+      var value = this._easingFunction(elapsed);
+      this._updateProperties(this._object, this._valuesStart, this._valuesEnd, value);
+      if (this._onUpdateCallback) {
+        this._onUpdateCallback(this._object, elapsed);
+      }
+      if (this._duration === 0 || elapsedTime >= this._duration) {
+        if (this._repeat > 0) {
+          var completeCount = Math.min(Math.trunc((elapsedTime - this._duration) / durationAndDelay) + 1, this._repeat);
+          if (isFinite(this._repeat)) {
+            this._repeat -= completeCount;
+          }
+          for (property in this._valuesStartRepeat) {
+            if (!this._yoyo && typeof this._valuesEnd[property] === "string") {
+              this._valuesStartRepeat[property] = // eslint-disable-next-line
+              // @ts-ignore FIXME?
+              this._valuesStartRepeat[property] + parseFloat(this._valuesEnd[property]);
+            }
+            if (this._yoyo) {
+              this._swapEndStartRepeatValues(property);
+            }
+            this._valuesStart[property] = this._valuesStartRepeat[property];
+          }
+          if (this._yoyo) {
+            this._reversed = !this._reversed;
+          }
+          this._startTime += durationAndDelay * completeCount;
+          if (this._onRepeatCallback) {
+            this._onRepeatCallback(this._object);
+          }
+          this._onEveryStartCallbackFired = false;
+          return true;
+        } else {
+          if (this._onCompleteCallback) {
+            this._onCompleteCallback(this._object);
+          }
+          for (var i = 0, numChainedTweens = this._chainedTweens.length; i < numChainedTweens; i++) {
+            this._chainedTweens[i].start(this._startTime + this._duration, false);
+          }
+          this._isPlaying = false;
+          return false;
+        }
+      }
+      return true;
+    };
+    Tween2.prototype._updateProperties = function(_object, _valuesStart, _valuesEnd, value) {
+      for (var property in _valuesEnd) {
+        if (_valuesStart[property] === void 0) {
+          continue;
+        }
+        var start = _valuesStart[property] || 0;
+        var end = _valuesEnd[property];
+        var startIsArray = Array.isArray(_object[property]);
+        var endIsArray = Array.isArray(end);
+        var isInterpolationList = !startIsArray && endIsArray;
+        if (isInterpolationList) {
+          _object[property] = this._interpolationFunction(end, value);
+        } else if (typeof end === "object" && end) {
+          this._updateProperties(_object[property], start, end, value);
+        } else {
+          end = this._handleRelativeValue(start, end);
+          if (typeof end === "number") {
+            _object[property] = start + (end - start) * value;
+          }
+        }
+      }
+    };
+    Tween2.prototype._handleRelativeValue = function(start, end) {
+      if (typeof end !== "string") {
+        return end;
+      }
+      if (end.charAt(0) === "+" || end.charAt(0) === "-") {
+        return start + parseFloat(end);
+      }
+      return parseFloat(end);
+    };
+    Tween2.prototype._swapEndStartRepeatValues = function(property) {
+      var tmp = this._valuesStartRepeat[property];
+      var endValue = this._valuesEnd[property];
+      if (typeof endValue === "string") {
+        this._valuesStartRepeat[property] = this._valuesStartRepeat[property] + parseFloat(endValue);
+      } else {
+        this._valuesStartRepeat[property] = this._valuesEnd[property];
+      }
+      this._valuesEnd[property] = tmp;
+    };
+    Tween2.autoStartOnUpdate = false;
+    return Tween2;
+  }()
+);
+var nextId = Sequence.nextId;
+var TWEEN = mainGroup;
+var getAll = TWEEN.getAll.bind(TWEEN);
+var removeAll = TWEEN.removeAll.bind(TWEEN);
+var add = TWEEN.add.bind(TWEEN);
+var remove = TWEEN.remove.bind(TWEEN);
+var update = TWEEN.update.bind(TWEEN);
 
 // src/materials.ts
 import * as THREE2 from "three";
@@ -1347,10 +2160,12 @@ var WebGLArcanumCube = class extends ArcanumCube {
   _draggingTwist;
   /** max degree to cancel the dragging */
   _cancelDragDeg;
-  /** tween group */
-  _tweens;
+  /** easing group */
+  _easings;
   /** light at the center of cube */
   _coreLights;
+  /** status of locking the twist */
+  _lockTwist;
   constructor(options) {
     super(options);
     this._config = {
@@ -1362,7 +2177,6 @@ var WebGLArcanumCube = class extends ArcanumCube {
       gap: 0.01,
       enableShadow: false,
       skin: DefaultSkin,
-      autoReset: true,
       enableCoreLight: false,
       coreLightColor: 33023,
       coreLightIntensity: 30,
@@ -1375,8 +2189,9 @@ var WebGLArcanumCube = class extends ArcanumCube {
     this._cubeObjectList = [];
     this._cubeMap = {};
     this._cancelDragDeg = 15;
-    this._tweens = new TWEEN.Group();
+    this._easings = new Group();
     this._coreLights = [];
+    this._lockTwist = false;
     if (options) {
       Object.assign(this._config, options);
     }
@@ -1473,8 +2288,14 @@ var WebGLArcanumCube = class extends ArcanumCube {
     }
     await this.init();
   }
+  lockTwist(flag) {
+    this._lockTwist = flag;
+  }
+  isTwisting() {
+    return this._easings.getAll().length > 0;
+  }
   reset(duration = 1800) {
-    if (this._tweens.getAll().length > 0) return;
+    if (this._lockTwist || this.isTwisting()) return;
     if (this._selectedCube) this.deselectCube();
     if (this._selectedSticker) this.deselectSticker();
     this._twistGroup = void 0;
@@ -1493,34 +2314,34 @@ var WebGLArcanumCube = class extends ArcanumCube {
         qa.push(cube.getGroup().quaternion.clone());
       });
       const params = { t: 0 };
-      const tweenExplode = new TWEEN.Tween(params).to({ t: 1 }, duration * 5 / 18).easing(TWEEN.Easing.Quartic.Out).onUpdate(() => {
+      const easingExplode = new Tween(params).to({ t: 1 }, duration * 5 / 18).easing(Easing.Quartic.Out).onUpdate(() => {
         cubeList.forEach((cube) => {
           cube.stretch(stretchSize * params.t);
         });
       }).onComplete(() => {
-        this._tweens.remove(tweenExplode);
+        this._easings.remove(easingExplode);
       });
       const params2 = { t: 0 };
-      const tweenReset = new TWEEN.Tween(params2).to({ t: 1 }, duration * 8 / 18).easing(TWEEN.Easing.Quartic.Out).onUpdate(() => {
+      const easingReset = new Tween(params2).to({ t: 1 }, duration * 8 / 18).easing(Easing.Quartic.Out).onUpdate(() => {
         cubeList.forEach((cube, index) => {
           cube.getGroup().quaternion.slerpQuaternions(qa[index], qb, params2.t);
         });
       }).onComplete(() => {
         super.reset();
-        this._tweens.remove(tweenReset);
+        this._easings.remove(easingReset);
       });
       const params3 = { t: 1 };
-      const tweenContract = new TWEEN.Tween(params3).to({ t: 0 }, duration * 5 / 18).easing(TWEEN.Easing.Quartic.Out).onUpdate(() => {
+      const easingContract = new Tween(params3).to({ t: 0 }, duration * 5 / 18).easing(Easing.Quartic.Out).onUpdate(() => {
         cubeList.forEach((cube) => {
           cube.stretch(stretchSize * params3.t);
         });
       }).onComplete(() => {
-        this._tweens.remove(tweenContract);
+        this._easings.remove(easingContract);
       });
-      tweenExplode.chain(tweenReset);
-      tweenReset.chain(tweenContract);
-      this._tweens.add(tweenExplode, tweenReset, tweenContract);
-      tweenExplode.start();
+      easingExplode.chain(easingReset);
+      easingReset.chain(easingContract);
+      this._easings.add(easingExplode, easingReset, easingContract);
+      easingExplode.start();
     }
   }
   selectedCube() {
@@ -1661,7 +2482,7 @@ var WebGLArcanumCube = class extends ArcanumCube {
     return twistGroup;
   }
   dragTwist(twist, rad) {
-    if (this._tweens.getAll().length > 0) return;
+    if (this._lockTwist || this.isTwisting()) return;
     if (!this._draggingTwist || this._draggingTwist.twist != twist) {
       this._draggingTwist = {
         twist,
@@ -1676,30 +2497,30 @@ var WebGLArcanumCube = class extends ArcanumCube {
     this._draggingTwist.group.quaternion.copy(q);
   }
   dragTwistEnd() {
-    if (this._tweens.getAll().length > 0) return;
+    if (this._lockTwist || this.isTwisting()) return;
     if (this._draggingTwist) {
       const deg = this._draggingTwist.rad * 180 / Math.PI;
       if (deg > this._cancelDragDeg) {
-        this.tweenTwist(this._draggingTwist.twist);
+        this.easingTwist(this._draggingTwist.twist);
       } else {
-        this.tweenTwist(this._draggingTwist.twist, false, 100, true);
+        this.easingTwist(this._draggingTwist.twist, false, 100, true);
       }
     }
   }
   // twist randomly several steps
   scramble(steps = 0, duration = 3e3) {
     const list = getRandomTwistList(steps);
-    this.tweenTwist(list, false, duration, false);
+    this.easingTwist(list, false, duration, false);
   }
   undo(steps = 1, duration = 300) {
     const list = this.getUndoList(steps);
-    this.tweenTwist(list, true, duration, false);
+    this.easingTwist(list, true, duration, false);
   }
   // twisting(複数回対応)
-  // durationを0にするとTweenなしとなる
-  tweenTwist(twist, reverse = false, duration = 500, cancel = false, options) {
-    if (this._tweens.getAll().length > 0) return;
-    if (options == null) options = this._config.twistOptions;
+  // durationを0にするとEasingなしとなる
+  easingTwist(twist, reverse = false, duration = 500, cancel = false, options) {
+    if (this._lockTwist || this.isTwisting()) return;
+    options = { ...this._config.twistOptions, ...options };
     if (duration === 0) {
       if (Array.isArray(twist)) {
         if (twist.length == 0) return;
@@ -1718,8 +2539,8 @@ var WebGLArcanumCube = class extends ArcanumCube {
       options?.onComplete && options.onComplete(this);
       return;
     }
-    let firstTween = void 0;
-    let tween = void 0;
+    let firstEasing = void 0;
+    let easing = void 0;
     if (Array.isArray(twist)) {
       if (twist.length == 0) return;
       const lap = duration / twist.length;
@@ -1731,22 +2552,22 @@ var WebGLArcanumCube = class extends ArcanumCube {
         if (ontwisted)
           opts.onTwisted = (self, twist2, n1, n2) => ontwisted(this, twist2, i + 1, len);
         if (i === len - 1 && options?.onComplete) opts.onComplete = options.onComplete;
-        const t = this._tweenTwist(c, reverse, lap, cancel, opts);
-        this._tweens.add(t);
-        if (!tween) {
-          firstTween = tween = t;
+        const t = this._easingTwist(c, reverse, lap, cancel, opts);
+        this._easings.add(t);
+        if (!easing) {
+          firstEasing = easing = t;
         } else {
-          tween.chain(t);
-          tween = t;
+          easing.chain(t);
+          easing = t;
         }
       }
     } else {
-      firstTween = this._tweenTwist(twist, reverse, duration, cancel, options);
-      this._tweens.add(firstTween);
+      firstEasing = this._easingTwist(twist, reverse, duration, cancel, options);
+      this._easings.add(firstEasing);
     }
-    if (firstTween) {
+    if (firstEasing) {
       options?.onStart && options.onStart(this);
-      firstTween.start();
+      firstEasing.start();
     }
   }
   // twist immediately
@@ -1766,8 +2587,8 @@ var WebGLArcanumCube = class extends ArcanumCube {
     this._twistGroup = void 0;
     super.twist(twist, reverse);
   }
-  // twist with tween
-  _tweenTwist(twist, reverse, duration, cancel, options = {}) {
+  // twist with easing
+  _easingTwist(twist, reverse, duration, cancel, options = {}) {
     let qa;
     if (this._draggingTwist) {
       this._twistGroup = this._draggingTwist.group;
@@ -1783,7 +2604,7 @@ var WebGLArcanumCube = class extends ArcanumCube {
       qb.setFromAxisAngle(new THREE3.Vector3(axis[0], axis[1], axis[2]), rad);
     }
     const params = { t: 0 };
-    const tween = new TWEEN.Tween(params).to({ t: 1 }, duration).easing(TWEEN.Easing.Quartic.Out).onUpdate(() => {
+    const easing = new Tween(params).to({ t: 1 }, duration).easing(Easing.Quartic.Out).onUpdate(() => {
       if (!this._twistGroup) {
         this._twistGroup = this._reconstructGroups(twist);
       }
@@ -1803,15 +2624,17 @@ var WebGLArcanumCube = class extends ArcanumCube {
       if (!cancel) {
         super.twist(twist, reverse);
       }
-      this._tweens.remove(tween);
+      this._easings.remove(easing);
       options.onTwisted && options.onTwisted(this, twist, 1, 1);
       options.onComplete && options.onComplete(this);
-      if (this._config.autoReset && this.isSolved()) this.reset(0);
+      if (options.onSolved && this.isSolved()) {
+        options.onSolved(this);
+      }
     });
-    return tween;
+    return easing;
   }
-  updateTweens() {
-    this._tweens.update();
+  update() {
+    this._easings.update();
   }
   // set color of core lights
   setCoreLightColor(color) {
@@ -1858,5 +2681,6 @@ export {
   getNextStickerColors,
   getRandomTwistList,
   getStickerIndex,
-  getStickerPermutationGroup
+  getStickerPermutationGroup,
+  loadDefaultLogoTexture
 };