cubing 0.28.1 → 0.28.2

package/dist/esm/{chunk-LSVR2HCG.js → chunk-76UZ2QTB.js}

@@ -1,13 +1,6 @@
 import {
   from
-} from "./chunk-GVPTO3OF.js";
-import {
-  __privateAdd,
-  __privateGet,
-  __privateMethod,
-  __privateSet,
-  __privateWrapper
-} from "./chunk-MGJA5U5O.js";
+} from "./chunk-OX6O2ZO5.js";
 
 // src/cubing/twisty/debug.ts
 var twistyDebugGlobals = {
@@ -24,41 +17,16 @@ function setTwistyDebug(options) {
 }
 
 // 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 };
-    }
-  }
-};
-_latestAssignedIdx = new WeakMap();
-_latestResolvedIdx = new WeakMap();
-var _latestAssignedIdx2, _latestResolvedIdx2;
 var StaleDropper = class {
-  constructor() {
-    __privateAdd(this, _latestAssignedIdx2, 0);
-    __privateAdd(this, _latestResolvedIdx2, 0);
-  }
+  #latestAssignedIdx = 0;
+  #latestResolvedIdx = 0;
   queue(p) {
     return new Promise(async (resolve, reject) => {
       try {
-        const idx = ++__privateWrapper(this, _latestAssignedIdx2)._;
+        const idx = ++this.#latestAssignedIdx;
         const result = await p;
-        if (idx > __privateGet(this, _latestResolvedIdx2)) {
-          __privateSet(this, _latestResolvedIdx2, idx);
+        if (idx > this.#latestResolvedIdx) {
+          this.#latestResolvedIdx = idx;
           resolve(result);
         }
       } catch (e) {
@@ -67,21 +35,16 @@ var StaleDropper = class {
     });
   }
 };
-_latestAssignedIdx2 = new WeakMap();
-_latestResolvedIdx2 = new WeakMap();
 
 // 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, /* @__PURE__ */ new Set());
+    this.#children = /* @__PURE__ */ new Set();
     this.lastSourceGeneration = 0;
-    __privateAdd(this, _rawListeners, /* @__PURE__ */ new Set());
-    __privateAdd(this, _rawDispatchPending, false);
-    __privateAdd(this, _freshListeners, /* @__PURE__ */ new Map());
+    this.#rawListeners = /* @__PURE__ */ new Set();
+    this.#rawDispatchPending = false;
+    this.#freshListeners = /* @__PURE__ */ new Map();
   }
   canReuse(v1, v2) {
     return v1 === v2 || this.canReuseValue(v1, v2);
@@ -90,13 +53,14 @@ var TwistyPropParent = class {
     return false;
   }
   debugGetChildren() {
-    return Array.from(__privateGet(this, _children).values());
+    return Array.from(this.#children.values());
   }
+  #children;
   addChild(child) {
-    __privateGet(this, _children).add(child);
+    this.#children.add(child);
   }
   removeChild(child) {
-    __privateGet(this, _children).delete(child);
+    this.#children.delete(child);
   }
   markStale(sourceEvent) {
     if (sourceEvent.detail.generation !== globalSourceGeneration) {
@@ -106,20 +70,38 @@ var TwistyPropParent = class {
       return;
     }
     this.lastSourceGeneration = sourceEvent.detail.generation;
-    for (const child of __privateGet(this, _children)) {
+    for (const child of this.#children) {
       child.markStale(sourceEvent);
     }
-    __privateMethod(this, _scheduleRawDispatch, scheduleRawDispatch_fn).call(this);
+    this.#scheduleRawDispatch();
   }
+  #rawListeners;
   addRawListener(listener, options) {
-    __privateGet(this, _rawListeners).add(listener);
+    this.#rawListeners.add(listener);
     if (options?.initial) {
       listener();
     }
   }
   removeRawListener(listener) {
-    __privateGet(this, _rawListeners).delete(listener);
+    this.#rawListeners.delete(listener);
+  }
+  #scheduleRawDispatch() {
+    if (!this.#rawDispatchPending) {
+      this.#rawDispatchPending = true;
+      setTimeout(() => this.#dispatchRawListeners(), 0);
+    }
   }
+  #rawDispatchPending;
+  #dispatchRawListeners() {
+    if (!this.#rawDispatchPending) {
+      throw new Error("Invalid dispatch state!");
+    }
+    for (const listener of this.#rawListeners) {
+      listener();
+    }
+    this.#rawDispatchPending = false;
+  }
+  #freshListeners;
   addFreshListener(listener) {
     const staleDropper = new StaleDropper();
     let lastResult = null;
@@ -131,142 +113,114 @@ var TwistyPropParent = class {
       lastResult = result;
       listener(result);
     };
-    __privateGet(this, _freshListeners).set(listener, callback);
+    this.#freshListeners.set(listener, callback);
     this.addRawListener(callback, { initial: true });
   }
   removeFreshListener(listener) {
-    this.removeRawListener(__privateGet(this, _freshListeners).get(listener));
-    __privateGet(this, _freshListeners).delete(listener);
-  }
-};
-_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);
+    this.removeRawListener(this.#freshListeners.get(listener));
+    this.#freshListeners.delete(listener);
   }
 };
-_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 {
+  #value;
   constructor(initialValue) {
     super();
-    __privateAdd(this, _value, void 0);
-    __privateSet(this, _value, from(() => this.getDefaultValue()));
+    this.#value = from(() => this.getDefaultValue());
     if (initialValue) {
-      __privateSet(this, _value, this.deriveFromPromiseOrValue(initialValue, __privateGet(this, _value)));
+      this.#value = this.deriveFromPromiseOrValue(initialValue, this.#value);
     }
   }
   set(input) {
-    __privateSet(this, _value, this.deriveFromPromiseOrValue(input, __privateGet(this, _value)));
+    this.#value = this.deriveFromPromiseOrValue(input, this.#value);
     const sourceEventDetail = {
       sourceProp: this,
-      value: __privateGet(this, _value),
+      value: this.#value,
       generation: ++globalSourceGeneration
     };
-    this.markStale(new CustomEvent("stale", {
-      detail: sourceEventDetail
-    }));
+    this.markStale(
+      new CustomEvent("stale", {
+        detail: sourceEventDetail
+      })
+    );
   }
   async get() {
-    return __privateGet(this, _value);
+    return this.#value;
   }
   async deriveFromPromiseOrValue(input, oldValuePromise) {
     return this.derive(await input, oldValuePromise);
   }
 };
-_value = new WeakMap();
 var SimpleTwistyPropSource = class extends TwistyPropSource {
   derive(input) {
     return input;
   }
 };
 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);
+    this.#parents = parents;
     for (const parent of Object.values(parents)) {
       parent.addChild(this);
     }
   }
+  #parents;
+  #cachedLastSuccessfulCalculation = null;
+  #cachedLatestGenerationCalculation = null;
   async get() {
     const generation = this.lastSourceGeneration;
-    if (__privateGet(this, _cachedLatestGenerationCalculation)?.generation === generation) {
-      return __privateGet(this, _cachedLatestGenerationCalculation).output;
+    if (this.#cachedLatestGenerationCalculation?.generation === generation) {
+      return 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))
+      output: this.#cacheDerive(
+        this.#getParents(),
+        generation,
+        this.#cachedLastSuccessfulCalculation
+      )
     };
-    __privateSet(this, _cachedLatestGenerationCalculation, latestGenerationCalculation);
+    this.#cachedLatestGenerationCalculation = latestGenerationCalculation;
     this.userVisibleErrorTracker?.reset();
     return latestGenerationCalculation.output;
   }
-};
-_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;
-};
-_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])) {
+  async #getParents() {
+    const inputValuePromises = {};
+    for (const [key, parent] of Object.entries(this.#parents)) {
+      inputValuePromises[key] = parent.get();
+    }
+    const inputs = {};
+    for (const key in this.#parents) {
+      inputs[key] = await inputValuePromises[key];
+    }
+    return inputs;
+  }
+  async #cacheDerive(inputsPromise, generation, cachedLatestGenerationCalculation = null) {
+    const inputs = await inputsPromise;
+    const cache = (output) => {
+      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 this.#parents) {
+      const parent = this.#parents[key];
+      if (!parent.canReuse(inputs[key], cachedInputs[key])) {
+        return cache(await this.derive(inputs));
+      }
+    }
+    return cachedLatestGenerationCalculation.output;
   }
-  return cachedLatestGenerationCalculation.output;
 };
-var _disconnectionFunctions;
 var FreshListenerManager = class {
-  constructor() {
-    __privateAdd(this, _disconnectionFunctions, []);
-  }
+  #disconnectionFunctions = [];
   addListener(prop, listener) {
     let disconnected = false;
     const wrappedListener = (value) => {
@@ -276,7 +230,7 @@ var FreshListenerManager = class {
       listener(value);
     };
     prop.addFreshListener(wrappedListener);
-    __privateGet(this, _disconnectionFunctions).push(() => {
+    this.#disconnectionFunctions.push(() => {
       prop.removeFreshListener(wrappedListener);
       disconnected = true;
     });
@@ -295,14 +249,16 @@ var FreshListenerManager = class {
       if (disconnected) {
         return;
       }
-      const promises = props.map((prop) => prop.get());
+      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(() => {
+    this.#disconnectionFunctions.push(() => {
       for (const prop of props) {
         prop.removeFreshListener(wrappedListener);
       }
@@ -310,12 +266,11 @@ var FreshListenerManager = class {
     });
   }
   disconnect() {
-    for (const disconnectionFunction of __privateGet(this, _disconnectionFunctions)) {
+    for (const disconnectionFunction of this.#disconnectionFunctions) {
       disconnectionFunction();
     }
   }
 };
-_disconnectionFunctions = new WeakMap();
 
 // src/cubing/twisty/controllers/RenderScheduler.ts
 var RenderScheduler = class {
@@ -388,34 +343,34 @@ var CSSSource = class {
     return this.sourceText;
   }
 };
-var _cssSourceMap;
 var ManagedCustomElement = class extends HTMLElementShim {
   constructor(options) {
     super();
-    __privateAdd(this, _cssSourceMap, /* @__PURE__ */ new Map());
+    this.#cssSourceMap = /* @__PURE__ */ 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);
   }
+  #cssSourceMap;
   addCSS(cssSource) {
-    const existing = __privateGet(this, _cssSourceMap).get(cssSource);
+    const existing = this.#cssSourceMap.get(cssSource);
     if (existing) {
       return existing;
     }
     const cssElem = document.createElement("style");
     cssElem.textContent = cssSource.getAsString();
-    __privateGet(this, _cssSourceMap).set(cssSource, cssElem);
+    this.#cssSourceMap.set(cssSource, cssElem);
     this.shadow.appendChild(cssElem);
     return cssElem;
   }
   removeCSS(cssSource) {
-    const cssElem = __privateGet(this, _cssSourceMap).get(cssSource);
+    const cssElem = this.#cssSourceMap.get(cssSource);
     if (!cssElem) {
       return;
     }
     this.shadow.removeChild(cssElem);
-    __privateGet(this, _cssSourceMap).delete(cssSource);
+    this.#cssSourceMap.delete(cssSource);
   }
   addElement(element) {
     return this.contentWrapper.appendChild(element);
@@ -427,8 +382,10 @@ var ManagedCustomElement = class extends HTMLElementShim {
     return this.contentWrapper.removeChild(element);
   }
 };
-_cssSourceMap = new WeakMap();
-customElementsShim.define("twisty-managed-custom-element", ManagedCustomElement);
+customElementsShim.define(
+  "twisty-managed-custom-element",
+  ManagedCustomElement
+);
 
 // src/cubing/vendor/three/examples/jsm/libs/stats.modified.module.ts
 var performance = globalThis.performance;
@@ -444,10 +401,14 @@ var Stats = class {
     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.dom.addEventListener(
+      "click",
+      (event) => {
+        event.preventDefault();
+        this.showPanel(++this.mode % this.dom.children.length);
+      },
+      false
+    );
     this.showPanel(0);
   }
   addPanel(panel) {
@@ -473,7 +434,10 @@ var Stats = class {
       this.frames = 0;
       if (this.memPanel) {
         const memory = performance.memory;
-        this.memPanel.update(memory.usedJSHeapSize / 1048576, memory.jsHeapSizeLimit / 1048576);
+        this.memPanel.update(
+          memory.usedJSHeapSize / 1048576,
+          memory.jsHeapSizeLimit / 1048576
+        );
       }
     }
     return time;
@@ -521,21 +485,47 @@ var StatsPanel = class {
     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.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));
+    this.context.fillRect(
+      GRAPH_X + GRAPH_WIDTH - PR,
+      GRAPH_Y,
+      PR,
+      Math.round((1 - value / maxValue) * GRAPH_HEIGHT)
+    );
   }
 };
 
 // src/cubing/twisty/heavy-code-imports/3d.ts
 var cachedConstructorProxy = null;
 async function proxy3D() {
-  return cachedConstructorProxy ?? (cachedConstructorProxy = import("./twisty-dynamic-3d-QOX7IEXC.js"));
+  return cachedConstructorProxy ?? (cachedConstructorProxy = import("./twisty-dynamic-3d-2KRJEHAN.js"));
 }
-var THREEJS = from(async () => (await proxy3D()).T3I);
+var THREEJS = from(
+  async () => (await proxy3D()).T3I
+);
 
 // src/cubing/twisty/views/canvas.ts
 var globalPixelRatioOverride = null;
@@ -608,18 +598,12 @@ var twisty3DVantageCSS = new CSSSource(`
 
 // src/cubing/twisty/views/3D/DragTracker.ts
 var MOVEMENT_EPSILON = 0.1;
-var _dragInfoMap, _targetListeners, _lazyListenersRegistered, _registerLazyListeners, registerLazyListeners_fn, _clear, clear_fn, _trackDrag, trackDrag_fn;
 var DragTracker = class extends EventTarget {
   constructor(target) {
     super();
     this.target = target;
-    __privateAdd(this, _registerLazyListeners);
-    __privateAdd(this, _clear);
-    __privateAdd(this, _trackDrag);
-    __privateAdd(this, _dragInfoMap, /* @__PURE__ */ new Map());
-    __privateAdd(this, _targetListeners, /* @__PURE__ */ new Map());
-    __privateAdd(this, _lazyListenersRegistered, false);
   }
+  #dragInfoMap = /* @__PURE__ */ new Map();
   start() {
     this.addTargetListener("pointerdown", this.onPointerDown.bind(this));
     this.addTargetListener("contextmenu", (e) => {
@@ -629,20 +613,64 @@ var DragTracker = class extends EventTarget {
     this.addTargetListener("dblclick", (e) => e.preventDefault());
   }
   stop() {
-    for (const [eventType, listener] of __privateGet(this, _targetListeners).entries()) {
+    for (const [eventType, listener] of this.#targetListeners.entries()) {
       this.target.removeEventListener(eventType, listener);
     }
-    __privateGet(this, _targetListeners).clear();
-    __privateSet(this, _lazyListenersRegistered, false);
+    this.#targetListeners.clear();
+    this.#lazyListenersRegistered = false;
   }
+  #targetListeners = /* @__PURE__ */ new Map();
   addTargetListener(eventType, listener) {
-    if (!__privateGet(this, _targetListeners).has(eventType)) {
+    if (!this.#targetListeners.has(eventType)) {
       this.target.addEventListener(eventType, listener);
-      __privateGet(this, _targetListeners).set(eventType, listener);
+      this.#targetListeners.set(eventType, listener);
+    }
+  }
+  #lazyListenersRegistered = false;
+  #registerLazyListeners() {
+    if (this.#lazyListenersRegistered) {
+      return;
+    }
+    this.addTargetListener("pointermove", this.onPointerMove.bind(this));
+    this.addTargetListener("pointerup", this.onPointerUp.bind(this));
+    this.#lazyListenersRegistered = true;
+  }
+  #clear(e) {
+    this.#dragInfoMap.delete(e.pointerId);
+  }
+  #trackDrag(e) {
+    const existing = this.#dragInfoMap.get(e.pointerId);
+    if (!existing) {
+      return { movementInfo: null, hasMoved: false };
+    }
+    let movementInfo;
+    if ((e.movementX ?? 0) !== 0 || (e.movementY ?? 0) !== 0) {
+      movementInfo = {
+        attachedInfo: existing.attachedInfo,
+        movementX: e.movementX,
+        movementY: e.movementY,
+        elapsedMs: e.timeStamp - existing.lastTimeStamp
+      };
+    } else {
+      movementInfo = {
+        attachedInfo: existing.attachedInfo,
+        movementX: e.clientX - existing.lastClientX,
+        movementY: e.clientY - existing.lastClientY,
+        elapsedMs: e.timeStamp - existing.lastTimeStamp
+      };
+    }
+    existing.lastClientX = e.clientX;
+    existing.lastClientY = e.clientY;
+    existing.lastTimeStamp = e.timeStamp;
+    if (Math.abs(movementInfo.movementX) < MOVEMENT_EPSILON && Math.abs(movementInfo.movementY) < MOVEMENT_EPSILON) {
+      return { movementInfo: null, hasMoved: existing.hasMoved };
+    } else {
+      existing.hasMoved = true;
+      return { movementInfo, hasMoved: existing.hasMoved };
     }
   }
   onPointerDown(e) {
-    __privateMethod(this, _registerLazyListeners, registerLazyListeners_fn).call(this);
+    this.#registerLazyListeners();
     const newDragInfo = {
       attachedInfo: {},
       hasMoved: false,
@@ -650,22 +678,24 @@ var DragTracker = class extends EventTarget {
       lastClientY: e.clientY,
       lastTimeStamp: e.timeStamp
     };
-    __privateGet(this, _dragInfoMap).set(e.pointerId, newDragInfo);
+    this.#dragInfoMap.set(e.pointerId, newDragInfo);
     this.target.setPointerCapture(e.pointerId);
   }
   onPointerMove(e) {
-    const movementInfo = __privateMethod(this, _trackDrag, trackDrag_fn).call(this, e).movementInfo;
+    const movementInfo = this.#trackDrag(e).movementInfo;
     if (movementInfo) {
       e.preventDefault();
-      this.dispatchEvent(new CustomEvent("move", {
-        detail: movementInfo
-      }));
+      this.dispatchEvent(
+        new CustomEvent("move", {
+          detail: movementInfo
+        })
+      );
     }
   }
   onPointerUp(e) {
-    const trackDragResult = __privateMethod(this, _trackDrag, trackDrag_fn).call(this, e);
-    const existing = __privateGet(this, _dragInfoMap).get(e.pointerId);
-    __privateMethod(this, _clear, clear_fn).call(this, e);
+    const trackDragResult = this.#trackDrag(e);
+    const existing = this.#dragInfoMap.get(e.pointerId);
+    this.#clear(e);
     this.target.releasePointerCapture(e.pointerId);
     let event;
     if (trackDragResult.hasMoved) {
@@ -690,54 +720,6 @@ var DragTracker = class extends EventTarget {
     this.dispatchEvent(event);
   }
 };
-_dragInfoMap = new WeakMap();
-_targetListeners = new WeakMap();
-_lazyListenersRegistered = new WeakMap();
-_registerLazyListeners = new WeakSet();
-registerLazyListeners_fn = function() {
-  if (__privateGet(this, _lazyListenersRegistered)) {
-    return;
-  }
-  this.addTargetListener("pointermove", this.onPointerMove.bind(this));
-  this.addTargetListener("pointerup", this.onPointerUp.bind(this));
-  __privateSet(this, _lazyListenersRegistered, true);
-};
-_clear = new WeakSet();
-clear_fn = function(e) {
-  __privateGet(this, _dragInfoMap).delete(e.pointerId);
-};
-_trackDrag = new WeakSet();
-trackDrag_fn = function(e) {
-  const existing = __privateGet(this, _dragInfoMap).get(e.pointerId);
-  if (!existing) {
-    return { movementInfo: null, hasMoved: false };
-  }
-  let movementInfo;
-  if ((e.movementX ?? 0) !== 0 || (e.movementY ?? 0) !== 0) {
-    movementInfo = {
-      attachedInfo: existing.attachedInfo,
-      movementX: e.movementX,
-      movementY: e.movementY,
-      elapsedMs: e.timeStamp - existing.lastTimeStamp
-    };
-  } else {
-    movementInfo = {
-      attachedInfo: existing.attachedInfo,
-      movementX: e.clientX - existing.lastClientX,
-      movementY: e.clientY - existing.lastClientY,
-      elapsedMs: e.timeStamp - existing.lastTimeStamp
-    };
-  }
-  existing.lastClientX = e.clientX;
-  existing.lastClientY = e.clientY;
-  existing.lastTimeStamp = e.timeStamp;
-  if (Math.abs(movementInfo.movementX) < MOVEMENT_EPSILON && Math.abs(movementInfo.movementY) < MOVEMENT_EPSILON) {
-    return { movementInfo: null, hasMoved: existing.hasMoved };
-  } else {
-    existing.hasMoved = true;
-    return { movementInfo, hasMoved: existing.hasMoved };
-  }
-};
 
 // src/cubing/twisty/views/3D/RendererPool.ts
 var renderers = [];
@@ -785,7 +767,10 @@ var Inertia = class {
   }
   render(now) {
     const progressBefore = (this.lastTimestamp - this.startTimestamp) / INERTIA_DURATION_MS;
-    const progressAfter = Math.min(1, (now - 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;
     }
@@ -815,7 +800,10 @@ var TwistyOrbitControls = class {
   onMove(e) {
     var _a;
     (_a = e.detail).attachedInfo ?? (_a.attachedInfo = {});
-    const { temperedX, temperedY } = this.onMovement(e.detail.movementX, e.detail.movementY);
+    const { temperedX, temperedY } = this.onMovement(
+      e.detail.movementX,
+      e.detail.movementY
+    );
     const attachedInfo = e.detail.attachedInfo;
     attachedInfo.lastTemperedX = temperedX * 10;
     attachedInfo.lastTemperedY = temperedY * 10;
@@ -825,28 +813,41 @@ var TwistyOrbitControls = class {
     const scale = this.mirror ? -1 : 1;
     const minDim = Math.min(this.canvas.offsetWidth, this.canvas.offsetHeight);
     const temperedX = this.temperMovement(movementX / minDim);
-    const temperedY = this.temperMovement(movementY / minDim * VERTICAL_MOVEMENT_BASE_SCALE);
-    this.model.twistySceneModel.orbitCoordinatesRequest.set((async () => {
-      const prevCoords = await this.model.twistySceneModel.orbitCoordinates.get();
-      const newCoords = {
-        latitude: prevCoords.latitude + 2 * temperedY * DEGREES_PER_RADIAN * scale,
-        longitude: prevCoords.longitude - 2 * temperedX * DEGREES_PER_RADIAN
-      };
-      return newCoords;
-    })());
+    const temperedY = this.temperMovement(
+      movementY / minDim * VERTICAL_MOVEMENT_BASE_SCALE
+    );
+    this.model.twistySceneModel.orbitCoordinatesRequest.set(
+      (async () => {
+        const prevCoords = await this.model.twistySceneModel.orbitCoordinates.get();
+        const newCoords = {
+          latitude: prevCoords.latitude + 2 * temperedY * DEGREES_PER_RADIAN * scale,
+          longitude: prevCoords.longitude - 2 * temperedX * DEGREES_PER_RADIAN
+        };
+        return newCoords;
+      })()
+    );
     return { temperedX, temperedY };
   }
   onUp(e) {
     e.preventDefault();
     if ("lastTemperedX" in e.detail.attachedInfo && "lastTemperedY" in e.detail.attachedInfo && "timestamp" in e.detail.attachedInfo && e.timeStamp - e.detail.attachedInfo.timestamp < 60) {
-      new Inertia(e.timeStamp, e.detail.attachedInfo.lastTemperedX, e.detail.attachedInfo.lastTemperedY, this.onMovementBound);
+      new Inertia(
+        e.timeStamp,
+        e.detail.attachedInfo.lastTemperedX,
+        e.detail.attachedInfo.lastTemperedY,
+        this.onMovementBound
+      );
     }
   }
 };
 
 // src/cubing/twisty/views/3D/Twisty3DVantage.ts
 async function setCameraFromOrbitCoordinates(camera, orbitCoordinates, backView = false) {
-  const spherical = new (await THREEJS).Spherical(orbitCoordinates.distance, (90 - (backView ? -1 : 1) * orbitCoordinates.latitude) / DEGREES_PER_RADIAN, ((backView ? 180 : 0) + orbitCoordinates.longitude) / DEGREES_PER_RADIAN);
+  const spherical = new (await THREEJS).Spherical(
+    orbitCoordinates.distance,
+    (90 - (backView ? -1 : 1) * orbitCoordinates.latitude) / DEGREES_PER_RADIAN,
+    ((backView ? 180 : 0) + orbitCoordinates.longitude) / DEGREES_PER_RADIAN
+  );
   spherical.makeSafe();
   camera.position.setFromSpherical(spherical);
   camera.lookAt(0, 0, 0);
@@ -872,30 +873,26 @@ function shareRenderer() {
 function haveStartedSharingRenderers() {
   return sharingRenderers;
 }
-var _setupBasicPresses, setupBasicPresses_fn, _onResizeStaleDropper, _width, _height, _onResize, onResize_fn, _cachedRenderer, _cachedCanvas, _cachedDragTracker, _dragTracker, dragTracker_fn, _cachedCamera, _cachedOrbitControls, _disconnectionFunctions2, _experimentalNextRenderFinishedCallback, _scheduler;
 var Twisty3DVantage = class extends ManagedCustomElement {
   constructor(model, scene, options) {
     super();
     this.model = model;
     this.options = options;
-    __privateAdd(this, _setupBasicPresses);
-    __privateAdd(this, _onResize);
-    __privateAdd(this, _dragTracker);
     this.scene = null;
     this.stats = null;
     this.rendererIsShared = shareRenderer();
     this.loadingElement = null;
-    __privateAdd(this, _onResizeStaleDropper, new StaleDropper());
-    __privateAdd(this, _width, 0);
-    __privateAdd(this, _height, 0);
-    __privateAdd(this, _cachedRenderer, null);
-    __privateAdd(this, _cachedCanvas, null);
-    __privateAdd(this, _cachedDragTracker, null);
-    __privateAdd(this, _cachedCamera, null);
-    __privateAdd(this, _cachedOrbitControls, null);
-    __privateAdd(this, _disconnectionFunctions2, []);
-    __privateAdd(this, _experimentalNextRenderFinishedCallback, null);
-    __privateAdd(this, _scheduler, new RenderScheduler(this.render.bind(this)));
+    this.#onResizeStaleDropper = new StaleDropper();
+    this.#width = 0;
+    this.#height = 0;
+    this.#cachedRenderer = null;
+    this.#cachedCanvas = null;
+    this.#cachedDragTracker = null;
+    this.#cachedCamera = null;
+    this.#cachedOrbitControls = null;
+    this.#disconnectionFunctions = [];
+    this.#experimentalNextRenderFinishedCallback = null;
+    this.#scheduler = new RenderScheduler(this.render.bind(this));
     this.scene = scene ?? null;
     this.loadingElement = this.addElement(document.createElement("div"));
     this.loadingElement.classList.add("loading");
@@ -908,31 +905,87 @@ var Twisty3DVantage = class extends ManagedCustomElement {
   async connectedCallback() {
     this.addCSS(twisty3DVantageCSS);
     this.addElement((await this.canvasInfo()).canvas);
-    __privateMethod(this, _onResize, onResize_fn).call(this);
-    const observer = new ResizeObserver(__privateMethod(this, _onResize, onResize_fn).bind(this));
+    this.#onResize();
+    const observer = new ResizeObserver(this.#onResize.bind(this));
     observer.observe(this.contentWrapper);
     this.orbitControls();
-    __privateMethod(this, _setupBasicPresses, setupBasicPresses_fn).call(this);
+    this.#setupBasicPresses();
     this.scheduleRender();
   }
+  async #setupBasicPresses() {
+    const dragTracker = await this.#dragTracker();
+    dragTracker.addEventListener("press", async (e) => {
+      const movePressInput = await this.model.twistySceneModel.movePressInput.get();
+      if (movePressInput !== "basic") {
+        return;
+      }
+      this.dispatchEvent(
+        new CustomEvent("press", {
+          detail: {
+            pressInfo: e.detail,
+            cameraPromise: this.camera()
+          }
+        })
+      );
+    });
+  }
+  #onResizeStaleDropper;
   async clearCanvas() {
     if (this.rendererIsShared) {
       const canvasInfo = await this.canvasInfo();
-      canvasInfo.context.clearRect(0, 0, canvasInfo.canvas.width, canvasInfo.canvas.height);
+      canvasInfo.context.clearRect(
+        0,
+        0,
+        canvasInfo.canvas.width,
+        canvasInfo.canvas.height
+      );
     } else {
       const renderer = await this.renderer();
       const context = renderer.getContext();
       context.clear(context.COLOR_BUFFER_BIT);
     }
   }
+  #width;
+  #height;
+  async #onResize() {
+    const camera = await this.#onResizeStaleDropper.queue(this.camera());
+    const w = this.contentWrapper.clientWidth;
+    const h = this.contentWrapper.clientHeight;
+    this.#width = w;
+    this.#height = h;
+    const off = 0;
+    let yoff = 0;
+    let excess = 0;
+    if (h > w) {
+      excess = h - w;
+      yoff = -Math.floor(0.5 * excess);
+    }
+    camera.aspect = w / h;
+    camera.setViewOffset(w, h - excess, off, yoff, w, h);
+    camera.updateProjectionMatrix();
+    this.clearCanvas();
+    if (this.rendererIsShared) {
+      const canvasInfo = await this.canvasInfo();
+      canvasInfo.canvas.width = w * pixelRatio();
+      canvasInfo.canvas.height = h * pixelRatio();
+      canvasInfo.canvas.style.width = w.toString();
+      canvasInfo.canvas.style.height = h.toString();
+    } else {
+      const renderer = await this.renderer();
+      renderer.setSize(w, h, true);
+    }
+    this.scheduleRender();
+  }
+  #cachedRenderer;
   async renderer() {
     if (this.rendererIsShared) {
       throw new Error("renderer expected to be shared.");
     }
-    return __privateGet(this, _cachedRenderer) ?? __privateSet(this, _cachedRenderer, newRenderer());
+    return this.#cachedRenderer ?? (this.#cachedRenderer = newRenderer());
   }
+  #cachedCanvas;
   async canvasInfo() {
-    return __privateGet(this, _cachedCanvas) ?? __privateSet(this, _cachedCanvas, (async () => {
+    return this.#cachedCanvas ?? (this.#cachedCanvas = (async () => {
       let canvas;
       if (this.rendererIsShared) {
         canvas = this.addElement(document.createElement("canvas"));
@@ -945,44 +998,93 @@ var Twisty3DVantage = class extends ManagedCustomElement {
       return { canvas, context };
     })());
   }
+  #cachedDragTracker;
+  async #dragTracker() {
+    return this.#cachedDragTracker ?? (this.#cachedDragTracker = (async () => {
+      const dragTracker = new DragTracker((await this.canvasInfo()).canvas);
+      this.model?.twistySceneModel.dragInput.addFreshListener(
+        (dragInputMode) => {
+          let dragInputEnabled = false;
+          switch (dragInputMode) {
+            case "auto":
+              dragTracker.start();
+              dragInputEnabled = true;
+              break;
+            case "none":
+              dragTracker.stop();
+              break;
+          }
+          this.contentWrapper.classList.toggle(
+            "drag-input-enabled",
+            dragInputEnabled
+          );
+        }
+      );
+      return dragTracker;
+    })());
+  }
+  #cachedCamera;
   async camera() {
-    return __privateGet(this, _cachedCamera) ?? __privateSet(this, _cachedCamera, (async () => {
-      const camera = new (await THREEJS).PerspectiveCamera(20, 1, 0.1, 20);
-      camera.position.copy(new (await THREEJS).Vector3(2, 4, 4).multiplyScalar(this.options?.backView ? -1 : 1));
+    return this.#cachedCamera ?? (this.#cachedCamera = (async () => {
+      const camera = new (await THREEJS).PerspectiveCamera(
+        20,
+        1,
+        0.1,
+        20
+      );
+      camera.position.copy(
+        new (await THREEJS).Vector3(2, 4, 4).multiplyScalar(
+          this.options?.backView ? -1 : 1
+        )
+      );
       camera.lookAt(0, 0, 0);
       return camera;
     })());
   }
+  #cachedOrbitControls;
   async orbitControls() {
-    return __privateGet(this, _cachedOrbitControls) ?? __privateSet(this, _cachedOrbitControls, (async () => {
-      const orbitControls = new TwistyOrbitControls(this.model, !!this.options?.backView, (await this.canvasInfo()).canvas, await __privateMethod(this, _dragTracker, dragTracker_fn).call(this));
+    return this.#cachedOrbitControls ?? (this.#cachedOrbitControls = (async () => {
+      const orbitControls = new TwistyOrbitControls(
+        this.model,
+        !!this.options?.backView,
+        (await this.canvasInfo()).canvas,
+        await this.#dragTracker()
+      );
       if (this.model) {
-        this.addListener(this.model.twistySceneModel.orbitCoordinates, async (orbitCoordinates) => {
-          const camera = await this.camera();
-          setCameraFromOrbitCoordinates(camera, orbitCoordinates, this.options?.backView);
-          this.scheduleRender();
-        });
+        this.addListener(
+          this.model.twistySceneModel.orbitCoordinates,
+          async (orbitCoordinates) => {
+            const camera = await this.camera();
+            setCameraFromOrbitCoordinates(
+              camera,
+              orbitCoordinates,
+              this.options?.backView
+            );
+            this.scheduleRender();
+          }
+        );
       }
       return orbitControls;
     })());
   }
   addListener(prop, listener) {
     prop.addFreshListener(listener);
-    __privateGet(this, _disconnectionFunctions2).push(() => {
+    this.#disconnectionFunctions.push(() => {
       prop.removeFreshListener(listener);
     });
   }
+  #disconnectionFunctions;
   disconnect() {
-    for (const fn of __privateGet(this, _disconnectionFunctions2)) {
+    for (const fn of this.#disconnectionFunctions) {
       fn();
     }
-    __privateSet(this, _disconnectionFunctions2, []);
+    this.#disconnectionFunctions = [];
   }
+  #experimentalNextRenderFinishedCallback;
   experimentalNextRenderFinishedCallback(callback) {
-    __privateSet(this, _experimentalNextRenderFinishedCallback, callback);
+    this.#experimentalNextRenderFinishedCallback = callback;
   }
   async render() {
-    var _a;
     if (!this.scene) {
       throw new Error("Attempted to render without a scene");
     }
@@ -993,95 +1095,19 @@ var Twisty3DVantage = class extends ManagedCustomElement {
       this.canvasInfo()
     ]);
     if (this.rendererIsShared) {
-      renderPooled(__privateGet(this, _width), __privateGet(this, _height), canvas.canvas, scene, camera);
+      renderPooled(this.#width, this.#height, canvas.canvas, scene, camera);
     } else {
       (await this.renderer()).render(scene, camera);
     }
     this.stats?.end();
-    (_a = __privateGet(this, _experimentalNextRenderFinishedCallback)) == null ? void 0 : _a.call(this);
-    __privateSet(this, _experimentalNextRenderFinishedCallback, null);
+    this.#experimentalNextRenderFinishedCallback?.();
+    this.#experimentalNextRenderFinishedCallback = null;
   }
+  #scheduler;
   scheduleRender() {
-    __privateGet(this, _scheduler).requestAnimFrame();
+    this.#scheduler.requestAnimFrame();
   }
 };
-_setupBasicPresses = new WeakSet();
-setupBasicPresses_fn = async function() {
-  const dragTracker = await __privateMethod(this, _dragTracker, dragTracker_fn).call(this);
-  dragTracker.addEventListener("press", async (e) => {
-    const movePressInput = await this.model.twistySceneModel.movePressInput.get();
-    if (movePressInput !== "basic") {
-      return;
-    }
-    this.dispatchEvent(new CustomEvent("press", {
-      detail: {
-        pressInfo: e.detail,
-        cameraPromise: this.camera()
-      }
-    }));
-  });
-};
-_onResizeStaleDropper = new WeakMap();
-_width = new WeakMap();
-_height = new WeakMap();
-_onResize = new WeakSet();
-onResize_fn = async function() {
-  const camera = await __privateGet(this, _onResizeStaleDropper).queue(this.camera());
-  const w = this.contentWrapper.clientWidth;
-  const h = this.contentWrapper.clientHeight;
-  __privateSet(this, _width, w);
-  __privateSet(this, _height, h);
-  const off = 0;
-  let yoff = 0;
-  let excess = 0;
-  if (h > w) {
-    excess = h - w;
-    yoff = -Math.floor(0.5 * excess);
-  }
-  camera.aspect = w / h;
-  camera.setViewOffset(w, h - excess, off, yoff, w, h);
-  camera.updateProjectionMatrix();
-  this.clearCanvas();
-  if (this.rendererIsShared) {
-    const canvasInfo = await this.canvasInfo();
-    canvasInfo.canvas.width = w * pixelRatio();
-    canvasInfo.canvas.height = h * pixelRatio();
-    canvasInfo.canvas.style.width = w.toString();
-    canvasInfo.canvas.style.height = h.toString();
-  } else {
-    const renderer = await this.renderer();
-    renderer.setSize(w, h, true);
-  }
-  this.scheduleRender();
-};
-_cachedRenderer = new WeakMap();
-_cachedCanvas = new WeakMap();
-_cachedDragTracker = new WeakMap();
-_dragTracker = new WeakSet();
-dragTracker_fn = async function() {
-  return __privateGet(this, _cachedDragTracker) ?? __privateSet(this, _cachedDragTracker, (async () => {
-    const dragTracker = new DragTracker((await this.canvasInfo()).canvas);
-    this.model?.twistySceneModel.dragInput.addFreshListener((dragInputMode) => {
-      let dragInputEnabled = false;
-      switch (dragInputMode) {
-        case "auto":
-          dragTracker.start();
-          dragInputEnabled = true;
-          break;
-        case "none":
-          dragTracker.stop();
-          break;
-      }
-      this.contentWrapper.classList.toggle("drag-input-enabled", dragInputEnabled);
-    });
-    return dragTracker;
-  })());
-};
-_cachedCamera = new WeakMap();
-_cachedOrbitControls = new WeakMap();
-_disconnectionFunctions2 = new WeakMap();
-_experimentalNextRenderFinishedCallback = new WeakMap();
-_scheduler = new WeakMap();
 customElementsShim.define("twisty-3d-vantage", Twisty3DVantage);
 
 export {
@@ -1108,4 +1134,4 @@ export {
   proxy3D,
   THREEJS
 };
-//# sourceMappingURL=chunk-LSVR2HCG.js.map
+//# sourceMappingURL=chunk-76UZ2QTB.js.map