cubing 0.21.0 → 0.22.0

package/dist/esm/{chunk-5DN4DAAX.js → chunk-DLN5QS4V.js}

@@ -1,19 +1,23 @@
 import {
+  cube3x3x3,
   getFaceletAppearance,
   puzzles
-} from "./chunk-CQS6JZ7G.js";
+} from "./chunk-HXKINJ7U.js";
 import {
+  KPuzzle,
   areTransformationsEquivalent,
-  transformationForQuantumMove
-} from "./chunk-YV3RT5PX.js";
+  transformationForQuantumMove,
+  transformationOrder
+} from "./chunk-X6JHXPDX.js";
 import {
-  Alg
-} from "./chunk-BU5PUJK3.js";
+  Move
+} from "./chunk-EWRBHQFX.js";
 import {
   __privateAdd,
   __privateGet,
   __privateMethod,
-  __privateSet
+  __privateSet,
+  __privateWrapper
 } from "./chunk-WO2AXYFE.js";
 
 // src/cubing/twisty/views/3D/puzzles/Cube3D.ts
@@ -32,363 +36,345 @@ import {
   Quaternion,
   TextureLoader,
   Vector2,
-  Vector3 as Vector32
+  Vector3
 } from "three";
 
-// src/cubing/twisty/old/animation/easing.ts
-function smootherStep(x) {
-  return x * x * x * (10 - x * (15 - 6 * x));
-}
-
-// src/cubing/twisty/old/dom/TwistyPlayerConfig.ts
-import { Vector3 } from "three";
-
-// src/cubing/twisty/views/3D/TAU.ts
-var TAU = Math.PI * 2;
-var DEGREES_PER_RADIAN = 360 / TAU;
-
-// src/cubing/twisty/old/dom/element/ElementConfig.ts
-var AlgAttribute = class {
-  constructor(initialValue) {
-    if (initialValue) {
-      if (typeof initialValue === "string") {
-        this.setString(initialValue);
-      } else {
-        this.setValue(initialValue);
-      }
-    } else {
-      this.setValue(this.defaultValue());
-    }
+// src/cubing/vendor/p-lazy/p-lazy.ts
+var PLazy = class extends Promise {
+  constructor(executor) {
+    super((resolve) => {
+      resolve();
+    });
+    this._executor = executor;
   }
-  setString(str) {
-    if (this.string === str) {
-      return false;
-    }
-    this.string = str;
-    this.value = this.toValue(str);
-    return true;
+  static from(function_) {
+    return new PLazy((resolve) => {
+      resolve(function_());
+    });
   }
-  setValue(val) {
-    const str = this.toString(val);
-    if (this.string === str) {
-      return false;
-    }
-    this.string = str;
-    this.value = val;
-    return true;
+  static resolve(value) {
+    return new PLazy((resolve) => {
+      resolve(value);
+    });
   }
-  defaultValue() {
-    return new Alg([]);
+  static reject(error) {
+    return new PLazy((_resolve, reject) => {
+      reject(error);
+    });
   }
-  toValue(s) {
-    return Alg.fromString(s);
+  then(onFulfilled, onRejected) {
+    this._promise = this._promise || new Promise(this._executor);
+    return this._promise.then(onFulfilled, onRejected);
   }
-  toString(val) {
-    return val.toString();
+  catch(onRejected) {
+    this._promise = this._promise || new Promise(this._executor);
+    return this._promise.catch(onRejected);
   }
 };
-var StringEnumAttribute = class {
-  constructor(enumVal, initialValue) {
-    this.enumVal = enumVal;
-    this.setString(initialValue ?? this.defaultValue());
-  }
-  setString(str) {
-    if (this.string === str) {
-      return false;
-    }
-    if (!(str in this.enumVal)) {
-      throw new Error(`Invalid string for attribute!: ${str}`);
+function from(function_) {
+  return new PLazy((resolve) => {
+    resolve(function_());
+  });
+}
+
+// src/cubing/twisty/model/PromiseFreshener.ts
+var _latestAssignedIdx, _latestResolvedIdx;
+var PromiseFreshener = class {
+  constructor() {
+    __privateAdd(this, _latestAssignedIdx, 0);
+    __privateAdd(this, _latestResolvedIdx, 0);
+  }
+  async queue(p) {
+    const idx = ++__privateWrapper(this, _latestAssignedIdx)._;
+    const result = await p;
+    if (idx > __privateGet(this, _latestResolvedIdx)) {
+      __privateSet(this, _latestResolvedIdx, idx);
+      return {
+        fresh: true,
+        result
+      };
+    } else {
+      return { fresh: false };
     }
-    this.string = str;
-    this.value = this.toValue(str);
-    return true;
-  }
-  setValue(val) {
-    return this.setString(val);
-  }
-  defaultValue() {
-    return Object.keys(this.enumVal)[0];
-  }
-  toValue(s) {
-    return s;
   }
 };
-var _defaultValue, _clampValue, clampValue_fn;
-var RangedFloatAttribute = class {
-  constructor(defaultValue, minValue, maxValue, initialValue) {
-    this.minValue = minValue;
-    this.maxValue = maxValue;
-    __privateAdd(this, _clampValue);
-    __privateAdd(this, _defaultValue, void 0);
-    __privateSet(this, _defaultValue, defaultValue === null ? null : __privateMethod(this, _clampValue, clampValue_fn).call(this, defaultValue));
-    this.setValue(initialValue ?? this.defaultValue());
-  }
-  setString(str) {
-    return this.setValue(str === "" ? null : this.toValue(str));
-  }
-  setValue(val) {
-    const str = this.toString(val);
-    if (this.string === str) {
-      return false;
-    }
-    this.string = str;
-    this.value = val;
-    return true;
-  }
-  defaultValue() {
-    return __privateGet(this, _defaultValue);
-  }
-  toValue(s) {
-    return parseFloat(s);
-  }
-  toString(v) {
-    return v === null ? "" : v.toString();
+_latestAssignedIdx = new WeakMap();
+_latestResolvedIdx = new WeakMap();
+var _latestAssignedIdx2, _latestResolvedIdx2;
+var StaleDropper = class {
+  constructor() {
+    __privateAdd(this, _latestAssignedIdx2, 0);
+    __privateAdd(this, _latestResolvedIdx2, 0);
+  }
+  queue(p) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        const idx = ++__privateWrapper(this, _latestAssignedIdx2)._;
+        const result = await p;
+        if (idx > __privateGet(this, _latestResolvedIdx2)) {
+          __privateSet(this, _latestResolvedIdx2, idx);
+          resolve(result);
+        }
+      } catch (e) {
+        reject(e);
+      }
+    });
   }
 };
-_defaultValue = new WeakMap();
-_clampValue = new WeakSet();
-clampValue_fn = function(val) {
-  return Math.max(Math.min(val, this.maxValue), this.minValue);
-};
+_latestAssignedIdx2 = new WeakMap();
+_latestResolvedIdx2 = new WeakMap();
 
-// src/cubing/twisty/old/dom/element/ClassListManager.ts
-var _currentClassName;
-var ClassListManager = class {
-  constructor(elem, prefix, validSuffixes) {
-    this.elem = elem;
-    this.prefix = prefix;
-    this.validSuffixes = validSuffixes;
-    __privateAdd(this, _currentClassName, null);
-  }
-  clearValue() {
-    if (__privateGet(this, _currentClassName)) {
-      this.elem.contentWrapper.classList.remove(__privateGet(this, _currentClassName));
-    }
-    __privateSet(this, _currentClassName, null);
-  }
-  setValue(suffix) {
-    if (!this.validSuffixes.includes(suffix)) {
-      throw new Error(`Invalid suffix: ${suffix}`);
-    }
-    const newClassName = `${this.prefix}${suffix}`;
-    const changed = __privateGet(this, _currentClassName) !== newClassName;
-    if (changed) {
-      this.clearValue();
-      this.elem.contentWrapper.classList.add(newClassName);
-      __privateSet(this, _currentClassName, newClassName);
-    }
-    return changed;
+// src/cubing/twisty/model/props/TwistyProp.ts
+var globalSourceGeneration = 0;
+var _children, _rawListeners, _scheduleRawDispatch, scheduleRawDispatch_fn, _rawDispatchPending, _dispatchRawListeners, dispatchRawListeners_fn, _freshListeners;
+var TwistyPropParent = class {
+  constructor() {
+    __privateAdd(this, _scheduleRawDispatch);
+    __privateAdd(this, _dispatchRawListeners);
+    __privateAdd(this, _children, new Set());
+    this.lastSourceGeneration = 0;
+    __privateAdd(this, _rawListeners, new Set());
+    __privateAdd(this, _rawDispatchPending, false);
+    __privateAdd(this, _freshListeners, new Map());
   }
-};
-_currentClassName = new WeakMap();
-
-// src/cubing/twisty/old/dom/element/node-custom-element-shims.ts
-var HTMLElementStub = class {
-};
-var HTMLElementShim;
-if (typeof HTMLElement !== "undefined") {
-  HTMLElementShim = HTMLElement;
-} else {
-  HTMLElementShim = HTMLElementStub;
-}
-var CustomElementsStub = class {
-  define() {
+  canReuse(v1, v2) {
+    return v1 === v2 || this.canReuseValue(v1, v2);
   }
-};
-var customElementsShim;
-if (typeof customElements !== "undefined") {
-  customElementsShim = customElements;
-} else {
-  customElementsShim = new CustomElementsStub();
-}
-
-// src/cubing/twisty/old/dom/element/ManagedCustomElement.ts
-var CSSSource = class {
-  constructor(sourceText) {
-    this.sourceText = sourceText;
+  canReuseValue(_v1, _v2) {
+    return false;
   }
-  getAsString() {
-    return this.sourceText;
+  debugGetChildren() {
+    return Array.from(__privateGet(this, _children).values());
   }
-};
-var _cssSourceMap;
-var ManagedCustomElement = class extends HTMLElementShim {
-  constructor(options) {
-    super();
-    __privateAdd(this, _cssSourceMap, new Map());
-    this.shadow = this.attachShadow({ mode: options?.mode ?? "closed" });
-    this.contentWrapper = document.createElement("div");
-    this.contentWrapper.classList.add("wrapper");
-    this.shadow.appendChild(this.contentWrapper);
-  }
-  addCSS(cssSource) {
-    if (__privateGet(this, _cssSourceMap).get(cssSource)) {
+  addChild(child) {
+    __privateGet(this, _children).add(child);
+  }
+  removeChild(child) {
+    __privateGet(this, _children).delete(child);
+  }
+  markStale(sourceEvent) {
+    if (sourceEvent.detail.generation !== globalSourceGeneration) {
+      throw new Error("A TwistyProp was marked stale too late!");
+    }
+    if (this.lastSourceGeneration === sourceEvent.detail.generation) {
       return;
     }
-    const cssElem = document.createElement("style");
-    cssElem.textContent = cssSource.getAsString();
-    __privateGet(this, _cssSourceMap).set(cssSource, cssElem);
-    this.shadow.appendChild(cssElem);
+    this.lastSourceGeneration = sourceEvent.detail.generation;
+    for (const child of __privateGet(this, _children)) {
+      child.markStale(sourceEvent);
+    }
+    __privateMethod(this, _scheduleRawDispatch, scheduleRawDispatch_fn).call(this);
   }
-  removeCSS(cssSource) {
-    const cssElem = __privateGet(this, _cssSourceMap).get(cssSource);
-    if (!cssElem) {
-      return;
+  addRawListener(listener, options) {
+    __privateGet(this, _rawListeners).add(listener);
+    if (options?.initial) {
+      listener();
     }
-    this.shadow.removeChild(cssElem);
-    __privateGet(this, _cssSourceMap).delete(cssSource);
   }
-  addElement(element) {
-    return this.contentWrapper.appendChild(element);
+  removeRawListener(listener) {
+    __privateGet(this, _rawListeners).delete(listener);
   }
-  prependElement(element) {
-    this.contentWrapper.prepend(element);
+  addFreshListener(listener) {
+    const staleDropper = new StaleDropper();
+    let lastResult = null;
+    const callback = async () => {
+      const result = await staleDropper.queue(this.get());
+      if (lastResult !== null && this.canReuse(lastResult, result)) {
+        return;
+      }
+      lastResult = result;
+      listener(result);
+    };
+    __privateGet(this, _freshListeners).set(listener, callback);
+    this.addRawListener(callback, { initial: true });
   }
-  removeElement(element) {
-    return this.contentWrapper.removeChild(element);
+  removeFreshListener(listener) {
+    this.removeRawListener(__privateGet(this, _freshListeners).get(listener));
+    __privateGet(this, _freshListeners).delete(listener);
   }
 };
-_cssSourceMap = new WeakMap();
-customElementsShim.define("twisty-managed-custom-element", ManagedCustomElement);
-
-// src/cubing/twisty/old/dom/viewers/TwistyViewerWrapper.css.ts
-var twistyViewerWrapperCSS = new CSSSource(`
-:host {
-  width: 384px;
-  height: 256px;
-  display: grid;
-}
-
-.wrapper {
-  width: 100%;
-  height: 100%;
-  display: grid;
-  overflow: hidden;
-}
-
-.wrapper > * {
-  width: 100%;
-  height: 100%;
-  overflow: hidden;
-}
-
-.wrapper.back-view-side-by-side {
-  grid-template-columns: 1fr 1fr;
-}
-
-.wrapper.back-view-top-right {
-  grid-template-columns: 3fr 1fr;
-  grid-template-rows: 1fr 3fr;
-}
-
-.wrapper.back-view-top-right > :nth-child(1) {
-  grid-row: 1 / 3;
-  grid-column: 1 / 3;
-}
-
-.wrapper.back-view-top-right > :nth-child(2) {
-  grid-row: 1 / 2;
-  grid-column: 2 / 3;
-}
-`);
-
-// src/cubing/twisty/old/dom/viewers/TwistyViewerWrapper.ts
-var backViewLayouts = {
-  "none": true,
-  "side-by-side": true,
-  "top-right": true
+_children = new WeakMap();
+_rawListeners = new WeakMap();
+_scheduleRawDispatch = new WeakSet();
+scheduleRawDispatch_fn = function() {
+  if (!__privateGet(this, _rawDispatchPending)) {
+    __privateSet(this, _rawDispatchPending, true);
+    setTimeout(() => __privateMethod(this, _dispatchRawListeners, dispatchRawListeners_fn).call(this), 0);
+  }
 };
-var _backViewClassListManager;
-var TwistyViewerWrapper = class extends ManagedCustomElement {
-  constructor(config = {}) {
+_rawDispatchPending = new WeakMap();
+_dispatchRawListeners = new WeakSet();
+dispatchRawListeners_fn = function() {
+  if (!__privateGet(this, _rawDispatchPending)) {
+    throw new Error("Invalid dispatch state!");
+  }
+  for (const listener of __privateGet(this, _rawListeners)) {
+    listener();
+  }
+  __privateSet(this, _rawDispatchPending, false);
+};
+_freshListeners = new WeakMap();
+var _value;
+var TwistyPropSource = class extends TwistyPropParent {
+  constructor(initialValue) {
     super();
-    __privateAdd(this, _backViewClassListManager, new ClassListManager(this, "back-view-", [
-      "none",
-      "side-by-side",
-      "top-right"
-    ]));
-    this.addCSS(twistyViewerWrapperCSS);
-    if (config.backView && config.backView in backViewLayouts) {
-      __privateGet(this, _backViewClassListManager).setValue(config.backView);
+    __privateAdd(this, _value, void 0);
+    __privateSet(this, _value, from(() => this.getDefaultValue()));
+    if (initialValue) {
+      __privateSet(this, _value, this.deriveFromPromiseOrValue(initialValue, __privateGet(this, _value)));
     }
   }
-  setBackView(backView) {
-    return __privateGet(this, _backViewClassListManager).setValue(backView);
+  set(input) {
+    __privateSet(this, _value, this.deriveFromPromiseOrValue(input, __privateGet(this, _value)));
+    const sourceEventDetail = {
+      sourceProp: this,
+      value: __privateGet(this, _value),
+      generation: ++globalSourceGeneration
+    };
+    this.markStale(new CustomEvent("stale", {
+      detail: sourceEventDetail
+    }));
   }
-  clear() {
-    this.contentWrapper.innerHTML = "";
+  async get() {
+    return __privateGet(this, _value);
+  }
+  async deriveFromPromiseOrValue(input, oldValuePromise) {
+    return this.derive(await input, oldValuePromise);
   }
 };
-_backViewClassListManager = new WeakMap();
-customElementsShim.define("twisty-viewer-wrapper", TwistyViewerWrapper);
-
-// src/cubing/twisty/old/dom/TwistyPlayerConfig.ts
-var centeredCameraOrbitCoordinates = {
-  latitude: 31.717474411461005,
-  longitude: 0,
-  distance: 5.877852522924731
-};
-var cubeCube3DCameraOrbitCoordinates = {
-  latitude: 35,
-  longitude: 30,
-  distance: 6
-};
-var cubePG3DCameraOrbitCoordinates = {
-  latitude: 35,
-  longitude: 30,
-  distance: 6.25
+_value = new WeakMap();
+var SimpleTwistyPropSource = class extends TwistyPropSource {
+  derive(input) {
+    return input;
+  }
 };
-var megaminxCameraOrbitCoordinates = {
-  latitude: Math.atan(1 / 2) * DEGREES_PER_RADIAN,
-  longitude: 0,
-  distance: 6.7
+var NO_VALUE = Symbol("no value");
+var _parents, _cachedLastSuccessfulCalculation, _cachedLatestGenerationCalculation, _getParents, getParents_fn, _cacheDerive, cacheDerive_fn;
+var TwistyPropDerived = class extends TwistyPropParent {
+  constructor(parents, userVisibleErrorTracker) {
+    super();
+    this.userVisibleErrorTracker = userVisibleErrorTracker;
+    __privateAdd(this, _getParents);
+    __privateAdd(this, _cacheDerive);
+    __privateAdd(this, _parents, void 0);
+    __privateAdd(this, _cachedLastSuccessfulCalculation, null);
+    __privateAdd(this, _cachedLatestGenerationCalculation, null);
+    __privateSet(this, _parents, parents);
+    for (const parent of Object.values(parents)) {
+      parent.addChild(this);
+    }
+  }
+  async get() {
+    const generation = this.lastSourceGeneration;
+    if (__privateGet(this, _cachedLatestGenerationCalculation)?.generation === generation) {
+      return __privateGet(this, _cachedLatestGenerationCalculation).output;
+    }
+    const latestGenerationCalculation = {
+      generation,
+      output: __privateMethod(this, _cacheDerive, cacheDerive_fn).call(this, __privateMethod(this, _getParents, getParents_fn).call(this), generation, __privateGet(this, _cachedLastSuccessfulCalculation))
+    };
+    __privateSet(this, _cachedLatestGenerationCalculation, latestGenerationCalculation);
+    this.userVisibleErrorTracker?.reset();
+    return latestGenerationCalculation.output;
+  }
 };
-var pyraminxCameraOrbitCoordinates = {
-  latitude: 26.56505117707799,
-  longitude: 0,
-  distance: 6
+_parents = new WeakMap();
+_cachedLastSuccessfulCalculation = new WeakMap();
+_cachedLatestGenerationCalculation = new WeakMap();
+_getParents = new WeakSet();
+getParents_fn = async function() {
+  const inputValuePromises = {};
+  for (const [key, parent] of Object.entries(__privateGet(this, _parents))) {
+    inputValuePromises[key] = parent.get();
+  }
+  const inputs = {};
+  for (const key in __privateGet(this, _parents)) {
+    inputs[key] = await inputValuePromises[key];
+  }
+  return inputs;
 };
-var pyraminxLookAt = new Vector3(0, 1 / 6, 0);
-function defaultCameraOrbitCoordinates(puzzleID, strategy) {
-  if (puzzleID[1] === "x") {
-    if (strategy === "Cube3D") {
-      return cubeCube3DCameraOrbitCoordinates;
-    } else {
-      return cubePG3DCameraOrbitCoordinates;
-    }
-  } else {
-    switch (puzzleID) {
-      case "megaminx":
-      case "gigaminx":
-        return megaminxCameraOrbitCoordinates;
-      case "pyraminx":
-      case "master_tetraminx":
-        return pyraminxCameraOrbitCoordinates;
-      case "skewb":
-        return cubePG3DCameraOrbitCoordinates;
-      default:
-        return centeredCameraOrbitCoordinates;
+_cacheDerive = new WeakSet();
+cacheDerive_fn = async function(inputsPromise, generation, cachedLatestGenerationCalculation = null) {
+  const inputs = await inputsPromise;
+  const cache = (output) => {
+    __privateSet(this, _cachedLastSuccessfulCalculation, {
+      inputs,
+      output: Promise.resolve(output),
+      generation
+    });
+    return output;
+  };
+  if (!cachedLatestGenerationCalculation) {
+    return cache(await this.derive(inputs));
+  }
+  const cachedInputs = cachedLatestGenerationCalculation.inputs;
+  for (const key in __privateGet(this, _parents)) {
+    const parent = __privateGet(this, _parents)[key];
+    if (!parent.canReuse(inputs[key], cachedInputs[key])) {
+      return cache(await this.derive(inputs));
     }
   }
-}
-var setupToLocations = {
-  start: true,
-  end: true
+  return cachedLatestGenerationCalculation.output;
 };
-var visualizationFormats = {
-  "3D": true,
-  "2D": true,
-  "experimental-2D-LL": true,
-  "PG3D": true
-};
-var backgroundThemes = {
-  checkered: true,
-  none: true
+var _disconnectionFunctions;
+var FreshListenerManager = class {
+  constructor() {
+    __privateAdd(this, _disconnectionFunctions, []);
+  }
+  addListener(prop, listener) {
+    let disconnected = false;
+    const wrappedListener = (value) => {
+      if (disconnected) {
+        return;
+      }
+      listener(value);
+    };
+    prop.addFreshListener(wrappedListener);
+    __privateGet(this, _disconnectionFunctions).push(() => {
+      prop.removeFreshListener(wrappedListener);
+      disconnected = true;
+    });
+  }
+  addMultiListener(props, listener) {
+    let disconnected = false;
+    const wrappedListener = async (_) => {
+      if (disconnected) {
+        return;
+      }
+      const promises = props.map((prop) => prop.get());
+      const values = await Promise.all(promises);
+      listener(values);
+    };
+    for (const prop of props) {
+      prop.addFreshListener(wrappedListener);
+    }
+    __privateGet(this, _disconnectionFunctions).push(() => {
+      for (const prop of props) {
+        prop.removeFreshListener(wrappedListener);
+      }
+      disconnected = true;
+    });
+  }
+  disconnect() {
+    for (const disconnectionFunction of __privateGet(this, _disconnectionFunctions)) {
+      disconnectionFunction();
+    }
+  }
 };
+_disconnectionFunctions = new WeakMap();
+
+// src/cubing/twisty/model/props/puzzle/display/HintFaceletProp.ts
 var hintFaceletStyles = {
   floating: true,
   none: true
 };
+var HintFaceletProp = class extends SimpleTwistyPropSource {
+  getDefaultValue() {
+    return "auto";
+  }
+};
+
+// src/cubing/twisty/model/props/puzzle/display/StickeringProp.ts
 var experimentalStickerings = {
   "full": true,
   "centers-only": true,
@@ -432,88 +418,21 @@ var experimentalStickerings = {
   "experimental-global-custom-1": true,
   "experimental-global-custom-2": true
 };
-var controlsLocations = {
-  "bottom-row": true,
-  "none": true
-};
-var puzzleIDs = {
-  "3x3x3": true,
-  "custom": true,
-  "2x2x2": true,
-  "4x4x4": true,
-  "5x5x5": true,
-  "6x6x6": true,
-  "7x7x7": true,
-  "40x40x40": true,
-  "megaminx": true,
-  "pyraminx": true,
-  "square1": true,
-  "clock": true,
-  "skewb": true,
-  "fto": true,
-  "gigaminx": true,
-  "master_tetraminx": true
-};
-var viewerLinkPages = {
-  twizzle: true,
-  none: true
-};
-var cameraLatitudeLimits = {
-  auto: true,
-  none: true
-};
-var twistyPlayerAttributeMap = {
-  "alg": "alg",
-  "experimental-setup-alg": "experimentalSetupAlg",
-  "experimental-setup-anchor": "experimentalSetupAnchor",
-  "puzzle": "puzzle",
-  "visualization": "visualization",
-  "hint-facelets": "hintFacelets",
-  "experimental-stickering": "experimentalStickering",
-  "background": "background",
-  "control-panel": "controlPanel",
-  "back-view": "backView",
-  "experimental-camera-latitude": "experimentalCameraLatitude",
-  "experimental-camera-longitude": "experimentalCameraLongitude",
-  "experimental-camera-latitude-limits": "experimentalCameraLatitudeLimits",
-  "viewer-link": "viewerLink"
-};
-var TwistyPlayerConfig = class {
-  constructor(twistyPlayer, initialValues) {
-    this.twistyPlayer = twistyPlayer;
-    this.attributes = {
-      "alg": new AlgAttribute(initialValues.alg),
-      "experimental-setup-alg": new AlgAttribute(initialValues.experimentalSetupAlg),
-      "experimental-setup-anchor": new StringEnumAttribute(setupToLocations, initialValues.experimentalSetupAnchor),
-      "puzzle": new StringEnumAttribute(puzzleIDs, initialValues.puzzle),
-      "visualization": new StringEnumAttribute(visualizationFormats, initialValues.visualization),
-      "hint-facelets": new StringEnumAttribute(hintFaceletStyles, initialValues.hintFacelets),
-      "experimental-stickering": new StringEnumAttribute(experimentalStickerings, initialValues.experimentalStickering),
-      "background": new StringEnumAttribute(backgroundThemes, initialValues.background),
-      "control-panel": new StringEnumAttribute(controlsLocations, initialValues.controlPanel),
-      "back-view": new StringEnumAttribute(backViewLayouts, initialValues["backView"]),
-      "experimental-camera-latitude": new RangedFloatAttribute(null, -90, 90, initialValues["experimentalCameraLatitude"]),
-      "experimental-camera-longitude": new RangedFloatAttribute(null, -180, 180, initialValues["experimentalCameraLongitude"]),
-      "experimental-camera-latitude-limits": new StringEnumAttribute(cameraLatitudeLimits, initialValues["experimentalCameraLatitudeLimits"]),
-      "viewer-link": new StringEnumAttribute(viewerLinkPages, initialValues.viewerLink)
-    };
-  }
-  static get observedAttributes() {
-    return Object.keys(twistyPlayerAttributeMap);
-  }
-  attributeChangedCallback(attributeName, oldValue, newValue) {
-    const managedAttribute = this.attributes[attributeName];
-    if (managedAttribute) {
-      if (oldValue !== null && managedAttribute.string !== oldValue) {
-        console.warn("Attribute out of sync!", attributeName, managedAttribute.string, oldValue);
-      }
-      managedAttribute.setString(newValue);
-      const propertyName = twistyPlayerAttributeMap[attributeName];
-      this.twistyPlayer[propertyName] = managedAttribute.value;
-    }
+var StickeringProp = class extends SimpleTwistyPropSource {
+  getDefaultValue() {
+    return "full";
   }
 };
 
+// src/cubing/twisty/controllers/easing.ts
+function smootherStep(x) {
+  return x * x * x * (10 - x * (15 - 6 * x));
+}
+
+// src/cubing/twisty/views/3D/TAU.ts
+var TAU = Math.PI * 2;
+var DEGREES_PER_RADIAN = 360 / TAU;
+
 // src/cubing/twisty/views/3D/puzzles/Cube3D.ts
 var svgLoader = new TextureLoader();
 var ignoredMaterial = new MeshBasicMaterial({
@@ -578,12 +497,12 @@ var AxisInfo = class {
   }
 };
 var axesInfo = [
-  new AxisInfo(new Vector32(0, 1, 0), new Euler(-TAU / 4, 0, 0), 16777215, 14540253, 1.25),
-  new AxisInfo(new Vector32(-1, 0, 0), new Euler(0, -TAU / 4, 0), 16746496, 8930304, 1),
-  new AxisInfo(new Vector32(0, 0, 1), new Euler(0, 0, 0), 65280, 34816, 1),
-  new AxisInfo(new Vector32(1, 0, 0), new Euler(0, TAU / 4, 0), 16711680, 6684672, 1),
-  new AxisInfo(new Vector32(0, 0, -1), new Euler(0, TAU / 2, 0), 255, 136, 0.75, { hintColor: 17663, hintDimColor: 8840 }),
-  new AxisInfo(new Vector32(0, -1, 0), new Euler(TAU / 4, 0, 0), 16776960, 8947712, 1.25)
+  new AxisInfo(new Vector3(0, 1, 0), new Euler(-TAU / 4, 0, 0), 16777215, 14540253, 1.25),
+  new AxisInfo(new Vector3(-1, 0, 0), new Euler(0, -TAU / 4, 0), 16746496, 8930304, 1),
+  new AxisInfo(new Vector3(0, 0, 1), new Euler(0, 0, 0), 65280, 34816, 1),
+  new AxisInfo(new Vector3(1, 0, 0), new Euler(0, TAU / 4, 0), 16711680, 6684672, 1),
+  new AxisInfo(new Vector3(0, 0, -1), new Euler(0, TAU / 2, 0), 255, 136, 0.75, { hintColor: 17663, hintDimColor: 8840 }),
+  new AxisInfo(new Vector3(0, -1, 0), new Euler(TAU / 4, 0, 0), 16776960, 8947712, 1.25)
 ];
 var face = {
   U: 0,
@@ -664,18 +583,18 @@ function t(v, t4) {
   return new Quaternion().setFromAxisAngle(v, TAU * t4 / 4);
 }
 var r = {
-  O: new Vector32(0, 0, 0),
-  U: new Vector32(0, -1, 0),
-  L: new Vector32(1, 0, 0),
-  F: new Vector32(0, 0, -1),
-  R: new Vector32(-1, 0, 0),
-  B: new Vector32(0, 0, 1),
-  D: new Vector32(0, 1, 0)
+  O: new Vector3(0, 0, 0),
+  U: new Vector3(0, -1, 0),
+  L: new Vector3(1, 0, 0),
+  F: new Vector3(0, 0, -1),
+  R: new Vector3(-1, 0, 0),
+  B: new Vector3(0, 0, 1),
+  D: new Vector3(0, 1, 0)
 };
 var firstPiecePosition = {
-  EDGES: new Vector32(0, 1, 1),
-  CORNERS: new Vector32(1, 1, 1),
-  CENTERS: new Vector32(0, 1, 0)
+  EDGES: new Vector3(0, 1, 1),
+  CORNERS: new Vector3(1, 1, 1),
+  CENTERS: new Vector3(0, 1, 0)
 };
 var orientationRotation = {
   EDGES: [0, 1].map((i) => new Matrix4().makeRotationAxis(firstPiecePosition.EDGES.clone().normalize(), -i * TAU / 2)),
@@ -880,7 +799,7 @@ function sharedStickerGeometry() {
   return sharedStickerGeometryCache ?? (sharedStickerGeometryCache = newStickerGeometry());
 }
 var Cube3D = class extends Object3D {
-  constructor(def, cursor, scheduleRenderCallback, options = {}) {
+  constructor(def, scheduleRenderCallback, options = {}) {
     super();
     this.def = def;
     this.scheduleRenderCallback = scheduleRenderCallback;
@@ -918,7 +837,6 @@ var Cube3D = class extends Object3D {
     if (this.options.experimentalStickering) {
       this.setStickering(this.options.experimentalStickering);
     }
-    cursor?.addPositionListener(this);
   }
   setSprite(texture) {
     this.sprite = texture;
@@ -1142,7 +1060,7 @@ import {
   Mesh as Mesh2,
   MeshBasicMaterial as MeshBasicMaterial2,
   Object3D as Object3D2,
-  Vector3 as Vector33
+  Vector3 as Vector32
 } from "three";
 var foundationMaterial = new MeshBasicMaterial2({
   side: DoubleSide2,
@@ -1434,7 +1352,7 @@ var StickerDef = class {
   }
 };
 var HitPlaneDef = class {
-  constructor(hitface, tm) {
+  constructor(hitface, tm, stickerDat) {
     this.cubie = new Group2();
     const coords = hitface.coords;
     const filler = new Filler(coords.length / 3 - 2, tm);
@@ -1446,35 +1364,38 @@ var HitPlaneDef = class {
     this.geo = new BufferGeometry2();
     filler.setAttributes(this.geo);
     const obj = new Mesh2(this.geo, invisMaterial);
-    obj.userData.name = hitface.name;
+    obj.userData.quantumMove = stickerDat.notationMapper.notationToExternal(new Move(hitface.name));
     this.cubie.scale.setScalar(0.99);
     this.cubie.add(obj);
   }
 };
 var AxisInfo2 = class {
   constructor(axisDat) {
-    const vec = axisDat[0];
-    this.axis = new Vector33(vec[0], vec[1], vec[2]);
-    this.order = axisDat[2];
+    const vec = axisDat.coordinates;
+    this.axis = new Vector32(vec[0], vec[1], vec[2]);
+    this.order = axisDat.order;
   }
 };
 var DEFAULT_COLOR_FRACTION = 0.71;
 var PG_SCALE = 0.5;
-var _pendingStickeringUpdate;
+var _pendingStickeringUpdate, _cachedKPuzzle, _kpuzzle, kpuzzle_get, _isValidMove, isValidMove_fn;
 var PG3D = class extends Object3D2 {
-  constructor(cursor, scheduleRenderCallback, definition, pgdat, showFoundation = false, showHintStickers = false, hintStickerHeightScale = 1, params = {}) {
+  constructor(scheduleRenderCallback, definition, stickerDat, enableFoundationOpt = false, enableHintStickersOpt = false, hintStickerHeightScale = 1, params = {}) {
     super();
     this.scheduleRenderCallback = scheduleRenderCallback;
     this.definition = definition;
-    this.pgdat = pgdat;
-    this.showFoundation = showFoundation;
-    this.showHintStickers = showHintStickers;
+    this.stickerDat = stickerDat;
     this.params = params;
+    __privateAdd(this, _kpuzzle);
+    __privateAdd(this, _isValidMove);
     this.stickerTargets = [];
     this.controlTargets = [];
     this.textured = false;
+    this.showHintStickers = false;
+    this.showFoundations = false;
     __privateAdd(this, _pendingStickeringUpdate, false);
-    if (pgdat.stickers.length === 0) {
+    __privateAdd(this, _cachedKPuzzle, void 0);
+    if (stickerDat.stickers.length === 0) {
       throw Error("Reuse of stickerdat from pg; please don't do that.");
     }
     this.hintMaterial = new MeshBasicMaterial2({
@@ -1486,27 +1407,27 @@ var PG3D = class extends Object3D2 {
     this.stickerMaterial = basicStickerMaterial;
     this.stickerMaterialDisposable = false;
     this.axesInfo = {};
-    const axesDef = this.pgdat.axis;
+    const axesDef = this.stickerDat.axis;
     for (const axis of axesDef) {
-      this.axesInfo[axis[1]] = new AxisInfo2(axis);
+      this.axesInfo[axis.quantumMove.family] = new AxisInfo2(axis);
     }
-    const stickers = this.pgdat.stickers;
+    const stickers = this.stickerDat.stickers;
     this.stickers = {};
     this.materialArray1 = new Array(8);
     this.materialArray2 = new Array(8);
-    this.enableFoundation(showFoundation);
-    this.updateMaterialArrays();
+    this.showFoundation(enableFoundationOpt);
+    enableFoundationOpt = true;
     let triangleCount = 0;
     const multiplier = 3;
     for (const sticker of stickers) {
       const sides = sticker.coords.length / 3;
       triangleCount += multiplier * (sides - 2);
     }
-    const filler = new Filler(triangleCount, pgdat.textureMapper);
+    const filler = new Filler(triangleCount, stickerDat.textureMapper);
     const black = 0;
     const normals = [];
     let totArea = 0;
-    for (const f of pgdat.faces) {
+    for (const f of stickerDat.faces) {
       normals.push(normal(f.coords));
       totArea += polyarea(f.coords);
     }
@@ -1535,18 +1456,22 @@ var PG3D = class extends Object3D2 {
       const stickerdef = new StickerDef(filler, sticker, trim, options);
       this.stickers[orbit][ori][ord] = stickerdef;
     }
+    this.showHintStickers = enableHintStickersOpt;
+    enableHintStickersOpt = true;
     for (const sticker of stickers) {
       const orbit = sticker.orbit;
       const ord = sticker.ord;
       const ori = sticker.ori;
-      this.stickers[orbit][ori][ord].addHint(filler, sticker, showHintStickers, hintStickerHeightScale, trim, normals[sticker.face]);
+      this.stickers[orbit][ori][ord].addHint(filler, sticker, enableHintStickersOpt, hintStickerHeightScale, trim, normals[sticker.face]);
     }
     this.foundationBound = filler.ipos;
     for (const sticker of stickers) {
       const orbit = sticker.orbit;
       const ord = sticker.ord;
       const ori = sticker.ori;
-      this.stickers[orbit][ori][ord].addFoundation(filler, sticker, black);
+      if (enableFoundationOpt) {
+        this.stickers[orbit][ori][ord].addFoundation(filler, sticker, black);
+      }
     }
     const fixedGeo = new BufferGeometry2();
     filler.setAttributes(fixedGeo);
@@ -1557,19 +1482,19 @@ var PG3D = class extends Object3D2 {
     const obj2 = new Mesh2(fixedGeo, this.materialArray2);
     obj2.scale.set(PG_SCALE, PG_SCALE, PG_SCALE);
     this.add(obj2);
-    const hitfaces = this.pgdat.faces;
+    const hitfaces = this.stickerDat.faces;
     this.movingObj = obj2;
     this.fixedGeo = fixedGeo;
     this.filler = filler;
     for (const hitface of hitfaces) {
-      const facedef = new HitPlaneDef(hitface, pgdat.textureMapper);
+      const facedef = new HitPlaneDef(hitface, stickerDat.textureMapper, this.stickerDat);
       facedef.cubie.scale.set(PG_SCALE, PG_SCALE, PG_SCALE);
       this.add(facedef.cubie);
       this.controlTargets.push(facedef.cubie.children[0]);
     }
     filler.saveOriginalColors();
-    cursor.addPositionListener(this);
-    pgdat.stickers = [];
+    stickerDat.stickers = [];
+    this.updateMaterialArrays();
   }
   dispose() {
     if (this.fixedGeo) {
@@ -1592,6 +1517,42 @@ var PG3D = class extends Object3D2 {
   experimentalGetControlTargets() {
     return this.controlTargets;
   }
+  getClosestMoveToAxis(point, transformations) {
+    let closestMove = null;
+    let closestMoveDotProduct = 0;
+    let modify = (m) => m;
+    switch (transformations.depth) {
+      case "secondSlice":
+        modify = (m) => m.modified({ innerLayer: 2 });
+        break;
+      case "rotation":
+        modify = (m) => m.modified({ family: m.family + "v" });
+        break;
+    }
+    for (const axis of this.stickerDat.axis) {
+      const product = point.dot(new Vector32(...axis.coordinates));
+      if (product > closestMoveDotProduct) {
+        const modified = this.stickerDat.notationMapper.notationToExternal(modify(axis.quantumMove));
+        if (!modified) {
+          continue;
+        }
+        if (__privateMethod(this, _isValidMove, isValidMove_fn).call(this, modified)) {
+          closestMoveDotProduct = product;
+          closestMove = modified;
+        }
+      }
+    }
+    if (!closestMove) {
+      return null;
+    }
+    if (transformations.invert) {
+      closestMove = closestMove.invert();
+    }
+    __privateGet(this, _kpuzzle, kpuzzle_get).reset();
+    __privateGet(this, _kpuzzle, kpuzzle_get).applyMove(closestMove);
+    const order = transformationOrder(this.definition, __privateGet(this, _kpuzzle, kpuzzle_get).state);
+    return { move: closestMove, order };
+  }
   experimentalSetAppearance(appearance) {
     this.params.appearance = appearance;
     for (const orbitName in this.definition.orbits) {
@@ -1655,8 +1616,8 @@ var PG3D = class extends Object3D2 {
     let vismods = 0;
     for (const moveProgress of p.movesInProgress) {
       const externalMove = moveProgress.move;
-      const unswizzled = this.pgdat.unswizzle(externalMove);
-      const move = this.pgdat.notationMapper.notationToInternal(externalMove);
+      const unswizzled = this.stickerDat.unswizzle(externalMove);
+      const move = this.stickerDat.notationMapper.notationToInternal(externalMove);
       if (move === null) {
         throw Error("Bad blockmove " + externalMove.family);
       }
@@ -1733,9 +1694,8 @@ var PG3D = class extends Object3D2 {
   ease(fraction) {
     return smootherStep(fraction);
   }
-  enableHintFacelets(v) {
+  showHintFacelets(v) {
     this.showHintStickers = v;
-    this.updateMaterialArrays();
   }
   updateMaterialArrays() {
     for (let i = 0; i < 8; i++) {
@@ -1751,7 +1711,7 @@ var PG3D = class extends Object3D2 {
       this.materialArray1[2] = invisMaterial;
       this.materialArray2[3] = invisMaterial;
     }
-    if (this.showFoundation) {
+    if (this.showFoundations) {
       this.materialArray1[6] = foundationMaterial;
       this.materialArray2[7] = foundationMaterial;
     } else {
@@ -1759,15 +1719,15 @@ var PG3D = class extends Object3D2 {
       this.materialArray2[7] = invisMaterial;
     }
   }
-  enableFoundation(v) {
-    this.showFoundation = v;
-    this.updateMaterialArrays();
+  showFoundation(v) {
+    this.showFoundations = v;
   }
   setHintStickerOpacity(v) {
     if (this.hintMaterialDisposable) {
       this.hintMaterial.dispose();
       this.hintMaterialDisposable = false;
     }
+    console.log("hint sticker opacity " + v);
     if (v === 0) {
       this.hintMaterial = invisMaterial;
     } else if (v === 1) {
@@ -1783,10 +1743,10 @@ var PG3D = class extends Object3D2 {
   }
   experimentalUpdateOptions(options) {
     if (options.hintFacelets !== void 0) {
-      this.enableHintFacelets(options.hintFacelets !== "none");
+      this.showHintFacelets(options.hintFacelets !== "none");
     }
     if (options.showFoundation !== void 0) {
-      this.enableFoundation(options.showFoundation);
+      this.showFoundation(options.showFoundation);
     }
     if (options.hintStickerOpacity !== void 0) {
       this.setHintStickerOpacity(options.hintStickerOpacity);
@@ -1795,6 +1755,7 @@ var PG3D = class extends Object3D2 {
     if (this.lastPos) {
       this.onPositionChange(this.lastPos);
     }
+    this.updateMaterialArrays();
     this.scheduleRenderCallback();
   }
   adduvs() {
@@ -1864,595 +1825,23 @@ var PG3D = class extends Object3D2 {
   }
 };
 _pendingStickeringUpdate = new WeakMap();
-
-// src/cubing/twisty/old/dom/viewers/Twisty3DCanvas.ts
-import { PerspectiveCamera, Vector3 as Vector35, WebGLRenderer } from "three";
-
-// src/cubing/twisty/old/animation/RenderScheduler.ts
-var RenderScheduler = class {
-  constructor(callback) {
-    this.callback = callback;
-    this.animFrameID = null;
-    this.animFrame = this.animFrameWrapper.bind(this);
-  }
-  requestAnimFrame() {
-    if (!this.animFrameID) {
-      this.animFrameID = requestAnimationFrame(this.animFrame);
-    }
-  }
-  cancelAnimFrame() {
-    if (this.animFrameID) {
-      cancelAnimationFrame(this.animFrameID);
-      this.animFrameID = 0;
-    }
-  }
-  animFrameWrapper(timestamp) {
-    this.animFrameID = 0;
-    this.callback(timestamp);
-  }
+_cachedKPuzzle = new WeakMap();
+_kpuzzle = new WeakSet();
+kpuzzle_get = function() {
+  return __privateGet(this, _cachedKPuzzle) ?? __privateSet(this, _cachedKPuzzle, new KPuzzle(this.definition));
 };
-
-// src/cubing/twisty/old/dom/viewers/canvas.ts
-var globalPixelRatioOverride = null;
-function pixelRatio() {
-  return globalPixelRatioOverride ?? (devicePixelRatio || 1);
-}
-
-// src/cubing/twisty/old/dom/viewers/Twisty3DCanvas.css.ts
-var twisty3DCanvasCSS = new CSSSource(`
-:host {
-  width: 384px;
-  height: 256px;
-  display: grid;
-}
-
-.wrapper {
-  width: 100%;
-  height: 100%;
-  display: grid;
-  overflow: hidden;
-}
-
-/* TODO: This is due to stats hack. Replace with \`canvas\`. */
-.wrapper > canvas {
-  max-width: 100%;
-  max-height: 100%;
-}
-
-.wrapper.invisible {
-  opacity: 0;
-}
-`);
-
-// src/cubing/twisty/old/dom/viewers/TwistyOrbitControls.ts
-import { Spherical, Vector3 as Vector34 } from "three";
-var EPSILON = 1e-8;
-var INERTIA_DEFAULT = true;
-var LATITUDE_LIMITS_DEFAULT = "auto";
-var INERTIA_DURATION_MS = 500;
-var INERTIA_TIMEOUT_MS = 50;
-var VERTICAL_MOVEMENT_BASE_SCALE = 0.75;
-function momentumScale(progress) {
-  return (Math.exp(1 - progress) - (1 - progress)) / (1 - Math.E) + 1;
-}
-var Inertia = class {
-  constructor(startTimestamp, momentumX, momentumY, callback) {
-    this.startTimestamp = startTimestamp;
-    this.momentumX = momentumX;
-    this.momentumY = momentumY;
-    this.callback = callback;
-    this.scheduler = new RenderScheduler(this.render.bind(this));
-    this.scheduler.requestAnimFrame();
-    this.lastTimestamp = startTimestamp;
-  }
-  render(now) {
-    const progressBefore = (this.lastTimestamp - this.startTimestamp) / INERTIA_DURATION_MS;
-    const progressAfter = Math.min(1, (now - this.startTimestamp) / INERTIA_DURATION_MS);
-    if (progressBefore === 0 && progressAfter > INERTIA_TIMEOUT_MS / INERTIA_DURATION_MS) {
-      return;
-    }
-    const delta = momentumScale(progressAfter) - momentumScale(progressBefore);
-    this.callback(this.momentumX * delta * 1e3, this.momentumY * delta * 1e3);
-    if (progressAfter < 1) {
-      this.scheduler.requestAnimFrame();
-    }
-    this.lastTimestamp = now;
-  }
-};
-var _spherical, _lookAt, _adjust, adjust_fn, _acceptPropagation, _propagateSpherical, propagateSpherical_fn;
-var TwistyOrbitControls = class {
-  constructor(camera, canvas, scheduleRender) {
-    this.camera = camera;
-    this.canvas = canvas;
-    this.scheduleRender = scheduleRender;
-    __privateAdd(this, _adjust);
-    __privateAdd(this, _propagateSpherical);
-    __privateAdd(this, _spherical, new Spherical());
-    __privateAdd(this, _lookAt, new Vector34(0, 0, 0));
-    this.experimentalInertia = INERTIA_DEFAULT;
-    this.experimentalLatitudeLimits = LATITUDE_LIMITS_DEFAULT;
-    this.lastTouchClientX = 0;
-    this.lastTouchClientY = 0;
-    this.currentTouchID = null;
-    this.onMoveBound = this.onMove.bind(this);
-    this.onMouseMoveBound = this.onMouseMove.bind(this);
-    this.onMouseEndBound = this.onMouseEnd.bind(this);
-    this.onTouchMoveBound = this.onTouchMove.bind(this);
-    this.onTouchEndBound = this.onTouchEnd.bind(this);
-    this.lastTouchTimestamp = 0;
-    this.lastTouchMoveMomentumX = 0;
-    this.lastTouchMoveMomentumY = 0;
-    this.lastMouseTimestamp = 0;
-    this.lastMouseMoveMomentumX = 0;
-    this.lastMouseMoveMomentumY = 0;
-    this.experimentalHasBeenMoved = false;
-    __privateAdd(this, _acceptPropagation, true);
-    __privateGet(this, _spherical).setFromVector3(camera.position);
-    __privateMethod(this, _propagateSpherical, propagateSpherical_fn).call(this);
-    canvas.addEventListener("mousedown", this.onMouseStart.bind(this));
-    canvas.addEventListener("touchstart", this.onTouchStart.bind(this));
-  }
-  lookAt(v) {
-    if (!__privateGet(this, _acceptPropagation)) {
-      return;
-    }
-    __privateSet(this, _lookAt, v);
-    __privateSet(this, _acceptPropagation, false);
-    __privateMethod(this, _adjust, adjust_fn).call(this);
-    this.scheduleRender();
-    try {
-      if (this.mirrorControls) {
-        this.mirrorControls.lookAt(v);
-      }
-    } finally {
-      __privateSet(this, _acceptPropagation, true);
-    }
-  }
-  set latitude(newLatitude) {
-    __privateGet(this, _spherical).phi = (90 - newLatitude) / DEGREES_PER_RADIAN;
-    __privateMethod(this, _propagateSpherical, propagateSpherical_fn).call(this);
-  }
-  get latitude() {
-    return 90 - __privateGet(this, _spherical).phi * DEGREES_PER_RADIAN;
-  }
-  set longitude(newLongitude) {
-    __privateGet(this, _spherical).theta = newLongitude / DEGREES_PER_RADIAN;
-    __privateMethod(this, _propagateSpherical, propagateSpherical_fn).call(this);
-  }
-  get longitude() {
-    return __privateGet(this, _spherical).theta * DEGREES_PER_RADIAN;
-  }
-  set distance(newDistance) {
-    __privateGet(this, _spherical).radius = newDistance;
-    __privateMethod(this, _propagateSpherical, propagateSpherical_fn).call(this);
-  }
-  get distance() {
-    return __privateGet(this, _spherical).radius;
-  }
-  get orbitCoordinates() {
-    return {
-      latitude: this.latitude,
-      longitude: this.longitude,
-      distance: this.distance
-    };
-  }
-  set orbitCoordinates(orbitCoordinates) {
-    this.latitude = orbitCoordinates.latitude;
-    this.longitude = orbitCoordinates.longitude;
-    this.distance = orbitCoordinates.distance;
-  }
-  temperMovement(f) {
-    return Math.sign(f) * Math.log(Math.abs(f * 10) + 1) / 6;
-  }
-  onMouseStart(e) {
-    this.experimentalHasBeenMoved = true;
-    window.addEventListener("mousemove", this.onMouseMoveBound);
-    window.addEventListener("mouseup", this.onMouseEndBound);
-    this.onStart(e);
-    this.lastMouseTimestamp = e.timeStamp;
-  }
-  onMouseMove(e) {
-    if (e.buttons === 0) {
-      this.onMouseEnd(e);
-      return;
-    }
-    if (e.movementX === 0 && e.movementY === 0) {
-      console.log("short-circuit mouse!");
-      return;
-    }
-    const minDim = Math.min(this.canvas.offsetWidth, this.canvas.offsetHeight);
-    const movementX = this.temperMovement(e.movementX / minDim);
-    const movementY = this.temperMovement(e.movementY / minDim * VERTICAL_MOVEMENT_BASE_SCALE);
-    this.onMove(movementX, movementY);
-    const deltaMs = e.timeStamp - this.lastMouseTimestamp;
-    if (deltaMs > 0) {
-      this.lastMouseMoveMomentumX = movementX / deltaMs;
-      this.lastMouseMoveMomentumY = movementY / deltaMs;
-      this.lastMouseTimestamp = e.timeStamp;
-    }
-  }
-  onMouseEnd(e) {
-    window.removeEventListener("mousemove", this.onMouseMoveBound);
-    window.removeEventListener("mouseup", this.onMouseEndBound);
-    this.onEnd(e);
-    if (this.experimentalInertia) {
-      new Inertia(this.lastMouseTimestamp, this.lastMouseMoveMomentumX, this.lastMouseMoveMomentumY, this.onMoveBound);
-    }
-  }
-  onTouchStart(e) {
-    this.experimentalHasBeenMoved = true;
-    if (this.currentTouchID === null) {
-      if (e.touches[0].clientX === 0 && e.touches[0].clientY === 0) {
-        console.log("short-circuit touch!");
-        return;
-      }
-      this.currentTouchID = e.changedTouches[0].identifier;
-      this.lastTouchClientX = e.touches[0].clientX;
-      this.lastTouchClientY = e.touches[0].clientY;
-      window.addEventListener("touchmove", this.onTouchMoveBound);
-      window.addEventListener("touchend", this.onTouchEndBound);
-      window.addEventListener("touchcancel", this.onTouchEndBound);
-      this.onStart(e);
-      this.lastTouchTimestamp = e.timeStamp;
-    }
-  }
-  onTouchMove(e) {
-    for (let i = 0; i < e.changedTouches.length; i++) {
-      const touch = e.changedTouches[i];
-      if (touch.identifier === this.currentTouchID) {
-        const minDim = Math.min(this.canvas.offsetWidth, this.canvas.offsetHeight);
-        const movementX = this.temperMovement((touch.clientX - this.lastTouchClientX) / minDim);
-        const movementY = this.temperMovement((touch.clientY - this.lastTouchClientY) / minDim * VERTICAL_MOVEMENT_BASE_SCALE);
-        this.onMove(movementX, movementY);
-        this.lastTouchClientX = touch.clientX;
-        this.lastTouchClientY = touch.clientY;
-        const deltaMs = e.timeStamp - this.lastTouchTimestamp;
-        if (deltaMs > 0) {
-          this.lastTouchMoveMomentumX = movementX / deltaMs;
-          this.lastTouchMoveMomentumY = movementY / deltaMs;
-          this.lastTouchTimestamp = e.timeStamp;
-        }
-      }
-    }
-  }
-  onTouchEnd(e) {
-    for (let i = 0; i < e.changedTouches.length; i++) {
-      const touch = e.changedTouches[i];
-      if (touch.identifier === this.currentTouchID) {
-        this.currentTouchID = null;
-        window.removeEventListener("touchmove", this.onTouchMoveBound);
-        window.removeEventListener("touchend", this.onTouchEndBound);
-        window.removeEventListener("touchcancel", this.onTouchEndBound);
-        this.onEnd(e);
-      }
-    }
-    if (this.experimentalInertia) {
-      new Inertia(this.lastTouchTimestamp, this.lastTouchMoveMomentumX, this.lastTouchMoveMomentumY, this.onMoveBound);
-    }
-  }
-  onStart(e) {
-    e.preventDefault();
-  }
-  onMove(movementX, movementY) {
-    const newSpherical = new Spherical();
-    newSpherical.copy(__privateGet(this, _spherical));
-    newSpherical.theta += -2 * movementX;
-    newSpherical.phi += -2 * movementY;
-    if (this.experimentalLatitudeLimits !== "none") {
-      newSpherical.phi = Math.max(newSpherical.phi, Math.PI * 0.3);
-      newSpherical.phi = Math.min(newSpherical.phi, Math.PI * 0.7);
-    } else {
-      newSpherical.phi = Math.max(newSpherical.phi, EPSILON);
-      newSpherical.phi = Math.min(newSpherical.phi, Math.PI - EPSILON);
-    }
-    if (isNaN(newSpherical.theta) || newSpherical.theta === Infinity || newSpherical.theta === -Infinity) {
-      return;
-    }
-    if (isNaN(newSpherical.phi) || newSpherical.phi === Infinity || newSpherical.phi === -Infinity) {
-      return;
-    }
-    __privateSet(this, _spherical, newSpherical);
-    __privateMethod(this, _propagateSpherical, propagateSpherical_fn).call(this);
-  }
-  onEnd(e) {
-    e.preventDefault();
-  }
-  setMirror(m) {
-    this.mirrorControls = m;
-  }
-  updateMirroredCamera(orbitCoordinates) {
-    if (__privateGet(this, _acceptPropagation)) {
-      this.latitude = -orbitCoordinates.latitude;
-      this.longitude = orbitCoordinates.longitude + 180;
-      this.distance = orbitCoordinates.distance;
-      __privateMethod(this, _adjust, adjust_fn).call(this);
-      this.scheduleRender();
-    }
-  }
-};
-_spherical = new WeakMap();
-_lookAt = new WeakMap();
-_adjust = new WeakSet();
-adjust_fn = function() {
-  __privateGet(this, _spherical).makeSafe();
-  this.camera.position.setFromSpherical(__privateGet(this, _spherical));
-  this.camera.lookAt(__privateGet(this, _lookAt));
-};
-_acceptPropagation = new WeakMap();
-_propagateSpherical = new WeakSet();
-propagateSpherical_fn = function() {
-  __privateSet(this, _acceptPropagation, false);
+_isValidMove = new WeakSet();
+isValidMove_fn = function(move) {
   try {
-    __privateMethod(this, _adjust, adjust_fn).call(this);
-    this.scheduleRender();
-    this.mirrorControls?.updateMirroredCamera({
-      latitude: this.latitude,
-      longitude: this.longitude,
-      distance: this.distance
-    });
-  } finally {
-    __privateSet(this, _acceptPropagation, true);
-  }
-};
-
-// src/cubing/vendor/three/examples/jsm/libs/stats.modified.module.ts
-var performance = globalThis.performance;
-var Stats = class {
-  constructor() {
-    this.mode = 0;
-    this.dom = document.createElement("div");
-    this.beginTime = (performance || Date).now();
-    this.prevTime = this.beginTime;
-    this.frames = 0;
-    this.fpsPanel = this.addPanel(new StatsPanel("FPS", "#0ff", "#002"));
-    this.msPanel = this.addPanel(new StatsPanel("MS", "#0f0", "#020"));
-    this.memPanel = performance?.memory ? this.addPanel(new StatsPanel("MB", "#f08", "#201")) : null;
-    this.REVISION = 16;
-    this.dom.style.cssText = "position:fixed;top:0;left:0;cursor:pointer;opacity:0.9;z-index:10000";
-    this.dom.addEventListener("click", (event) => {
-      event.preventDefault();
-      this.showPanel(++this.mode % this.dom.children.length);
-    }, false);
-    this.showPanel(0);
-  }
-  addPanel(panel) {
-    this.dom.appendChild(panel.dom);
-    return panel;
-  }
-  showPanel(id) {
-    for (let i = 0; i < this.dom.children.length; i++) {
-      this.dom.children[i].style.display = i === id ? "block" : "none";
-    }
-    this.mode = id;
-  }
-  begin() {
-    this.beginTime = (performance || Date).now();
-  }
-  end() {
-    this.frames++;
-    const time = (performance || Date).now();
-    this.msPanel.update(time - this.beginTime, 200);
-    if (time >= this.prevTime + 1e3) {
-      this.fpsPanel.update(this.frames * 1e3 / (time - this.prevTime), 100);
-      this.prevTime = time;
-      this.frames = 0;
-      if (this.memPanel) {
-        const memory = performance.memory;
-        this.memPanel.update(memory.usedJSHeapSize / 1048576, memory.jsHeapSizeLimit / 1048576);
-      }
-    }
-    return time;
-  }
-  update() {
-    this.beginTime = this.end();
-  }
-};
-var PR = Math.round(globalThis?.window?.devicePixelRatio ?? 1);
-var WIDTH = 80 * PR;
-var HEIGHT = 48 * PR;
-var TEXT_X = 3 * PR;
-var TEXT_Y = 2 * PR;
-var GRAPH_X = 3 * PR;
-var GRAPH_Y = 15 * PR;
-var GRAPH_WIDTH = 74 * PR;
-var GRAPH_HEIGHT = 30 * PR;
-var StatsPanel = class {
-  constructor(name, fg, bg) {
-    this.name = name;
-    this.fg = fg;
-    this.bg = bg;
-    this.min = Infinity;
-    this.max = 0;
-    this.dom = document.createElement("canvas");
-    this.context = this.dom.getContext("2d");
-    this.dom.width = WIDTH;
-    this.dom.height = HEIGHT;
-    this.dom.style.cssText = "width:80px;height:48px";
-    this.context.font = `bold ${9 * PR}px Helvetica,Arial,sans-serif`;
-    this.context.textBaseline = "top";
-    this.context.fillStyle = bg;
-    this.context.fillRect(0, 0, WIDTH, HEIGHT);
-    this.context.fillStyle = fg;
-    this.context.fillText(name, TEXT_X, TEXT_Y);
-    this.context.fillRect(GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT);
-    this.context.fillStyle = bg;
-    this.context.globalAlpha = 0.9;
-    this.context.fillRect(GRAPH_X, GRAPH_Y, GRAPH_WIDTH, GRAPH_HEIGHT);
-  }
-  update(value, maxValue) {
-    this.min = Math.min(this.min, value);
-    this.max = Math.max(this.max, value);
-    this.context.fillStyle = this.bg;
-    this.context.globalAlpha = 1;
-    this.context.fillRect(0, 0, WIDTH, GRAPH_Y);
-    this.context.fillStyle = this.fg;
-    this.context.fillText(Math.round(value) + " " + this.name + " (" + Math.round(this.min) + "-" + Math.round(this.max) + ")", TEXT_X, TEXT_Y);
-    this.context.drawImage(this.dom, GRAPH_X + PR, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT, GRAPH_X, GRAPH_Y, GRAPH_WIDTH - PR, GRAPH_HEIGHT);
-    this.context.fillRect(GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, GRAPH_HEIGHT);
-    this.context.fillStyle = this.bg;
-    this.context.globalAlpha = 0.9;
-    this.context.fillRect(GRAPH_X + GRAPH_WIDTH - PR, GRAPH_Y, PR, Math.round((1 - value / maxValue) * GRAPH_HEIGHT));
+    __privateGet(this, _kpuzzle, kpuzzle_get).applyMove(move);
+    return true;
+  } catch (_) {
+    return false;
   }
 };
 
-// src/cubing/twisty/old/dom/viewers/Twisty3DCanvas.ts
-var SHOW_STATS = false;
-function experimentalShowRenderStats(show) {
-  SHOW_STATS = show;
-}
-var shareAllNewRenderers = false;
-var sharedRenderer = null;
-function newRenderer() {
-  return new WebGLRenderer({
-    antialias: true,
-    alpha: true
-  });
-}
-function newSharedRenderer() {
-  return sharedRenderer ?? (sharedRenderer = newRenderer());
-}
-var _invisible, _onRenderFinish, _resize, resize_fn;
-var Twisty3DCanvas = class extends ManagedCustomElement {
-  constructor(scene, options = {}) {
-    super();
-    __privateAdd(this, _resize);
-    this.legacyExperimentalShift = 0;
-    this.scheduler = new RenderScheduler(this.render.bind(this));
-    this.resizePending = false;
-    this.stats = null;
-    __privateAdd(this, _invisible, false);
-    __privateAdd(this, _onRenderFinish, null);
-    this.addCSS(twisty3DCanvasCSS);
-    this.scene = scene;
-    this.scene?.addRenderTarget(this);
-    if (SHOW_STATS) {
-      this.stats = new Stats();
-      this.stats.dom.style.position = "absolute";
-      this.addElement(this.stats.dom);
-    }
-    this.rendererIsShared = shareAllNewRenderers;
-    this.renderer = this.rendererIsShared ? newSharedRenderer() : newRenderer();
-    this.canvas = this.rendererIsShared ? document.createElement("canvas") : this.renderer.domElement;
-    this.canvas2DContext = this.canvas.getContext("2d");
-    this.addElement(this.canvas);
-    this.camera = new PerspectiveCamera(20, 1, 0.1, 20);
-    this.camera.position.copy(new Vector35(2, 4, 4));
-    this.orbitControls = new TwistyOrbitControls(this.camera, this.canvas, this.scheduleRender.bind(this));
-    if (options.orbitCoordinates) {
-      this.orbitControls.latitude = options.orbitCoordinates.latitude * (options.negateCameraPosition ? -1 : 1);
-    }
-    if (options.orbitCoordinates) {
-      this.orbitControls.longitude = options.orbitCoordinates.longitude + (options.negateCameraPosition ? 180 : 0);
-    }
-    if (options.orbitCoordinates) {
-      this.orbitControls.distance = options.orbitCoordinates.distance;
-    }
-    this.camera.lookAt(new Vector35(0, 0, 0));
-    const observer = new ResizeObserver(this.onResize.bind(this));
-    observer.observe(this.contentWrapper);
-  }
-  setMirror(partner) {
-    this.orbitControls.setMirror(partner.orbitControls);
-    partner.orbitControls.setMirror(this.orbitControls);
-  }
-  experimentalSetLatitudeLimits(limits) {
-    this.orbitControls.experimentalLatitudeLimits = limits;
-  }
-  connectedCallback() {
-    __privateMethod(this, _resize, resize_fn).call(this);
-    this.render();
-  }
-  scheduleRender() {
-    this.scheduler.requestAnimFrame();
-  }
-  makeInvisibleUntilRender() {
-    this.contentWrapper.classList.add("invisible");
-    __privateSet(this, _invisible, true);
-  }
-  experimentalSetOnRenderFinish(f) {
-    __privateSet(this, _onRenderFinish, f);
-  }
-  render() {
-    this.stats?.begin();
-    this.scheduler.cancelAnimFrame();
-    if (this.resizePending) {
-      __privateMethod(this, _resize, resize_fn).call(this);
-    }
-    if (this.rendererIsShared) {
-      this.renderer.setSize(this.canvas.width, this.canvas.height, false);
-      this.canvas2DContext.clearRect(0, 0, this.canvas.width, this.canvas.height);
-    }
-    if (this.scene) {
-      this.renderer.render(this.scene, this.camera);
-    }
-    if (this.rendererIsShared) {
-      this.canvas2DContext.drawImage(this.renderer.domElement, 0, 0);
-    }
-    if (__privateGet(this, _invisible)) {
-      this.contentWrapper.classList.remove("invisible");
-    }
-    this.stats?.end();
-    if (__privateGet(this, _onRenderFinish)) {
-      __privateGet(this, _onRenderFinish).call(this);
-    }
-  }
-  onResize() {
-    this.resizePending = true;
-    this.scheduleRender();
-  }
-  renderToDataURL(options = {}) {
-    __privateMethod(this, _resize, resize_fn).call(this, options.minWidth, options.minHeight);
-    this.render();
-    let url;
-    if (!options.squareCrop || this.canvas.width === this.canvas.height) {
-      url = this.canvas.toDataURL();
-    } else {
-      const tempCanvas = document.createElement("canvas");
-      const squareSize = Math.min(this.canvas.width, this.canvas.height);
-      tempCanvas.width = squareSize;
-      tempCanvas.height = squareSize;
-      const tempCtx = tempCanvas.getContext("2d");
-      tempCtx.drawImage(this.canvas, -(this.canvas.width - squareSize) / 2, -(this.canvas.height - squareSize) / 2);
-      url = tempCanvas.toDataURL();
-    }
-    __privateMethod(this, _resize, resize_fn).call(this);
-    return url;
-  }
-};
-_invisible = new WeakMap();
-_onRenderFinish = new WeakMap();
-_resize = new WeakSet();
-resize_fn = function(minWidth = 0, minHeight = 0) {
-  this.resizePending = false;
-  const w = Math.max(this.contentWrapper.clientWidth, minWidth);
-  const h = Math.max(this.contentWrapper.clientHeight, minHeight);
-  let off = 0;
-  if (this.legacyExperimentalShift > 0) {
-    off = Math.max(0, Math.floor((w - h) * 0.5));
-  } else if (this.legacyExperimentalShift < 0) {
-    off = -Math.max(0, Math.floor((w - h) * 0.5));
-  }
-  let yoff = 0;
-  let excess = 0;
-  if (h > w) {
-    excess = h - w;
-    yoff = -Math.floor(0.5 * excess);
-  }
-  this.camera.aspect = w / h;
-  this.camera.setViewOffset(w, h - excess, off, yoff, w, h);
-  this.camera.updateProjectionMatrix();
-  if (this.rendererIsShared) {
-    this.canvas.width = w * pixelRatio();
-    this.canvas.height = h * pixelRatio();
-    this.canvas.style.width = w.toString();
-    this.canvas.style.height = w.toString();
-  } else {
-    this.renderer.setPixelRatio(pixelRatio());
-    this.renderer.setSize(w, h, true);
-  }
-  this.scheduleRender();
-};
-customElementsShim.define("twisty-3d-canvas", Twisty3DCanvas);
+// src/cubing/twisty/heavy-code-imports/dynamic-entries/3d.ts
+import * as T3I from "three";
 
 // src/cubing/twisty/views/3D/Twisty3DScene.ts
 import { Scene as ThreeScene } from "three";
@@ -2486,27 +1875,34 @@ var Twisty3DScene = class extends ThreeScene {
   }
 };
 
+// src/cubing/twisty/heavy-code-imports/dynamic-entries/3d.ts
+async function cube3DShim(options) {
+  const renderCallbackShim = () => {
+  };
+  return new Cube3D(await cube3x3x3.def(), renderCallbackShim, options);
+}
+async function pg3dShim(puzzleLoader, hintFacelets) {
+  const renderCallbackShim = () => {
+  };
+  return new PG3D(renderCallbackShim, await puzzleLoader.def(), (await puzzleLoader.pg()).get3d(), true, hintFacelets === "floating");
+}
+
 export {
-  RenderScheduler,
-  ClassListManager,
-  HTMLElementShim,
-  customElementsShim,
-  CSSSource,
-  ManagedCustomElement,
+  StaleDropper,
+  from,
+  TwistyPropSource,
+  SimpleTwistyPropSource,
+  NO_VALUE,
+  TwistyPropDerived,
+  FreshListenerManager,
+  HintFaceletProp,
+  StickeringProp,
   DEGREES_PER_RADIAN,
-  twistyViewerWrapperCSS,
-  TwistyViewerWrapper,
-  pyraminxLookAt,
-  defaultCameraOrbitCoordinates,
-  controlsLocations,
-  TwistyPlayerConfig,
   Cube3D,
   PG3D,
-  pixelRatio,
-  twisty3DCanvasCSS,
-  Stats,
-  experimentalShowRenderStats,
-  Twisty3DCanvas,
-  Twisty3DScene
+  Twisty3DScene,
+  cube3DShim,
+  pg3dShim,
+  T3I
 };
-//# sourceMappingURL=chunk-5DN4DAAX.js.map
+//# sourceMappingURL=chunk-DLN5QS4V.js.map