cubing 0.23.0 → 0.24.0-pre4

package/dist/esm/{chunk-JZWB7AIU.js → chunk-QBSUFYNB.js}

@@ -1,20 +1,27 @@
 import {
   parseSGS
-} from "./chunk-XVZOMB6J.js";
+} from "./chunk-27KJGD3S.js";
 import {
+  PGNotation,
   getPuzzleGeometryByName
-} from "./chunk-PUPUQWJC.js";
+} from "./chunk-ZDALYMGF.js";
+import {
+  KPuzzle
+} from "./chunk-Z36TNZT2.js";
 
 // src/cubing/search/inside/solve/puzzles/skewb.sgs.json.ts
-async function skewbDefWithoutMO() {
-  return getPuzzleGeometryByName("skewb", {
+async function skewbKPuzzleWithoutMO() {
+  const pg = getPuzzleGeometryByName("skewb", {
     allMoves: true,
     addRotations: true
-  }).writekpuzzle(true);
+  });
+  return new KPuzzle(pg.getKPuzzleDefinition(true), {
+    experimentalPGNotation: new PGNotation(pg, pg.getOrbitsDef(true))
+  });
 }
 var defCache = null;
-async function skewbDefWithoutMOCached() {
-  return defCache ?? (defCache = skewbDefWithoutMO());
+async function skewbKPuzzleWithoutMOCached() {
+  return defCache ?? (defCache = skewbKPuzzleWithoutMO());
 }
 var cachedData = null;
 async function sgsDataSkewb() {
@@ -26,7 +33,7 @@ async function sgsDataSkewbFixedCorner() {
   };
 }
 async function uncachedSGSDataSkewb() {
-  return parseSGS(await skewbDefWithoutMOCached(), `SubgroupSizes 24 6 5 12 9 3 4 9 3 3
+  return parseSGS(await skewbKPuzzleWithoutMOCached(), `SubgroupSizes 24 6 5 12 9 3 4 9 3 3
 
 Alg y
 Alg y2
@@ -108,8 +115,8 @@ Alg R' U' R U B' U' B L`);
 }
 
 export {
-  skewbDefWithoutMOCached,
+  skewbKPuzzleWithoutMOCached,
   sgsDataSkewb,
   sgsDataSkewbFixedCorner
 };
-//# sourceMappingURL=chunk-JZWB7AIU.js.map
+//# sourceMappingURL=chunk-QBSUFYNB.js.map

package/dist/esm/chunk-QBSUFYNB.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/search/inside/solve/puzzles/skewb.sgs.json.ts"],
+  "sourcesContent": ["import { KPuzzle } from \"../../../../kpuzzle\";\nimport {\n  getPuzzleGeometryByName,\n  ExperimentalPGNotation,\n} from \"../../../../puzzle-geometry\";\nimport { parseSGS, SGSCachedData } from \"../parseSGS\";\n\nasync function skewbKPuzzleWithoutMO(): Promise<KPuzzle> {\n  const pg = getPuzzleGeometryByName(\"skewb\", {\n    allMoves: true,\n    addRotations: true,\n  });\n  return new KPuzzle(pg.getKPuzzleDefinition(true), {\n    experimentalPGNotation: new ExperimentalPGNotation(\n      pg,\n      pg.getOrbitsDef(true),\n    ),\n  });\n}\n\n// TODO: Implement a general lazy Promise/ Promise cache wrapper\nlet defCache: Promise<KPuzzle> | null = null;\nexport async function skewbKPuzzleWithoutMOCached(): Promise<KPuzzle> {\n  return (defCache ??= skewbKPuzzleWithoutMO());\n}\n\nlet cachedData: Promise<SGSCachedData> | null = null;\nexport async function sgsDataSkewb() {\n  return (cachedData ??= uncachedSGSDataSkewb());\n}\n\nexport async function sgsDataSkewbFixedCorner(): Promise<SGSCachedData> {\n  return {\n    ordering: (await sgsDataSkewb()).ordering.slice(1),\n  };\n}\n\n// TODO: Reduce info.\nasync function uncachedSGSDataSkewb(): Promise<SGSCachedData> {\n  return parseSGS(\n    await skewbKPuzzleWithoutMOCached(),\n    `SubgroupSizes 24 6 5 12 9 3 4 9 3 3\n\nAlg y\nAlg y2\nAlg y'\nAlg F\nAlg F'\nAlg y U\nAlg y U'\nAlg y L\nAlg y L'\nAlg y F\nAlg y F'\nAlg y2 U\nAlg y2 U'\nAlg y2 B\nAlg y2 B'\nAlg y' U\nAlg y' F'\nAlg y U L'\nAlg y U B\nAlg y2 U B\nAlg y2 U B'\nAlg y2 U' B\nAlg y2 U' B'\n\nAlg U\nAlg U'\nAlg U L\nAlg U L'\nAlg U' R'\n\nAlg R\nAlg R'\nAlg R B\nAlg R' L'\n\nAlg U B' U\nAlg U' L U\nAlg U' L' U\nAlg U' B U'\nAlg R L R'\nAlg R B' R\nAlg U B L U'\nAlg U B' U B'\nAlg U B' L' U\nAlg U' L B U'\nAlg R' B L' R'\n\nAlg L\nAlg L'\nAlg L B\nAlg L B'\nAlg L B L\nAlg L B L'\nAlg L B' L\nAlg L B' L'\n\nAlg B\nAlg B'\n\nAlg L' B L\nAlg L' B' L\nAlg R' L' B L R\n\nAlg B L' B L B'\nAlg B L' B' L B'\nAlg U L U B U' L' U'\nAlg R L R' B' R L' R'\nAlg U B' R L R' B' U B\nAlg U' B U L U' B' U L'\nAlg L U' B U L' U' B' U\nAlg R B' U R B L U' B\n\nAlg U L U' B' U L' U' B\nAlg U' B L U L B' U' L'\n\nAlg U R' U' L B R' B' R\nAlg R' U' R U B' U' B L`,\n  );\n}\n"],
+  "mappings": ";;;;;;;;;;;;AAOA,uCAAyD;AACvD,QAAM,KAAK,wBAAwB,SAAS;AAAA,IAC1C,UAAU;AAAA,IACV,cAAc;AAAA;AAEhB,SAAO,IAAI,QAAQ,GAAG,qBAAqB,OAAO;AAAA,IAChD,wBAAwB,IAAI,WAC1B,IACA,GAAG,aAAa;AAAA;AAAA;AAMtB,IAAI,WAAoC;AACxC,6CAAsE;AACpE,SAAQ,wBAAa;AAAA;AAGvB,IAAI,aAA4C;AAChD,8BAAqC;AACnC,SAAQ,4BAAe;AAAA;AAGzB,yCAAwE;AACtE,SAAO;AAAA,IACL,UAAW,OAAM,gBAAgB,SAAS,MAAM;AAAA;AAAA;AAKpD,sCAA8D;AAC5D,SAAO,SACL,MAAM,+BACN;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}

package/dist/esm/{chunk-4IUYLRHT.js → chunk-U2TSTTDG.js}

@@ -49,8 +49,18 @@ function baseMetric(move) {
     return 1;
   }
 }
+function quantumMetric(move) {
+  const fam = move.family;
+  if (isCharUppercase(fam[0]) && fam[fam.length - 1] === "v" || fam === "x" || fam === "y" || fam === "z" || fam === "T") {
+    return 0;
+  } else {
+    return Math.abs(move.amount);
+  }
+}
 var countMovesInstance = new CountMoves(baseMetric);
 var countMoves = countMovesInstance.traverseAlg.bind(countMovesInstance);
+var countQuantumMovesInstance = new CountMoves(quantumMetric);
+var countQuantumMoves = countQuantumMovesInstance.traverseAlg.bind(countQuantumMovesInstance);
 
 // src/cubing/notation/CountAnimatedLeaves.ts
 var CountAnimatedLeaves = class extends TraversalUp {
@@ -88,6 +98,7 @@ var countAnimatedLeaves = countAnimatedLeavesInstance.traverseAlg.bind(countAnim
 
 export {
   countMoves,
+  countQuantumMoves,
   countAnimatedLeaves
 };
-//# sourceMappingURL=chunk-4IUYLRHT.js.map
+//# sourceMappingURL=chunk-U2TSTTDG.js.map

package/dist/esm/chunk-U2TSTTDG.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/notation/CountMoves.ts", "../../src/cubing/notation/CountAnimatedLeaves.ts"],
+  "sourcesContent": ["// TODO: move this file somewhere permanent.\nimport {\n  Alg,\n  Grouping,\n  LineComment,\n  Commutator,\n  Conjugate,\n  Move,\n  Newline,\n  Pause,\n  TraversalUp,\n} from \"../alg\";\n\n/*\n *   For movecount, that understands puzzle rotations.  This code\n *   should be moved to the alg class, probably.\n */\nclass CountMoves extends TraversalUp<number> {\n  constructor(private metric: (move: Move) => number) {\n    super();\n  }\n\n  public traverseAlg(alg: Alg): number {\n    let r = 0;\n    for (const unit of alg.units()) {\n      r += this.traverseUnit(unit);\n    }\n    return r;\n  }\n\n  public traverseGrouping(grouping: Grouping): number {\n    // const unit: Unit = Alg.fromString(\"SDf\");\n    // console.log(unit);\n    const alg: Alg = grouping.alg;\n    return this.traverseAlg(alg) * Math.abs(grouping.amount);\n  }\n\n  public traverseMove(move: Move): number {\n    return this.metric(move);\n  }\n\n  public traverseCommutator(commutator: Commutator): number {\n    return (\n      2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B))\n    );\n  }\n\n  public traverseConjugate(conjugate: Conjugate): number {\n    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);\n  }\n\n  // TODO: Remove spaces between repeated pauses (in traverseSequence)\n  public traversePause(_pause: Pause): number {\n    return 0;\n  }\n\n  public traverseNewline(_newLine: Newline): number {\n    return 0;\n  }\n\n  // TODO: Enforce being followed by a newline (or the end of the alg)?\n  public traverseLineComment(_comment: LineComment): number {\n    return 0;\n  }\n}\n\nfunction isCharUppercase(c: string): boolean {\n  return \"A\" <= c && c <= \"Z\";\n}\n\n// TODO: Implement a puzzle-specific way to calculate this.\nfunction baseMetric(move: Move): number {\n  const fam = move.family;\n  if (\n    (isCharUppercase(fam[0]) && fam[fam.length - 1] === \"v\") ||\n    fam === \"x\" ||\n    fam === \"y\" ||\n    fam === \"z\" ||\n    fam === \"T\"\n  ) {\n    return 0;\n  } else {\n    return 1;\n  }\n}\n\n// TODO: Implement a puzzle-specific way to calculate this.\nfunction quantumMetric(move: Move): number {\n  const fam = move.family;\n  if (\n    (isCharUppercase(fam[0]) && fam[fam.length - 1] === \"v\") ||\n    fam === \"x\" ||\n    fam === \"y\" ||\n    fam === \"z\" ||\n    fam === \"T\"\n  ) {\n    return 0;\n  } else {\n    return Math.abs(move.amount);\n  }\n}\n\nconst countMovesInstance = new CountMoves(baseMetric);\nexport const countMoves: (alg: Alg) => number =\n  countMovesInstance.traverseAlg.bind(countMovesInstance);\n\nconst countQuantumMovesInstance = new CountMoves(quantumMetric);\nexport const countQuantumMoves: (alg: Alg) => number =\n  countQuantumMovesInstance.traverseAlg.bind(countQuantumMovesInstance);\n", "import {\n  Alg,\n  Commutator,\n  Conjugate,\n  Grouping,\n  LineComment,\n  Move,\n  Newline,\n  Pause,\n  TraversalUp,\n} from \"../alg\";\n\n// TODO: Include Pause, include amounts\nclass CountAnimatedLeaves extends TraversalUp<number, number> {\n  public traverseAlg(alg: Alg): number {\n    let total = 0;\n    for (const part of alg.units()) {\n      total += this.traverseUnit(part);\n    }\n    return total;\n  }\n\n  public traverseGrouping(grouping: Grouping): number {\n    return this.traverseAlg(grouping.alg) * Math.abs(grouping.amount);\n  }\n\n  public traverseMove(_move: Move): number {\n    return 1;\n  }\n\n  public traverseCommutator(commutator: Commutator): number {\n    return (\n      2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B))\n    );\n  }\n\n  public traverseConjugate(conjugate: Conjugate): number {\n    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);\n  }\n\n  public traversePause(_pause: Pause): number {\n    return 1;\n  }\n\n  public traverseNewline(_newline: Newline): number {\n    return 0;\n  }\n\n  public traverseLineComment(_comment: LineComment): number {\n    return 0;\n  }\n}\n\nconst countAnimatedLeavesInstance = new CountAnimatedLeaves();\nexport const countAnimatedLeaves: (alg: Alg) => number =\n  countAnimatedLeavesInstance.traverseAlg.bind(countAnimatedLeavesInstance);\n"],
+  "mappings": ";;;;;AAiBA,+BAAyB,YAAoB;AAAA,EAC3C,YAAoB,QAAgC;AAClD;AADkB;AAAA;AAAA,EAIb,YAAY,KAAkB;AACnC,QAAI,IAAI;AACR,eAAW,QAAQ,IAAI,SAAS;AAC9B,WAAK,KAAK,aAAa;AAAA;AAEzB,WAAO;AAAA;AAAA,EAGF,iBAAiB,UAA4B;AAGlD,UAAM,MAAW,SAAS;AAC1B,WAAO,KAAK,YAAY,OAAO,KAAK,IAAI,SAAS;AAAA;AAAA,EAG5C,aAAa,MAAoB;AACtC,WAAO,KAAK,OAAO;AAAA;AAAA,EAGd,mBAAmB,YAAgC;AACxD,WACE,IAAK,MAAK,YAAY,WAAW,KAAK,KAAK,YAAY,WAAW;AAAA;AAAA,EAI/D,kBAAkB,WAA8B;AACrD,WAAO,IAAI,KAAK,YAAY,UAAU,KAAK,KAAK,YAAY,UAAU;AAAA;AAAA,EAIjE,cAAc,QAAuB;AAC1C,WAAO;AAAA;AAAA,EAGF,gBAAgB,UAA2B;AAChD,WAAO;AAAA;AAAA,EAIF,oBAAoB,UAA+B;AACxD,WAAO;AAAA;AAAA;AAIX,yBAAyB,GAAoB;AAC3C,SAAO,OAAO,KAAK,KAAK;AAAA;AAI1B,oBAAoB,MAAoB;AACtC,QAAM,MAAM,KAAK;AACjB,MACG,gBAAgB,IAAI,OAAO,IAAI,IAAI,SAAS,OAAO,OACpD,QAAQ,OACR,QAAQ,OACR,QAAQ,OACR,QAAQ,KACR;AACA,WAAO;AAAA,SACF;AACL,WAAO;AAAA;AAAA;AAKX,uBAAuB,MAAoB;AACzC,QAAM,MAAM,KAAK;AACjB,MACG,gBAAgB,IAAI,OAAO,IAAI,IAAI,SAAS,OAAO,OACpD,QAAQ,OACR,QAAQ,OACR,QAAQ,OACR,QAAQ,KACR;AACA,WAAO;AAAA,SACF;AACL,WAAO,KAAK,IAAI,KAAK;AAAA;AAAA;AAIzB,IAAM,qBAAqB,IAAI,WAAW;AACnC,IAAM,aACX,mBAAmB,YAAY,KAAK;AAEtC,IAAM,4BAA4B,IAAI,WAAW;AAC1C,IAAM,oBACX,0BAA0B,YAAY,KAAK;;;AC/F7C,wCAAkC,YAA4B;AAAA,EACrD,YAAY,KAAkB;AACnC,QAAI,QAAQ;AACZ,eAAW,QAAQ,IAAI,SAAS;AAC9B,eAAS,KAAK,aAAa;AAAA;AAE7B,WAAO;AAAA;AAAA,EAGF,iBAAiB,UAA4B;AAClD,WAAO,KAAK,YAAY,SAAS,OAAO,KAAK,IAAI,SAAS;AAAA;AAAA,EAGrD,aAAa,OAAqB;AACvC,WAAO;AAAA;AAAA,EAGF,mBAAmB,YAAgC;AACxD,WACE,IAAK,MAAK,YAAY,WAAW,KAAK,KAAK,YAAY,WAAW;AAAA;AAAA,EAI/D,kBAAkB,WAA8B;AACrD,WAAO,IAAI,KAAK,YAAY,UAAU,KAAK,KAAK,YAAY,UAAU;AAAA;AAAA,EAGjE,cAAc,QAAuB;AAC1C,WAAO;AAAA;AAAA,EAGF,gBAAgB,UAA2B;AAChD,WAAO;AAAA;AAAA,EAGF,oBAAoB,UAA+B;AACxD,WAAO;AAAA;AAAA;AAIX,IAAM,8BAA8B,IAAI;AACjC,IAAM,sBACX,4BAA4B,YAAY,KAAK;",
+  "names": []
+}

package/dist/esm/chunk-UYT3253Q.js

@@ -0,0 +1,423 @@
+import {
+  __privateAdd,
+  __privateGet,
+  __privateMethod,
+  __privateSet,
+  __privateWrapper
+} from "./chunk-WO2AXYFE.js";
+
+// src/cubing/vendor/p-lazy/p-lazy.ts
+var PLazy = class extends Promise {
+  constructor(executor) {
+    super((resolve) => {
+      resolve();
+    });
+    this._executor = executor;
+  }
+  static from(function_) {
+    return new PLazy((resolve) => {
+      resolve(function_());
+    });
+  }
+  static resolve(value) {
+    return new PLazy((resolve) => {
+      resolve(value);
+    });
+  }
+  static reject(error) {
+    return new PLazy((_resolve, reject) => {
+      reject(error);
+    });
+  }
+  then(onFulfilled, onRejected) {
+    this._promise = this._promise || new Promise(this._executor);
+    return this._promise.then(onFulfilled, onRejected);
+  }
+  catch(onRejected) {
+    this._promise = this._promise || new Promise(this._executor);
+    return this._promise.catch(onRejected);
+  }
+};
+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 };
+    }
+  }
+};
+_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);
+      }
+    });
+  }
+};
+_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, new Set());
+    this.lastSourceGeneration = 0;
+    __privateAdd(this, _rawListeners, new Set());
+    __privateAdd(this, _rawDispatchPending, false);
+    __privateAdd(this, _freshListeners, new Map());
+  }
+  canReuse(v1, v2) {
+    return v1 === v2 || this.canReuseValue(v1, v2);
+  }
+  canReuseValue(_v1, _v2) {
+    return false;
+  }
+  debugGetChildren() {
+    return Array.from(__privateGet(this, _children).values());
+  }
+  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;
+    }
+    this.lastSourceGeneration = sourceEvent.detail.generation;
+    for (const child of __privateGet(this, _children)) {
+      child.markStale(sourceEvent);
+    }
+    __privateMethod(this, _scheduleRawDispatch, scheduleRawDispatch_fn).call(this);
+  }
+  addRawListener(listener, options) {
+    __privateGet(this, _rawListeners).add(listener);
+    if (options?.initial) {
+      listener();
+    }
+  }
+  removeRawListener(listener) {
+    __privateGet(this, _rawListeners).delete(listener);
+  }
+  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 });
+  }
+  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);
+  }
+};
+_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, _value, void 0);
+    __privateSet(this, _value, from(() => this.getDefaultValue()));
+    if (initialValue) {
+      __privateSet(this, _value, this.deriveFromPromiseOrValue(initialValue, __privateGet(this, _value)));
+    }
+  }
+  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
+    }));
+  }
+  async get() {
+    return __privateGet(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);
+    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;
+  }
+};
+_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])) {
+      return cache(await this.derive(inputs));
+    }
+  }
+  return cachedLatestGenerationCalculation.output;
+};
+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/StickeringProp.ts
+var experimentalStickerings = {
+  "full": true,
+  "centers-only": true,
+  "PLL": true,
+  "CLS": true,
+  "OLL": true,
+  "COLL": true,
+  "OCLL": true,
+  "CLL": true,
+  "ELL": true,
+  "ELS": true,
+  "LL": true,
+  "F2L": true,
+  "ZBLL": true,
+  "ZBLS": true,
+  "WVLS": true,
+  "VLS": true,
+  "LS": true,
+  "EO": true,
+  "EOline": true,
+  "EOcross": true,
+  "CMLL": true,
+  "L6E": true,
+  "L6EO": true,
+  "Daisy": true,
+  "Cross": true,
+  "2x2x2": true,
+  "2x2x3": true,
+  "Void Cube": true,
+  "invisible": true,
+  "picture": true,
+  "experimental-centers-U": true,
+  "experimental-centers-U-D": true,
+  "experimental-centers-U-L-D": true,
+  "experimental-centers-U-L-B-D": true,
+  "experimental-centers": true,
+  "experimental-fto-fc": true,
+  "experimental-fto-f2t": true,
+  "experimental-fto-sc": true,
+  "experimental-fto-l2c": true,
+  "experimental-fto-lbt": true,
+  "experimental-fto-l3t": true,
+  "experimental-global-custom-1": true,
+  "experimental-global-custom-2": true
+};
+var StickeringProp = class extends SimpleTwistyPropSource {
+  getDefaultValue() {
+    return "full";
+  }
+};
+
+// 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/views/3D/TAU.ts
+var TAU = Math.PI * 2;
+var DEGREES_PER_RADIAN = 360 / TAU;
+
+// src/cubing/twisty/heavy-code-imports/3d.ts
+var cachedConstructorProxy = null;
+async function proxy3D() {
+  return cachedConstructorProxy ?? (cachedConstructorProxy = import("./3d-dynamic-inside-OGANXBOW.js"));
+}
+var THREEJS = from(async () => (await proxy3D()).T3I);
+
+export {
+  StaleDropper,
+  TwistyPropSource,
+  SimpleTwistyPropSource,
+  NO_VALUE,
+  TwistyPropDerived,
+  FreshListenerManager,
+  hintFaceletStyles,
+  HintFaceletProp,
+  experimentalStickerings,
+  StickeringProp,
+  TAU,
+  DEGREES_PER_RADIAN,
+  proxy3D,
+  THREEJS
+};
+//# sourceMappingURL=chunk-UYT3253Q.js.map

package/dist/esm/chunk-UYT3253Q.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/cubing/vendor/p-lazy/p-lazy.ts", "../../src/cubing/twisty/model/PromiseFreshener.ts", "../../src/cubing/twisty/model/props/TwistyProp.ts", "../../src/cubing/twisty/model/props/puzzle/display/StickeringProp.ts", "../../src/cubing/twisty/model/props/puzzle/display/HintFaceletProp.ts", "../../src/cubing/twisty/views/3D/TAU.ts", "../../src/cubing/twisty/heavy-code-imports/3d.ts"],
+  "sourcesContent": ["// eslint-disable-next-line @typescript-eslint/ban-ts-comment\n// @ts-nocheck\n\n// TODO: Use private class fields when ESLint support it.\n\nexport class PLazy<T> extends Promise<T> {\n  constructor(executor) {\n    super((resolve) => {\n      resolve();\n    });\n\n    this._executor = executor;\n  }\n\n  static from(function_) {\n    return new PLazy((resolve) => {\n      resolve(function_());\n    });\n  }\n\n  static resolve(value) {\n    return new PLazy((resolve) => {\n      resolve(value);\n    });\n  }\n\n  static reject(error) {\n    return new PLazy((_resolve, reject) => {\n      reject(error);\n    });\n  }\n\n  then(onFulfilled, onRejected) {\n    this._promise = this._promise || new Promise(this._executor);\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return this._promise.then(onFulfilled, onRejected);\n  }\n\n  catch(onRejected) {\n    this._promise = this._promise || new Promise(this._executor);\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-return\n    return this._promise.catch(onRejected);\n  }\n}\n\nexport function from<T>(function_): Promise<T> {\n  return new PLazy((resolve) => {\n    resolve(function_());\n  });\n}\n", "// TODO: Pick a much better name.\nexport class PromiseFreshener<T> {\n  #latestAssignedIdx = 0;\n  #latestResolvedIdx = 0;\n\n  // TODO: reject instead? Drop?\n  async queue(\n    p: Promise<T>,\n  ): Promise<{ fresh: false } | { fresh: true; result: T }> {\n    const idx = ++this.#latestAssignedIdx;\n    const result = await p;\n    if (idx > this.#latestResolvedIdx) {\n      this.#latestResolvedIdx = idx;\n      return {\n        fresh: true,\n        result: result,\n      };\n    } else {\n      return { fresh: false };\n    }\n  }\n}\n\n// This will silenty drop a queued Promise (i.e. not resolve it) if a\n// newer queued one already resolved first. This is useful for classes that want\n// to know the \"latest\" state of something without jumping back to an older\n// value by accident.\n// TODO: Remove this because it's too easy to misuse?\nexport class StaleDropper<T> {\n  #latestAssignedIdx = 0;\n  #latestResolvedIdx = 0;\n\n  queue(p: Promise<T>): Promise<T> {\n    // This is a very rare case where we *do* want to drop a Promise sometimes.\n    // eslint-disable-next-line no-async-promise-executor\n    return new Promise(async (resolve, reject) => {\n      try {\n        const idx = ++this.#latestAssignedIdx;\n        const result = await p;\n        if (idx > this.#latestResolvedIdx) {\n          this.#latestResolvedIdx = idx;\n          resolve(result);\n        }\n      } catch (e) {\n        reject(e);\n      }\n    });\n  }\n}\n", "import { from } from \"../../../vendor/p-lazy/p-lazy\";\nimport { StaleDropper } from \"../PromiseFreshener\";\nimport type { UserVisibleErrorTracker } from \"../UserVisibleErrorTracker\";\n\n/*eslint @typescript-eslint/ban-types:off */\ntype InputRecord = {};\n\nexport type InputProps<T extends InputRecord> = {\n  [s in keyof T]: TwistyPropParent<T[s]>;\n};\n\ntype InputPromises<T extends InputRecord> = {\n  [s in keyof T]: Promise<T[s]>;\n};\n\ninterface SourceEventDetail<OutputType> {\n  sourceProp: TwistyPropSource<OutputType, any>;\n  value: Promise<OutputType>; // TODO: remove?\n  generation: number;\n}\n\ntype SourceEvent<T> = CustomEvent<SourceEventDetail<T>>;\n\ntype PromiseOrValue<T> = T | Promise<T>;\n\n// Values of T must be immutable.\nlet globalSourceGeneration = 0; // This is incremented before being used, so 1 will be the first active value.\nexport abstract class TwistyPropParent<T> {\n  public abstract get(): Promise<T>;\n\n  // Don't overwrite this. Overwrite `canReuseValue` instead.\n  canReuse(v1: T, v2: T): boolean {\n    return v1 === v2 || this.canReuseValue(v1, v2);\n  }\n\n  // Overwrite with a cheap semantic comparison when possible.\n  // Note that this is not called if `v1 === v2` (in which case the value is automatically reused).\n  canReuseValue(_v1: T, _v2: T): boolean {\n    return false;\n  }\n\n  debugGetChildren(): Array<TwistyPropDerived<any, any>> {\n    return Array.from(this.#children.values());\n  }\n\n  // Propagation\n\n  #children: Set<TwistyPropDerived<any, any>> = new Set();\n  protected addChild(child: TwistyPropDerived<any, any>): void {\n    this.#children.add(child);\n  }\n\n  protected removeChild(child: TwistyPropDerived<any, any>): void {\n    this.#children.delete(child);\n  }\n\n  protected lastSourceGeneration: number = 0;\n  // Synchronously marks all descendants as stale. This doesn't actually\n  // literally mark as stale, but it updates the last source generation, which\n  // is used to tell if a cahced result is stale.\n  protected markStale(sourceEvent: SourceEvent<any>): void {\n    if (sourceEvent.detail.generation !== globalSourceGeneration) {\n      // The full stale propagation is synchronous, so there should not be a new one yet.\n      throw new Error(\"A TwistyProp was marked stale too late!\");\n    }\n    if (this.lastSourceGeneration === sourceEvent.detail.generation) {\n      // Already propagated.\n      return;\n    }\n    this.lastSourceGeneration = sourceEvent.detail.generation;\n    for (const child of this.#children) {\n      child.markStale(sourceEvent);\n    }\n    // We schedule sending out events *after* the (synchronous) propagation has happened, in\n    // case one of the listeners updates a source again.\n    this.#scheduleRawDispatch();\n  }\n\n  #rawListeners: Set<() => void> = new Set();\n  /** @deprecated */\n  addRawListener(listener: () => void, options?: { initial: boolean }): void {\n    this.#rawListeners.add(listener);\n    if (options?.initial) {\n      listener(); // TODO: wrap in a try?\n    }\n  }\n\n  /** @deprecated */\n  removeRawListener(listener: () => void): void {\n    this.#rawListeners.delete(listener);\n  }\n\n  /** @deprecated */\n  #scheduleRawDispatch(): void {\n    if (!this.#rawDispatchPending) {\n      this.#rawDispatchPending = true;\n      setTimeout(() => this.#dispatchRawListeners(), 0);\n    }\n  }\n\n  #rawDispatchPending: boolean = false;\n  #dispatchRawListeners(): void {\n    if (!this.#rawDispatchPending) {\n      throw new Error(\"Invalid dispatch state!\");\n    }\n    for (const listener of this.#rawListeners) {\n      listener(); // TODO: wrap in a try?\n    }\n    this.#rawDispatchPending = false;\n  }\n\n  #freshListeners: Map<(value: T) => void, () => void> = new Map();\n  // TODO: Pick a better name.\n  addFreshListener(listener: (value: T) => void): void {\n    const staleDropper: StaleDropper<T> = new StaleDropper<T>();\n    let lastResult: T | null = null;\n    const callback = async () => {\n      const result = await staleDropper.queue(this.get());\n      if (lastResult !== null && this.canReuse(lastResult, result)) {\n        return;\n      }\n      lastResult = result;\n      listener(result);\n    };\n    this.#freshListeners.set(listener, callback);\n    this.addRawListener(callback, { initial: true });\n  }\n\n  removeFreshListener(listener: (value: T) => void): void {\n    this.removeRawListener(this.#freshListeners.get(listener)!); // TODO: throw a custom error?\n    this.#freshListeners.delete(listener);\n  }\n}\n\nexport abstract class TwistyPropSource<\n  OutputType,\n  InputType = OutputType,\n> extends TwistyPropParent<OutputType> {\n  #value: Promise<OutputType>;\n\n  public abstract getDefaultValue(): PromiseOrValue<OutputType>;\n\n  constructor(initialValue?: PromiseOrValue<InputType>) {\n    super();\n    this.#value = from(() => this.getDefaultValue());\n    if (initialValue) {\n      this.#value = this.deriveFromPromiseOrValue(initialValue, this.#value);\n    }\n  }\n\n  set(input: PromiseOrValue<InputType>): void {\n    this.#value = this.deriveFromPromiseOrValue(input, this.#value);\n\n    const sourceEventDetail: SourceEventDetail<OutputType> = {\n      sourceProp: this,\n      value: this.#value,\n      generation: ++globalSourceGeneration,\n    };\n    this.markStale(\n      new CustomEvent<SourceEventDetail<OutputType>>(\"stale\", {\n        detail: sourceEventDetail,\n      }),\n    );\n  }\n\n  async get(): Promise<OutputType> {\n    return this.#value;\n  }\n\n  async deriveFromPromiseOrValue(\n    input: PromiseOrValue<InputType>,\n    oldValuePromise: Promise<OutputType>,\n  ): Promise<OutputType> {\n    return this.derive(await input, oldValuePromise);\n  }\n\n  // TODO: add an indirect layer to cache the derivation?\n  protected abstract derive(\n    input: InputType,\n    oldValuePromise: Promise<OutputType>,\n  ): PromiseOrValue<OutputType>;\n}\n\nexport abstract class SimpleTwistyPropSource<\n  SimpleType,\n> extends TwistyPropSource<SimpleType> {\n  derive(input: SimpleType): PromiseOrValue<SimpleType> {\n    return input;\n  }\n}\n\n// TODO: Can we support `null` as a valid output value without loosening type\n// safety?\nexport const NO_VALUE = Symbol(\"no value\");\nexport type NoValueType = typeof NO_VALUE;\n\nexport abstract class TwistyPropDerived<\n  InputTypes extends InputRecord,\n  OutputType,\n> extends TwistyPropParent<OutputType> {\n  // cachedInputs:\n  #parents: InputProps<InputTypes>;\n\n  constructor(\n    parents: InputProps<InputTypes>,\n    protected userVisibleErrorTracker?: UserVisibleErrorTracker,\n  ) {\n    super();\n    this.#parents = parents;\n    for (const parent of Object.values(parents)) {\n      (\n        parent as TwistyPropDerived<InputProps<InputTypes>, OutputType>\n      ).addChild(this);\n    }\n  }\n\n  #cachedLastSuccessfulCalculation: {\n    inputs: InputTypes;\n    output: Promise<OutputType>;\n    generation: number;\n  } | null = null;\n\n  #cachedLatestGenerationCalculation: {\n    output: Promise<OutputType>;\n    generation: number;\n  } | null = null;\n\n  public async get(): Promise<OutputType> {\n    const generation = this.lastSourceGeneration;\n\n    if (this.#cachedLatestGenerationCalculation?.generation === generation) {\n      return this.#cachedLatestGenerationCalculation.output;\n    }\n\n    const latestGenerationCalculation = {\n      generation,\n      output: this.#cacheDerive(\n        this.#getParents(),\n        generation,\n        this.#cachedLastSuccessfulCalculation,\n      ),\n    };\n    this.#cachedLatestGenerationCalculation = latestGenerationCalculation;\n\n    this.userVisibleErrorTracker?.reset();\n    return latestGenerationCalculation.output;\n  }\n\n  async #getParents(): Promise<InputTypes> {\n    const inputValuePromises: InputPromises<InputRecord> = {} as any; // TODO\n    for (const [key, parent] of Object.entries(this.#parents)) {\n      (inputValuePromises as Record<string, Promise<unknown>>)[key] = (\n        parent as TwistyPropParent<unknown>\n      ).get();\n    }\n\n    const inputs: InputTypes = {} as any; // TODO\n    for (const key in this.#parents) {\n      inputs[key] = (await (\n        inputValuePromises as Record<string, Promise<unknown>>\n      )[key]) as any;\n    }\n    return inputs;\n  }\n\n  async #cacheDerive(\n    inputsPromise: PromiseOrValue<InputTypes>,\n    generation: number,\n    cachedLatestGenerationCalculation: {\n      inputs: InputTypes;\n      output: Promise<OutputType>;\n      generation: number;\n    } | null = null,\n  ): Promise<OutputType> {\n    const inputs = await inputsPromise;\n\n    const cache = (output: OutputType): OutputType => {\n      this.#cachedLastSuccessfulCalculation = {\n        inputs,\n        output: Promise.resolve(output),\n        generation,\n      };\n      return output;\n    };\n\n    if (!cachedLatestGenerationCalculation) {\n      return cache(await this.derive(inputs));\n    }\n\n    const cachedInputs = cachedLatestGenerationCalculation.inputs;\n    for (const key in this.#parents) {\n      const parent = this.#parents[key];\n      if (!parent.canReuse(inputs[key], cachedInputs[key])) {\n        return cache(await this.derive(inputs));\n      }\n    }\n\n    return cachedLatestGenerationCalculation.output;\n  }\n\n  protected abstract derive(input: InputTypes): PromiseOrValue<OutputType>;\n}\n\nexport class FreshListenerManager {\n  #disconnectionFunctions: (() => void)[] = [];\n\n  addListener<T>(\n    prop: TwistyPropParent<T>,\n    listener: (value: T) => void,\n  ): void {\n    let disconnected = false;\n    const wrappedListener = (value: T) => {\n      if (disconnected) {\n        // TODO\n        // console.warn(\"Should be disconnected!\");\n        return;\n      }\n      listener(value);\n    };\n\n    prop.addFreshListener(wrappedListener);\n\n    this.#disconnectionFunctions.push(() => {\n      prop.removeFreshListener(wrappedListener);\n      disconnected = true;\n    });\n  }\n\n  addMultiListener<U, V>(\n    props: [TwistyPropParent<U>, TwistyPropParent<V>],\n    listener: (values: [U, V]) => void,\n  ) {\n    let disconnected = false;\n    const wrappedListener = async (_: any) => {\n      if (disconnected) {\n        // TODO\n        // console.warn(\"Should be disconnected!\");\n        return;\n      }\n      // We rely on `TwistyProp` caching to give us the full set of latest\n      // values efficiently.\n      const promises = (props as TwistyPropParent<any>[]).map((prop) =>\n        prop.get(),\n      );\n      const values = await Promise.all(promises);\n      listener(values as any); // TODO: fix up types\n    };\n\n    for (const prop of props) {\n      prop.addFreshListener(wrappedListener);\n    }\n\n    this.#disconnectionFunctions.push(() => {\n      for (const prop of props) {\n        prop.removeFreshListener(wrappedListener);\n      }\n      disconnected = true;\n    });\n  }\n\n  disconnect(): void {\n    for (const disconnectionFunction of this.#disconnectionFunctions) {\n      disconnectionFunction();\n    }\n  }\n}\n", "import { SimpleTwistyPropSource } from \"../../TwistyProp\";\n\n// TODO: turn these maps into lists?\n// TODO: alg.cubing.net parity\nexport const experimentalStickerings = {\n  \"full\": true, // default\n  \"centers-only\": true, // TODO\n  \"PLL\": true,\n  \"CLS\": true,\n  \"OLL\": true,\n  \"COLL\": true,\n  \"OCLL\": true,\n  \"CLL\": true,\n  \"ELL\": true,\n  \"ELS\": true,\n  \"LL\": true,\n  \"F2L\": true,\n  \"ZBLL\": true,\n  \"ZBLS\": true,\n  \"WVLS\": true,\n  \"VLS\": true,\n  \"LS\": true,\n  \"EO\": true,\n  \"EOline\": true,\n  \"EOcross\": true,\n  \"CMLL\": true,\n  \"L6E\": true,\n  \"L6EO\": true,\n  \"Daisy\": true,\n  \"Cross\": true,\n  \"2x2x2\": true,\n  \"2x2x3\": true,\n  \"Void Cube\": true,\n  \"invisible\": true,\n  \"picture\": true,\n  \"experimental-centers-U\": true,\n  \"experimental-centers-U-D\": true,\n  \"experimental-centers-U-L-D\": true,\n  \"experimental-centers-U-L-B-D\": true,\n  \"experimental-centers\": true,\n  \"experimental-fto-fc\": true,\n  \"experimental-fto-f2t\": true,\n  \"experimental-fto-sc\": true,\n  \"experimental-fto-l2c\": true,\n  \"experimental-fto-lbt\": true,\n  \"experimental-fto-l3t\": true,\n  \"experimental-global-custom-1\": true,\n  \"experimental-global-custom-2\": true,\n};\nexport type ExperimentalStickering = keyof typeof experimentalStickerings;\n\nexport class StickeringProp extends SimpleTwistyPropSource<ExperimentalStickering> {\n  getDefaultValue(): ExperimentalStickering {\n    return \"full\"; // TODO: auto\n  }\n}\n", "import { SimpleTwistyPropSource } from \"../../TwistyProp\";\n\n// TODO: turn these maps into lists?\nexport const hintFaceletStyles = {\n  floating: true, // default\n  none: true,\n};\nexport type HintFaceletStyle = keyof typeof hintFaceletStyles;\nexport type HintFaceletStyleWithAuto = HintFaceletStyle | \"auto\";\n\nexport class HintFaceletProp extends SimpleTwistyPropSource<HintFaceletStyleWithAuto> {\n  getDefaultValue(): HintFaceletStyleWithAuto {\n    return \"auto\";\n  }\n}\n", "export const TAU = Math.PI * 2;\nexport const DEGREES_PER_RADIAN = 360 / TAU;\n", "import { from } from \"../../vendor/p-lazy/p-lazy\";\n\n// TODO can we remove the cached proxy?\n\n// In theory we can, but we've run into situations where imports are not properly cached.\nlet cachedConstructorProxy: Promise<\n  typeof import(\"./dynamic-entries/3d-dynamic-inside\")\n> | null = null;\n\nexport async function proxy3D(): Promise<\n  typeof import(\"./dynamic-entries/3d-dynamic-inside\")\n> {\n  return (cachedConstructorProxy ??= import(\n    \"./dynamic-entries/3d-dynamic-inside\"\n  ));\n}\n\nexport const THREEJS: Promise<typeof import(\"three\")> = from(\n  async () => (await proxy3D()).T3I,\n);\n"],
+  "mappings": "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",
+  "names": []
+}