cubing 0.56.0 → 0.57.0

package/dist/lib/cubing/chunks/{chunk-TQF5J7MH.js → chunk-3YVVF3KK.js}

@@ -3,7 +3,7 @@ import {
   Move,
   TraversalDownUp,
   functionFromTraversal
-} from "./chunk-2SBMIHZV.js";
+} from "./chunk-SWKNZGJF.js";
 
 // src/cubing/kpuzzle/combine.ts
 function combineTransformationData(definition, transformationData1, transformationData2) {
@@ -160,82 +160,6 @@ function moveToTransformationUncached(kpuzzle, move) {
   throw new Error(`Invalid move for KPuzzle (${kpuzzle.name()}): ${move}`);
 }
 
-// src/cubing/kpuzzle/KPattern.ts
-var KPattern = class _KPattern {
-  constructor(kpuzzle, patternData) {
-    this.kpuzzle = kpuzzle;
-    this.patternData = patternData;
-  }
-  toJSON() {
-    return {
-      experimentalPuzzleName: this.kpuzzle.name(),
-      patternData: this.patternData
-    };
-  }
-  static fromTransformation(transformation) {
-    const newPatternData = applyTransformationDataToKPatternData(
-      transformation.kpuzzle.definition,
-      transformation.kpuzzle.definition.defaultPattern,
-      transformation.transformationData
-    );
-    return new _KPattern(transformation.kpuzzle, newPatternData);
-  }
-  // Convenience function
-  /** @deprecated */
-  apply(source) {
-    return this.applyTransformation(this.kpuzzle.toTransformation(source));
-  }
-  applyTransformation(transformation) {
-    if (transformation.isIdentityTransformation()) {
-      return new _KPattern(this.kpuzzle, this.patternData);
-    }
-    const newPatternData = applyTransformationDataToKPatternData(
-      this.kpuzzle.definition,
-      this.patternData,
-      transformation.transformationData
-    );
-    return new _KPattern(this.kpuzzle, newPatternData);
-  }
-  applyMove(move) {
-    return this.applyTransformation(this.kpuzzle.moveToTransformation(move));
-  }
-  applyAlg(alg) {
-    return this.applyTransformation(this.kpuzzle.algToTransformation(alg));
-  }
-  isIdentical(other) {
-    return isPatternDataIdentical(
-      this.kpuzzle,
-      this.patternData,
-      other.patternData
-    );
-  }
-  /** @deprecated */
-  experimentalToTransformation() {
-    if (!this.kpuzzle.canConvertDefaultPatternToUniqueTransformation()) {
-      return null;
-    }
-    const transformationData = {};
-    for (const [orbitName, patternOrbitData] of Object.entries(
-      this.patternData
-    )) {
-      const transformationOrbit = {
-        permutation: patternOrbitData.pieces,
-        orientationDelta: patternOrbitData.orientation
-      };
-      transformationData[orbitName] = transformationOrbit;
-    }
-    return new KTransformation(this.kpuzzle, transformationData);
-  }
-  experimentalIsSolved(options) {
-    if (!this.kpuzzle.definition.experimentalIsPatternSolved) {
-      throw new Error(
-        "`KPattern.experimentalIsPatternSolved()` is not supported for this puzzle at the moment."
-      );
-    }
-    return this.kpuzzle.definition.experimentalIsPatternSolved(this, options);
-  }
-};
-
 // src/cubing/kpuzzle/KTransformation.ts
 var KTransformation = class _KTransformation {
   constructor(kpuzzle, transformationData) {
@@ -559,6 +483,82 @@ function transformationRepetitionOrder(definition, transformation) {
   return order;
 }
 
+// src/cubing/kpuzzle/KPattern.ts
+var KPattern = class _KPattern {
+  constructor(kpuzzle, patternData) {
+    this.kpuzzle = kpuzzle;
+    this.patternData = patternData;
+  }
+  toJSON() {
+    return {
+      experimentalPuzzleName: this.kpuzzle.name(),
+      patternData: this.patternData
+    };
+  }
+  static fromTransformation(transformation) {
+    const newPatternData = applyTransformationDataToKPatternData(
+      transformation.kpuzzle.definition,
+      transformation.kpuzzle.definition.defaultPattern,
+      transformation.transformationData
+    );
+    return new _KPattern(transformation.kpuzzle, newPatternData);
+  }
+  // Convenience function
+  /** @deprecated */
+  apply(source) {
+    return this.applyTransformation(this.kpuzzle.toTransformation(source));
+  }
+  applyTransformation(transformation) {
+    if (transformation.isIdentityTransformation()) {
+      return new _KPattern(this.kpuzzle, this.patternData);
+    }
+    const newPatternData = applyTransformationDataToKPatternData(
+      this.kpuzzle.definition,
+      this.patternData,
+      transformation.transformationData
+    );
+    return new _KPattern(this.kpuzzle, newPatternData);
+  }
+  applyMove(move) {
+    return this.applyTransformation(this.kpuzzle.moveToTransformation(move));
+  }
+  applyAlg(alg) {
+    return this.applyTransformation(this.kpuzzle.algToTransformation(alg));
+  }
+  isIdentical(other) {
+    return isPatternDataIdentical(
+      this.kpuzzle,
+      this.patternData,
+      other.patternData
+    );
+  }
+  /** @deprecated */
+  experimentalToTransformation() {
+    if (!this.kpuzzle.canConvertDefaultPatternToUniqueTransformation()) {
+      return null;
+    }
+    const transformationData = {};
+    for (const [orbitName, patternOrbitData] of Object.entries(
+      this.patternData
+    )) {
+      const transformationOrbit = {
+        permutation: patternOrbitData.pieces,
+        orientationDelta: patternOrbitData.orientation
+      };
+      transformationData[orbitName] = transformationOrbit;
+    }
+    return new KTransformation(this.kpuzzle, transformationData);
+  }
+  experimentalIsSolved(options) {
+    if (!this.kpuzzle.definition.experimentalIsPatternSolved) {
+      throw new Error(
+        "`KPattern.experimentalIsPatternSolved()` is not supported for this puzzle at the moment."
+      );
+    }
+    return this.kpuzzle.definition.experimentalIsPatternSolved(this, options);
+  }
+};
+
 // src/cubing/kpuzzle/KPuzzle.ts
 var KPuzzle = class {
   constructor(definition, options) {
@@ -653,8 +653,8 @@ var KPuzzle = class {
 };
 
 export {
-  KPattern,
   KTransformation,
+  KPattern,
   KPuzzle
 };
-//# sourceMappingURL=chunk-TQF5J7MH.js.map
+//# sourceMappingURL=chunk-3YVVF3KK.js.map

package/dist/lib/cubing/chunks/chunk-3YVVF3KK.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cubing/kpuzzle/combine.ts", "../../../../src/cubing/kpuzzle/construct.ts", "../../../../src/cubing/kpuzzle/KTransformation.ts", "../../../../src/cubing/kpuzzle/calculate.ts", "../../../../src/cubing/kpuzzle/KPattern.ts", "../../../../src/cubing/kpuzzle/KPuzzle.ts"],
+  "sourcesContent": ["import { isOrbitTransformationDataIdentityUncached } from \"./calculate\";\nimport type {\n  KPatternData,\n  KPatternOrbitData,\n  KPuzzleDefinition,\n  KTransformationData,\n} from \"./KPuzzleDefinition\";\n\nexport function combineTransformationData(\n  definition: KPuzzleDefinition,\n  transformationData1: KTransformationData,\n  transformationData2: KTransformationData,\n): KTransformationData {\n  const newTransformationData = {} as KTransformationData;\n  for (const orbitDefinition of definition.orbits) {\n    const orbit1 = transformationData1[orbitDefinition.orbitName];\n    const orbit2 = transformationData2[orbitDefinition.orbitName];\n    if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        orbit2,\n      )\n    ) {\n      // common case for big cubes\n      newTransformationData[orbitDefinition.orbitName] = orbit1;\n    } else if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        orbit1,\n      )\n    ) {\n      newTransformationData[orbitDefinition.orbitName] = orbit2;\n    } else {\n      const newPerm = new Array(orbitDefinition.numPieces);\n      if (orbitDefinition.numOrientations === 1) {\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          newPerm[idx] = orbit1.permutation[orbit2.permutation[idx]];\n        }\n        newTransformationData[orbitDefinition.orbitName] = {\n          permutation: newPerm,\n          orientationDelta: orbit1.orientationDelta,\n        };\n      } else {\n        const newOri = new Array(orbitDefinition.numPieces);\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          newOri[idx] =\n            (orbit1.orientationDelta[orbit2.permutation[idx]] +\n              orbit2.orientationDelta[idx]) %\n            orbitDefinition.numOrientations;\n          newPerm[idx] = orbit1.permutation[orbit2.permutation[idx]];\n        }\n        newTransformationData[orbitDefinition.orbitName] = {\n          permutation: newPerm,\n          orientationDelta: newOri,\n        };\n      }\n    }\n  }\n  return newTransformationData;\n}\n\nexport function applyTransformationDataToKPatternData(\n  definition: KPuzzleDefinition,\n  patternData: KPatternData,\n  transformationData: KTransformationData,\n): KPatternData {\n  const newPatternData = {} as KPatternData;\n  for (const orbitDefinition of definition.orbits) {\n    const patternOrbit = patternData[orbitDefinition.orbitName];\n    const transformationOrbit = transformationData[orbitDefinition.orbitName];\n    if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        transformationOrbit,\n      )\n    ) {\n      // common case for big cubes\n      newPatternData[orbitDefinition.orbitName] = patternOrbit;\n    } else {\n      const newPieces = new Array(orbitDefinition.numPieces);\n      if (orbitDefinition.numOrientations === 1) {\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          newPieces[idx] =\n            patternOrbit.pieces[transformationOrbit.permutation[idx]];\n        }\n        const newOrbitData: KPatternOrbitData = {\n          pieces: newPieces,\n          orientation: patternOrbit.orientation, // copy all 0\n        };\n        newPatternData[orbitDefinition.orbitName] = newOrbitData;\n      } else {\n        const newOrientation = new Array(orbitDefinition.numPieces);\n        const newOrientationMod: number[] | undefined =\n          patternOrbit.orientationMod\n            ? new Array(orbitDefinition.numPieces)\n            : undefined;\n        for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n          const transformationIdx = transformationOrbit.permutation[idx];\n          let mod = orbitDefinition.numOrientations;\n          if (patternOrbit.orientationMod) {\n            const orientationMod =\n              patternOrbit.orientationMod[transformationIdx];\n            newOrientationMod![idx] = orientationMod;\n            mod = orientationMod || orbitDefinition.numOrientations;\n          }\n          newOrientation[idx] =\n            (patternOrbit.orientation[transformationIdx] +\n              transformationOrbit.orientationDelta[idx]) %\n            mod; // We don't have to use `modIntoRange` (assuming input is well-formed), because we're adding.\n          newPieces[idx] = patternOrbit.pieces[transformationIdx];\n        }\n        const newOrbitData: KPatternOrbitData = {\n          pieces: newPieces,\n          orientation: newOrientation,\n        };\n        if (newOrientationMod) {\n          newOrbitData.orientationMod = newOrientationMod;\n        }\n        newPatternData[orbitDefinition.orbitName] = newOrbitData;\n      }\n    }\n  }\n  return newPatternData;\n}\n", "import type { Move } from \"../alg\";\nimport { repeatTransformationUncached } from \"./calculate\";\nimport type { KPuzzle } from \"./KPuzzle\";\nimport type {\n  KPuzzleDefinition,\n  KTransformationData,\n  KTransformationOrbitData,\n} from \"./KPuzzleDefinition\";\n\nconst FREEZE: boolean = false;\n\nconst identityOrbitCache = new Map<number, KTransformationOrbitData>();\nfunction constructIdentityOrbitTransformation(\n  numPieces: number,\n): KTransformationOrbitData {\n  const cached = identityOrbitCache.get(numPieces);\n  if (cached) {\n    return cached;\n  }\n\n  const newPermutation = new Array(numPieces);\n  const newOrientation = new Array(numPieces);\n  for (let i = 0; i < numPieces; i++) {\n    newPermutation[i] = i;\n    newOrientation[i] = 0;\n  }\n  const orbitTransformation = {\n    permutation: newPermutation,\n    orientationDelta: newOrientation,\n  };\n  if (FREEZE) {\n    Object.freeze(newPermutation); // TODO\n    Object.freeze(newOrientation); // TODO\n    Object.freeze(orbitTransformation); // TODO\n  }\n  identityOrbitCache.set(numPieces, orbitTransformation);\n  return orbitTransformation;\n}\n\nexport function constructIdentityTransformationDataUncached(\n  definition: KPuzzleDefinition,\n): KTransformationData {\n  const transformation = {} as KTransformationData;\n  for (const orbitDefinition of definition.orbits) {\n    transformation[orbitDefinition.orbitName] =\n      constructIdentityOrbitTransformation(orbitDefinition.numPieces);\n  }\n  if (FREEZE) {\n    Object.freeze(transformation); // TODO\n  }\n  return transformation;\n}\n\nexport function moveToTransformationUncached(\n  kpuzzle: KPuzzle,\n  move: Move,\n): KTransformationData {\n  function getTransformationData(\n    key: {\n      toString: () => string;\n    },\n    multiplyAmount: number,\n  ): KTransformationData | undefined {\n    const s = key.toString();\n    const movesDef = kpuzzle.definition.moves[s];\n    if (movesDef) {\n      return repeatTransformationUncached(kpuzzle, movesDef, multiplyAmount);\n    }\n    const derivedDef = kpuzzle.definition.derivedMoves?.[s];\n    if (derivedDef) {\n      return repeatTransformationUncached(\n        kpuzzle,\n        kpuzzle.algToTransformation(derivedDef).transformationData,\n        multiplyAmount,\n      );\n    }\n    return undefined;\n  }\n\n  // TODO: Use Euclid's algorithm to pre-calculate the GCD of moves for each\n  // quantum, along with its transformation. This will make lookup `O(1)` for multiples of e.g. `y2`.\n\n  const data =\n    getTransformationData(move.quantum, move.amount) ??\n    // Handle e.g. `y2` if `y2` is defined.\n    // Note: this doesn't handle multiples.\n    getTransformationData(move, 1) ??\n    // Handle e.g. `y2'` if `y2` is defined.\n    // Note: this doesn't handle multiples.\n    getTransformationData(move.invert, -1);\n\n  if (data) {\n    return data;\n  }\n  throw new Error(`Invalid move for KPuzzle (${kpuzzle.name()}): ${move}`);\n}\n", "import type { Alg, Move } from \"../alg\";\nimport {\n  invertTransformation,\n  isTransformationDataIdentical,\n  repeatTransformationUncached,\n  transformationRepetitionOrder,\n} from \"./calculate\";\nimport { combineTransformationData } from \"./combine\";\nimport { constructIdentityTransformationDataUncached } from \"./construct\";\nimport { KPattern } from \"./KPattern\";\nimport type { KPuzzle, KTransformationSource } from \"./KPuzzle\";\nimport type { KTransformationData } from \"./KPuzzleDefinition\";\n\nexport class KTransformation {\n  constructor(\n    public readonly kpuzzle: KPuzzle,\n    public readonly transformationData: KTransformationData,\n  ) {}\n\n  toJSON(): any {\n    return {\n      experimentalPuzzleName: this.kpuzzle.name(),\n      transformationData: this.transformationData,\n    };\n  }\n\n  invert(): KTransformation {\n    return new KTransformation(\n      this.kpuzzle,\n      invertTransformation(this.kpuzzle, this.transformationData),\n    );\n  }\n\n  // For optimizations, we want to make it cheap to rely on optimizations when a\n  // transformation is an identity. Here, we try to make it cheaper by:\n  // - only calculating when needed, and\n  // - caching the result.\n  #cachedIsIdentity: boolean | undefined; // TODO: is `null` worse here?\n  isIdentityTransformation(): boolean {\n    return (this.#cachedIsIdentity ??= this.isIdentical(\n      this.kpuzzle.identityTransformation(),\n    ));\n  }\n\n  /** @deprecated */\n  static experimentalConstructIdentity(kpuzzle: KPuzzle) {\n    const transformation = new KTransformation(\n      kpuzzle,\n      constructIdentityTransformationDataUncached(kpuzzle.definition),\n    );\n    transformation.#cachedIsIdentity = true;\n    return transformation;\n  }\n\n  isIdentical(t2: KTransformation): boolean {\n    return isTransformationDataIdentical(\n      this.kpuzzle,\n      this.transformationData,\n      t2.transformationData,\n    );\n  }\n\n  // Convenience function\n  /** @deprecated */\n  apply(source: KTransformationSource): KTransformation {\n    return this.applyTransformation(this.kpuzzle.toTransformation(source));\n  }\n\n  applyTransformation(t2: KTransformation): KTransformation {\n    if (this.kpuzzle !== t2.kpuzzle) {\n      throw new Error(\n        `Tried to apply a transformation for a KPuzzle (${t2.kpuzzle.name()}) to a different KPuzzle (${this.kpuzzle.name()}).`,\n      );\n    }\n\n    if (this.#cachedIsIdentity) {\n      return new KTransformation(this.kpuzzle, t2.transformationData);\n    }\n    if (t2.#cachedIsIdentity) {\n      return new KTransformation(this.kpuzzle, this.transformationData);\n    }\n\n    return new KTransformation(\n      this.kpuzzle,\n      combineTransformationData(\n        this.kpuzzle.definition,\n        this.transformationData,\n        t2.transformationData,\n      ),\n    );\n  }\n\n  applyMove(move: Move | string): KTransformation {\n    return this.applyTransformation(this.kpuzzle.moveToTransformation(move));\n  }\n\n  applyAlg(alg: Alg | string): KTransformation {\n    return this.applyTransformation(this.kpuzzle.algToTransformation(alg));\n  }\n\n  // Convenience. Useful for chaining.\n  toKPattern(): KPattern {\n    return KPattern.fromTransformation(this);\n  }\n\n  // TODO: support calculating this for a given start state. (For `R U R' U` on 3x3x3, should this default to 5 or 10?)\n  repetitionOrder(): number {\n    return transformationRepetitionOrder(this.kpuzzle.definition, this);\n  }\n\n  selfMultiply(amount: number): KTransformation {\n    return new KTransformation(\n      this.kpuzzle,\n      repeatTransformationUncached(\n        this.kpuzzle,\n        this.transformationData,\n        amount,\n      ),\n    );\n  }\n}\n", "import {\n  type Alg,\n  type Commutator,\n  type Conjugate,\n  functionFromTraversal,\n  type Grouping,\n  type LineComment,\n  type Move,\n  type Newline,\n  type Pause,\n  TraversalDownUp,\n} from \"../alg\";\nimport { combineTransformationData } from \"./combine\";\nimport type { KPuzzle } from \"./KPuzzle\";\nimport type {\n  KPatternData,\n  KPatternOrbitData,\n  KPuzzleDefinition,\n  KPuzzleOrbitDefinition,\n  KTransformationData,\n  KTransformationOrbitData,\n} from \"./KPuzzleDefinition\";\nimport { KTransformation } from \"./KTransformation\";\n\nexport function isOrbitTransformationDataIdentityUncached(\n  numOrientations: number,\n  orbitTransformationData: KTransformationOrbitData,\n): boolean {\n  // TODO\n  // if (o === lasto) {\n  //   return true;\n  // }\n  if (!orbitTransformationData.permutation) {\n    console.log(orbitTransformationData);\n  }\n  const { permutation } = orbitTransformationData;\n  const numPieces = permutation.length;\n  for (let idx = 0; idx < numPieces; idx++) {\n    if (permutation[idx] !== idx) {\n      return false;\n    }\n  }\n  if (numOrientations > 1) {\n    const { orientationDelta: orientation } = orbitTransformationData;\n    for (let idx = 0; idx < numPieces; idx++) {\n      if (orientation[idx] !== 0) {\n        return false;\n      }\n    }\n  }\n  // lasto = o; // TODO\n  return true;\n}\n\nexport function isOrbitTransformationDataIdentical(\n  orbitDefinition: KPuzzleOrbitDefinition,\n  orbitTransformationData1: KTransformationOrbitData,\n  orbitTransformationData2: KTransformationOrbitData,\n  options: {\n    ignorePieceOrientations?: boolean;\n    ignorePiecePermutation?: boolean;\n  } = {},\n): boolean {\n  for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n    if (\n      !options?.ignorePieceOrientations &&\n      orbitTransformationData1.orientationDelta[idx] !==\n        orbitTransformationData2.orientationDelta[idx]\n    ) {\n      return false;\n    }\n    if (\n      !options?.ignorePiecePermutation &&\n      orbitTransformationData1.permutation[idx] !==\n        orbitTransformationData2.permutation[idx]\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isTransformationDataIdentical(\n  kpuzzle: KPuzzle,\n  transformationData1: KTransformationData,\n  transformationData2: KTransformationData,\n): boolean {\n  for (const orbitDefinition of kpuzzle.definition.orbits) {\n    if (\n      !isOrbitTransformationDataIdentical(\n        orbitDefinition,\n        transformationData1[orbitDefinition.orbitName],\n        transformationData2[orbitDefinition.orbitName],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nfunction isOrbitPatternDataIdentical(\n  orbitDefinition: KPuzzleOrbitDefinition,\n  orbitPatternData1: KPatternOrbitData,\n  orbitPatternData2: KPatternOrbitData,\n  options: {\n    ignorePieceOrientations?: boolean;\n    ignorePieceIndices?: boolean;\n  } = {},\n): boolean {\n  for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n    if (\n      !options?.ignorePieceOrientations &&\n      (orbitPatternData1.orientation[idx] !==\n        orbitPatternData2.orientation[idx] ||\n        (orbitPatternData1.orientationMod?.[idx] ?? 0) !==\n          (orbitPatternData2.orientationMod?.[idx] ?? 0))\n    ) {\n      return false;\n    }\n    if (\n      !options?.ignorePieceIndices &&\n      orbitPatternData1.pieces[idx] !== orbitPatternData2.pieces[idx]\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function isPatternDataIdentical(\n  kpuzzle: KPuzzle,\n  patternData1: KPatternData,\n  patternData2: KPatternData,\n): boolean {\n  for (const orbitDefinition of kpuzzle.definition.orbits) {\n    if (\n      !isOrbitPatternDataIdentical(\n        orbitDefinition,\n        patternData1[orbitDefinition.orbitName],\n        patternData2[orbitDefinition.orbitName],\n      )\n    ) {\n      return false;\n    }\n  }\n  return true;\n}\n\nexport function invertTransformation(\n  kpuzzle: KPuzzle,\n  transformationData: KTransformationData,\n): KTransformationData {\n  const newTransformationData: KTransformationData = {};\n  for (const orbitDefinition of kpuzzle.definition.orbits) {\n    const orbitTransformationData =\n      transformationData[orbitDefinition.orbitName];\n    if (\n      isOrbitTransformationDataIdentityUncached(\n        orbitDefinition.numOrientations,\n        orbitTransformationData,\n      )\n    ) {\n      newTransformationData[orbitDefinition.orbitName] =\n        orbitTransformationData;\n    } else if (orbitDefinition.numOrientations === 1) {\n      const newPerm = new Array(orbitDefinition.numPieces);\n      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n        newPerm[orbitTransformationData.permutation[idx]] = idx;\n      }\n      newTransformationData[orbitDefinition.orbitName] = {\n        permutation: newPerm,\n        orientationDelta: orbitTransformationData.orientationDelta,\n      };\n    } else {\n      const newPerm = new Array(orbitDefinition.numPieces);\n      const newOri = new Array(orbitDefinition.numPieces);\n      for (let idx = 0; idx < orbitDefinition.numPieces; idx++) {\n        const fromIdx = orbitTransformationData.permutation[idx];\n        newPerm[fromIdx] = idx;\n        newOri[fromIdx] =\n          (orbitDefinition.numOrientations -\n            orbitTransformationData.orientationDelta[idx] +\n            orbitDefinition.numOrientations) %\n          orbitDefinition.numOrientations;\n      }\n      newTransformationData[orbitDefinition.orbitName] = {\n        permutation: newPerm,\n        orientationDelta: newOri,\n      };\n    }\n  }\n  return newTransformationData;\n}\n\nexport function repeatTransformationUncached(\n  kpuzzle: KPuzzle,\n  transformationData: KTransformationData,\n  amount: number,\n): KTransformationData {\n  // This is used for move construction, so we optimize for the quantum move case.\n  if (amount === 1) {\n    return transformationData;\n  }\n  if (amount < 0) {\n    return repeatTransformationUncached(\n      kpuzzle,\n      invertTransformation(kpuzzle, transformationData),\n      -amount,\n    );\n  }\n  if (amount === 0) {\n    // TODO\n    const { transformationData } = kpuzzle.identityTransformation();\n    return transformationData;\n  }\n  let halfish = transformationData;\n  if (amount !== 2) {\n    halfish = repeatTransformationUncached(\n      kpuzzle,\n      transformationData,\n      Math.floor(amount / 2),\n    );\n  }\n  const twiceHalfish = combineTransformationData(\n    kpuzzle.definition,\n    halfish,\n    halfish,\n  );\n  if (amount % 2 === 0) {\n    return twiceHalfish;\n  } else {\n    return combineTransformationData(\n      kpuzzle.definition,\n      transformationData,\n      twiceHalfish,\n    );\n  }\n}\n\nclass AlgToTransformationTraversal extends TraversalDownUp<\n  KPuzzle,\n  KTransformation\n> {\n  traverseAlg(alg: Alg, kpuzzle: KPuzzle): KTransformation {\n    let transformation: KTransformation | null = null;\n    for (const algNode of alg.childAlgNodes()) {\n      if (transformation) {\n        transformation = transformation.applyTransformation(\n          this.traverseAlgNode(algNode, kpuzzle),\n        );\n      } else {\n        transformation = this.traverseAlgNode(algNode, kpuzzle);\n      }\n    }\n    return transformation ?? kpuzzle.identityTransformation();\n  }\n  traverseGrouping(grouping: Grouping, kpuzzle: KPuzzle): KTransformation {\n    const algTransformation = this.traverseAlg(grouping.alg, kpuzzle);\n    return new KTransformation(\n      kpuzzle,\n      repeatTransformationUncached(\n        kpuzzle,\n        algTransformation.transformationData,\n        grouping.amount,\n      ),\n    );\n  }\n  traverseMove(move: Move, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.moveToTransformation(move);\n  }\n  traverseCommutator(\n    commutator: Commutator,\n    kpuzzle: KPuzzle,\n  ): KTransformation {\n    const aTransformation = this.traverseAlg(commutator.A, kpuzzle);\n    const bTransformation = this.traverseAlg(commutator.B, kpuzzle);\n    return aTransformation\n      .applyTransformation(bTransformation)\n      .applyTransformation(aTransformation.invert())\n      .applyTransformation(bTransformation.invert());\n  }\n  traverseConjugate(conjugate: Conjugate, kpuzzle: KPuzzle): KTransformation {\n    const aTransformation = this.traverseAlg(conjugate.A, kpuzzle);\n    const bTransformation = this.traverseAlg(conjugate.B, kpuzzle);\n    return aTransformation\n      .applyTransformation(bTransformation)\n      .applyTransformation(aTransformation.invert());\n  }\n  traversePause(_: Pause, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.identityTransformation();\n  }\n  traverseNewline(_: Newline, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.identityTransformation();\n  }\n  traverseLineComment(_: LineComment, kpuzzle: KPuzzle): KTransformation {\n    return kpuzzle.identityTransformation();\n  }\n}\n\nexport const algToTransformation = functionFromTraversal(\n  AlgToTransformationTraversal,\n);\n\n// export function canConvertDefaultPatternToUniqueTransformationUncached(\n//   definition: KPuzzleDefinition,\n// ): boolean {\n//   for (const orbitDefinition of definition.orbits) {\n//     const pieces = new Array(orbitDefinition.numPieces).fill(false);\n//     for (const piece of definition.defaultPattern[orbitDefinition.orbitName]\n//       .pieces) {\n//       pieces[piece] = true;\n//     }\n//     for (const piece of pieces) {\n//       if (!piece) {\n//         return false;\n//       }\n//     }\n//   }\n//   return true;\n// }\n\nfunction gcd(a: number, b: number): number {\n  if (b) {\n    return gcd(b, a % b);\n  }\n  return a;\n}\n\n/* calculate the order of a particular transformation. */\nexport function transformationRepetitionOrder(\n  definition: KPuzzleDefinition,\n  transformation: KTransformation,\n): number {\n  let order: number = 1;\n  for (const orbitDefinition of definition.orbits) {\n    const transformationOrbit =\n      transformation.transformationData[orbitDefinition.orbitName];\n    const orbitPieces = new Array(orbitDefinition.numPieces);\n    for (let startIdx = 0; startIdx < orbitDefinition.numPieces; startIdx++) {\n      if (!orbitPieces[startIdx]) {\n        let currentIdx = startIdx;\n        let orientationSum = 0;\n        let cycleLength = 0;\n        for (;;) {\n          orbitPieces[currentIdx] = true;\n          orientationSum =\n            orientationSum + transformationOrbit.orientationDelta[currentIdx];\n          cycleLength = cycleLength + 1;\n          currentIdx = transformationOrbit.permutation[currentIdx];\n          if (currentIdx === startIdx) {\n            break;\n          }\n        }\n        if (orientationSum !== 0) {\n          cycleLength =\n            (cycleLength * orbitDefinition.numOrientations) /\n            gcd(orbitDefinition.numOrientations, Math.abs(orientationSum));\n        }\n        order = (order * cycleLength) / gcd(order, cycleLength);\n      }\n    }\n  }\n  return order;\n}\n", "import type { Alg, Move } from \"../alg\";\nimport { isPatternDataIdentical } from \"./calculate\";\nimport { applyTransformationDataToKPatternData } from \"./combine\";\nimport type { KPuzzle, KTransformationSource } from \"./KPuzzle\";\nimport type {\n  KPatternData,\n  KTransformationData,\n  KTransformationOrbitData,\n} from \"./KPuzzleDefinition\";\nimport { KTransformation } from \"./KTransformation\";\n\nexport class KPattern {\n  constructor(\n    public readonly kpuzzle: KPuzzle,\n    public readonly patternData: KPatternData,\n  ) {}\n\n  toJSON(): any {\n    return {\n      experimentalPuzzleName: this.kpuzzle.name(),\n      patternData: this.patternData,\n    };\n  }\n\n  static fromTransformation(transformation: KTransformation): KPattern {\n    const newPatternData = applyTransformationDataToKPatternData(\n      transformation.kpuzzle.definition,\n      transformation.kpuzzle.definition.defaultPattern,\n      transformation.transformationData,\n    );\n    return new KPattern(transformation.kpuzzle, newPatternData);\n  }\n\n  // Convenience function\n  /** @deprecated */\n  apply(source: KTransformationSource): KPattern {\n    return this.applyTransformation(this.kpuzzle.toTransformation(source));\n  }\n\n  applyTransformation(transformation: KTransformation): KPattern {\n    if (transformation.isIdentityTransformation()) {\n      return new KPattern(this.kpuzzle, this.patternData);\n    }\n    const newPatternData = applyTransformationDataToKPatternData(\n      this.kpuzzle.definition,\n      this.patternData,\n      transformation.transformationData,\n    );\n    return new KPattern(this.kpuzzle, newPatternData);\n  }\n\n  applyMove(move: Move | string): KPattern {\n    return this.applyTransformation(this.kpuzzle.moveToTransformation(move));\n  }\n\n  applyAlg(alg: Alg | string): KPattern {\n    return this.applyTransformation(this.kpuzzle.algToTransformation(alg));\n  }\n\n  isIdentical(other: KPattern): boolean {\n    return isPatternDataIdentical(\n      this.kpuzzle,\n      this.patternData,\n      other.patternData,\n    );\n  }\n\n  /** @deprecated */\n  experimentalToTransformation(): KTransformation | null {\n    if (!this.kpuzzle.canConvertDefaultPatternToUniqueTransformation()) {\n      return null;\n    }\n    const transformationData: KTransformationData = {};\n    for (const [orbitName, patternOrbitData] of Object.entries(\n      this.patternData,\n    )) {\n      const transformationOrbit: KTransformationOrbitData = {\n        permutation: patternOrbitData.pieces,\n        orientationDelta: patternOrbitData.orientation,\n      };\n      transformationData[orbitName] = transformationOrbit;\n    }\n    return new KTransformation(this.kpuzzle, transformationData);\n  }\n\n  experimentalIsSolved(options: {\n    ignorePuzzleOrientation: boolean;\n    // Note: `ignoreCenterOrientation` must currently be specified even if the puzzle does not have centers with indistinguishable orientations (in which case the value will be ignored).\n    ignoreCenterOrientation: boolean;\n  }): boolean {\n    if (!this.kpuzzle.definition.experimentalIsPatternSolved) {\n      throw new Error(\n        \"`KPattern.experimentalIsPatternSolved()` is not supported for this puzzle at the moment.\",\n      );\n    }\n    return this.kpuzzle.definition.experimentalIsPatternSolved(this, options);\n  }\n}\n", "import { Alg, Move } from \"../alg\";\nimport type { PGNotation } from \"../puzzle-geometry/PuzzleGeometry\";\nimport { algToTransformation } from \"./calculate\";\nimport { moveToTransformationUncached } from \"./construct\";\nimport { KPattern } from \"./KPattern\";\nimport type {\n  KPuzzleDefinition,\n  KPuzzleOrbitDefinition,\n  KTransformationData,\n} from \"./KPuzzleDefinition\";\nimport { KTransformation } from \"./KTransformation\";\n\nexport type KTransformationSource = Alg | Move | string | KTransformation;\n\nexport class KPuzzle {\n  private experimentalPGNotation: PGNotation | undefined;\n  constructor(\n    public readonly definition: KPuzzleDefinition,\n    options?: {\n      experimentalPGNotation?: PGNotation;\n    },\n  ) {\n    this.experimentalPGNotation = options?.experimentalPGNotation;\n  }\n\n  #indexedOrbits: Record<string, KPuzzleOrbitDefinition> | undefined;\n  // Note: this function is needed much more rarely than you might think. Most\n  // operations related to orbits require iterating through all of them, for\n  // which the following is better:\n  //\n  //    for (const orbitDefinition of kpuzzle.definition.orbits) { // \u2026\n  //    }\n  lookupOrbitDefinition(orbitName: string): KPuzzleOrbitDefinition {\n    this.#indexedOrbits ||= (() => {\n      const indexedOrbits: Record<string, KPuzzleOrbitDefinition> = {};\n      for (const orbitDefinition of this.definition.orbits) {\n        indexedOrbits[orbitDefinition.orbitName] = orbitDefinition;\n      }\n      return indexedOrbits;\n    })();\n    return this.#indexedOrbits[orbitName];\n  }\n\n  name(): string {\n    return this.definition.name; // TODO\n  }\n\n  identityTransformation(): KTransformation {\n    return KTransformation.experimentalConstructIdentity(this);\n  }\n\n  #moveToTransformationDataCache = new Map<string, KTransformationData>();\n  moveToTransformation(move: Move | string): KTransformation {\n    if (typeof move === \"string\") {\n      move = new Move(move);\n    }\n    const cacheKey = move.toString();\n    const cachedTransformationData: KTransformationData | undefined =\n      this.#moveToTransformationDataCache.get(cacheKey);\n    if (cachedTransformationData) {\n      return new KTransformation(this, cachedTransformationData);\n    }\n\n    if (this.experimentalPGNotation) {\n      const transformationData = this.experimentalPGNotation.lookupMove(move);\n      if (!transformationData) {\n        throw new Error(`could not map to internal move: ${move}`);\n      }\n      this.#moveToTransformationDataCache.set(cacheKey, transformationData);\n      return new KTransformation(this, transformationData);\n    }\n\n    const transformationData = moveToTransformationUncached(this, move);\n    this.#moveToTransformationDataCache.set(cacheKey, transformationData);\n    return new KTransformation(this, transformationData);\n  }\n\n  algToTransformation(alg: Alg | string): KTransformation {\n    if (typeof alg === \"string\") {\n      alg = new Alg(alg);\n    }\n    return algToTransformation(alg, this);\n  }\n\n  /** @deprecated */\n  toTransformation(source: KTransformationSource): KTransformation {\n    if (typeof source === \"string\") {\n      return this.algToTransformation(source);\n    } else if ((source as Alg | null)?.is?.(Alg)) {\n      return this.algToTransformation(source as Alg);\n    } else if ((source as Move | null)?.is?.(Move)) {\n      return this.moveToTransformation(source as Move);\n    } else {\n      return source as KTransformation;\n    }\n  }\n\n  defaultPattern(): KPattern {\n    return new KPattern(this, this.definition.defaultPattern);\n  }\n\n  #cachedCanConvertDefaultPatternToUniqueTransformation: boolean | undefined;\n  // TODO: Handle incomplete default pattern data\n  canConvertDefaultPatternToUniqueTransformation(): boolean {\n    return (this.#cachedCanConvertDefaultPatternToUniqueTransformation ??=\n      ((): boolean => {\n        for (const orbitDefinition of this.definition.orbits) {\n          const pieces = new Array(orbitDefinition.numPieces).fill(false);\n          for (const piece of this.definition.defaultPattern[\n            orbitDefinition.orbitName\n          ].pieces) {\n            pieces[piece] = true;\n          }\n          for (const piece of pieces) {\n            if (!piece) {\n              return false;\n            }\n          }\n        }\n        return true;\n      })());\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["transformationData", "transformationData"]
+}

package/dist/lib/cubing/chunks/{chunk-XPH22PGR.js → chunk-CGV5LY7H.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-RDSQRW3G.js";
 import {
   Alg
-} from "./chunk-2SBMIHZV.js";
+} from "./chunk-SWKNZGJF.js";
 
 // src/cubing/search/inside/solve/puzzles/clock.ts
 import { randomUIntBelow } from "random-uint-below";
@@ -361,4 +361,4 @@ export {
   solveTwsearch,
   setSearchDebug
 };
-//# sourceMappingURL=chunk-XPH22PGR.js.map
+//# sourceMappingURL=chunk-CGV5LY7H.js.map

package/dist/lib/cubing/chunks/chunk-CGV5LY7H.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cubing/search/inside/solve/puzzles/clock.ts", "../../../../src/cubing/vendor/apache/comlink-everywhere/outside/index.ts", "../../../../src/cubing/search/worker-workarounds/index.ts", "../../../../src/cubing/search/instantiator.ts", "../../../../src/cubing/search/outside.ts"],
+  "sourcesContent": ["import { randomUIntBelow } from \"random-uint-below\";\n\nconst backMoves = [\"U\", \"R\", \"D\", \"L\", \"ALL\"];\nconst frontMoves = [\"UR\", \"DR\", \"DL\", \"UL\"].concat(backMoves);\n\nexport function randomClockScrambleString(): string {\n  let filteringMoveCount = 0;\n\n  function randomSuffix() {\n    const amount = randomUIntBelow(12);\n    if (amount !== 0) {\n      filteringMoveCount++;\n    }\n    if (amount <= 6) {\n      return `${amount}+`;\n    } else {\n      return `${12 - amount}-`;\n    }\n  }\n\n  const moves = [];\n  function side(families: string[]): void {\n    for (const family of families) {\n      moves.push(`${family}${randomSuffix()}`);\n    }\n  }\n\n  side(frontMoves);\n  moves.push(\"y2\");\n  side(backMoves);\n\n  // https://www.worldcubeassociation.org/regulations/#4b3\n  if (filteringMoveCount < 2) {\n    return randomClockScrambleString();\n  }\n\n  return moves.join(\" \");\n}\n", "import nodeEndpoint from \"../node-adapter\";\n\nexport { wrap } from \"comlink\";\n\nconst useNodeWorkarounds =\n  typeof globalThis.Worker === \"undefined\" &&\n  typeof (globalThis as any).WorkerNavigator === \"undefined\";\n\nasync function nodeWorker(\n  source: string | URL,\n  options?: { eval?: boolean },\n): Promise<Worker> {\n  const { Worker: NodeWorker } = globalThis.process.getBuiltinModule(\n    \"node:worker_threads\",\n  );\n  const worker = new NodeWorker(source, options);\n  worker.unref();\n  return nodeEndpoint(worker);\n}\n\nexport async function constructWorker(\n  source: string | URL,\n  options?: { type?: WorkerType },\n): Promise<Worker> {\n  let worker: Worker;\n  if (useNodeWorkarounds) {\n    return nodeWorker(source);\n  } else {\n    worker = new globalThis.Worker(source, {\n      type: options ? options.type : undefined, // TODO: Is it safe to use `options?.type`?\n    });\n  }\n  return worker;\n}\n", "import { exposeAPI } from \"./worker-guard\";\n\nexport async function searchWorkerURLImportMetaResolve(): Promise<string> {\n  // Note:\n  // - We have to hardcode the expected path of the entry file in the ESM build, due to lack of `esbuild` support: https://github.com/evanw/esbuild/issues/2866\n  //   - This URL is based on the assumption that the code from this file ends up in a shared chunk in the `esm` build. This is not guaranteed by `esbuild`, but it consistently happens for our codebase.\n  // - We inline the value (instead of using a constant), to maximize compatibility for hardcoded syntax detection in bundlers.\n  // - `import.meta.resolve(\u2026)` returns a sync result in every environment except `bun`: https://loadeverything.net/#compatibility-dashboard\n  //   - We assume that it's `async`, just in case.\n  // @ts-ignore\n  return import.meta.resolve(\"./search-worker-entry.js\");\n}\n\nexport function searchWorkerURLNewURLImportMetaURL(): URL {\n  // Note:\n  // - We have to hardcode the expected path of the entry file in the ESM build, due to lack of `esbuild` support: https://github.com/evanw/esbuild/issues/795\n  //   - This URL is based on the assumption that the code from this file ends up in a shared chunk in the `esm` build. This is not guaranteed by `esbuild`, but it consistently happens for our codebase.\n  // - We inline the value (instead of using a constant), to maximize compatibility for hardcoded syntax detection in bundlers.\n  return new URL(\"./search-worker-entry.js\", import.meta.url);\n}\n\n// Workaround for `esbuild`: https://github.com/evanw/esbuild/issues/312#issuecomment-1092195778\nexport async function searchWorkerURLEsbuildWorkaround(): Promise<string> {\n  exposeAPI.expose = false;\n  return (await import(\"./search-worker-entry.js\")).WORKER_ENTRY_FILE_URL;\n}\n\nexport function instantiateSearchWorkerURLNewURLImportMetaURL(): Worker {\n  return new Worker(new URL(\"./search-worker-entry.js\", import.meta.url), {\n    type: \"module\",\n  });\n}\n", "import {\n  constructWorker,\n  wrap,\n} from \"../vendor/apache/comlink-everywhere/outside\";\nimport type { WorkerInsideAPI } from \"./inside/api\";\nimport { searchOutsideDebugGlobals } from \"./outside\";\nimport {\n  instantiateSearchWorkerURLNewURLImportMetaURL,\n  searchWorkerURLEsbuildWorkaround,\n  searchWorkerURLImportMetaResolve,\n  searchWorkerURLNewURLImportMetaURL,\n} from \"./worker-workarounds\";\n\nexport interface WorkerOutsideAPI {\n  terminate: () => void; // `node` can return a `Promise` with an exit code, but we match the web worker API.\n}\nexport interface InsideOutsideAPI {\n  insideAPI: WorkerInsideAPI;\n  outsideAPI: WorkerOutsideAPI;\n}\n\nfunction probablyCrossOrigin(workerEntryFileURL: URL): boolean {\n  try {\n    const scriptOrigin = globalThis.location?.origin;\n    const workerOrigin = workerEntryFileURL.origin;\n    return !!scriptOrigin && !!workerOrigin && scriptOrigin !== workerOrigin;\n  } catch {\n    return false;\n  }\n}\n\nasync function instantiateModuleWorker(\n  workerEntryFileURL: string | URL,\n): Promise<InsideOutsideAPI> {\n  // We need the `import.meta.url` base for `bun`.\n  const url = new URL(workerEntryFileURL, import.meta.url);\n  const tryTrampolineFirst = probablyCrossOrigin(url);\n  try {\n    return instantiateModuleWorkerAttempt(url, tryTrampolineFirst);\n  } catch {\n    return instantiateModuleWorkerAttempt(url, !tryTrampolineFirst);\n  }\n}\n\ninterface BunWorker extends Worker {\n  unref?: () => void;\n}\n\nasync function instantiateModuleWorkerAttempt(\n  workerEntryFileURL: URL,\n  crossOriginTrampoline: boolean,\n): Promise<InsideOutsideAPI> {\n  // biome-ignore lint/suspicious/noAsyncPromiseExecutor: TODO\n  return new Promise<InsideOutsideAPI>(async (resolve, reject) => {\n    try {\n      if (!workerEntryFileURL) {\n        reject(new Error(\"Could not get worker entry file URL.\"));\n      }\n      let url: URL = workerEntryFileURL;\n      if (crossOriginTrampoline) {\n        // Standard browser-like environment.\n        const importSrc = `import ${JSON.stringify(\n          workerEntryFileURL.toString(),\n        )};`;\n        const blob = new Blob([importSrc], {\n          type: \"text/javascript\",\n        });\n        url = new URL(URL.createObjectURL(blob));\n      }\n\n      const worker = (await constructWorker(url, {\n        type: \"module\",\n      })) as Worker & {\n        nodeWorker?: import(\"worker_threads\").Worker;\n      } & BunWorker;\n\n      worker.unref?.(); // Unref in `bun`.\n\n      const onError = (e: ErrorEvent) => {\n        reject(e);\n      };\n\n      // TODO: Remove this once we can remove the workarounds for lack of `import.meta.resolve(\u2026)` support.\n      const onFirstMessage = (messageData: string) => {\n        if (messageData === \"comlink-exposed\") {\n          // We need to clear the timeout so that we don't prevent `node` from exiting in the meantime.\n          resolve(wrapWithTerminate(worker));\n        } else {\n          reject(\n            new Error(`wrong module instantiation message ${messageData}`),\n          );\n        }\n      };\n\n      if (worker.nodeWorker) {\n        // We have to use `once` so the `unref()` from `comlink-everywhere` allows the process to quit as expected.\n        worker.nodeWorker.once(\"message\", onFirstMessage);\n      } else {\n        worker.addEventListener(\"error\", onError, {\n          once: true,\n        });\n        worker.addEventListener(\"message\", (e) => onFirstMessage(e.data), {\n          once: true,\n        });\n      }\n    } catch (e) {\n      reject(e);\n    }\n  });\n}\n\n// Maybe some day if we work really hard, this code path can work:\n// - in `node` (https://github.com/nodejs/node/issues/43583#issuecomment-1540025755)\n// - for CDNs (https://github.com/tc39/proposal-module-expressions or https://github.com/whatwg/html/issues/6911)\nexport async function instantiateModuleWorkerDirectlyForBrowser(): Promise<InsideOutsideAPI> {\n  // biome-ignore lint/suspicious/noAsyncPromiseExecutor: TODO\n  return new Promise<InsideOutsideAPI>(async (resolve, reject) => {\n    try {\n      const worker = instantiateSearchWorkerURLNewURLImportMetaURL();\n\n      const onError = (e: ErrorEvent) => {\n        reject(e);\n      };\n\n      // TODO: Remove this once we can remove the workarounds for lack of `import.meta.resolve(\u2026)` support.\n      const onFirstMessage = (messageData: string) => {\n        if (messageData === \"comlink-exposed\") {\n          // We need to clear the timeout so that we don't prevent `node` from exiting in the meantime.\n          resolve(wrapWithTerminate(worker));\n        } else {\n          reject(\n            new Error(`wrong module instantiation message ${messageData}`),\n          );\n        }\n      };\n\n      worker.addEventListener(\"error\", onError, {\n        once: true,\n      });\n      worker.addEventListener(\"message\", (e) => onFirstMessage(e.data), {\n        once: true,\n      });\n    } catch (e) {\n      reject(e);\n    }\n  });\n}\n\nfunction wrapWithTerminate(worker: Worker): InsideOutsideAPI {\n  const insideAPI = wrap<WorkerInsideAPI>(worker);\n  const terminate = worker.terminate.bind(worker);\n  return { insideAPI, outsideAPI: { terminate } };\n}\n\nexport const allInsideOutsideAPIPromises: Promise<InsideOutsideAPI>[] = [];\n\nexport async function instantiateWorker(): Promise<InsideOutsideAPI> {\n  const insideOutsideAPIPromise = instantiateWorkerImplementation();\n  allInsideOutsideAPIPromises.push(insideOutsideAPIPromise);\n  const { insideAPI } = await insideOutsideAPIPromise;\n  insideAPI.setDebugMeasurePerf(searchOutsideDebugGlobals.logPerf);\n  insideAPI.setScramblePrefetchLevel(\n    searchOutsideDebugGlobals.scramblePrefetchLevel,\n  );\n  return insideOutsideAPIPromise;\n}\n\nexport async function mapToAllWorkers(\n  f: (worker: InsideOutsideAPI) => void,\n): Promise<void> {\n  await Promise.all(\n    allInsideOutsideAPIPromises.map((worker) => worker.then(f)),\n  );\n}\n\nasync function instantiateWorkerImplementation(): Promise<InsideOutsideAPI> {\n  if (globalThis.location?.protocol === \"file:\") {\n    console.warn(\n      \"This current web page is loaded from the local filesystem (a URL that starts with `file://`). In this situation, `cubing.js` may be unable to generate scrambles or perform searches in some browsers. See: https://js.cubing.net/cubing/scramble/#file-server-required\",\n    );\n  }\n\n  function failed(methodDescription?: string) {\n    return `Module worker instantiation${\n      methodDescription ? ` ${methodDescription}` : \"\"\n    } failed`;\n  }\n\n  const fallbackOrder: [\n    fn: () => Promise<InsideOutsideAPI>,\n    description: string,\n    warnOnSuccess: null | string,\n  ][] = [\n    [\n      async () =>\n        instantiateModuleWorker(await searchWorkerURLImportMetaResolve()),\n      \"using `import.meta.resolve(\u2026)\",\n      null,\n    ],\n    // TODO: This fallback should be lower (because it's less portable), but we need to try it earlier to work around https://github.com/parcel-bundler/parcel/issues/9051\n    [\n      instantiateModuleWorkerDirectlyForBrowser,\n      \"using inline `new URL(\u2026, import.meta.url)`\",\n      \"may\",\n    ],\n    [\n      async () => instantiateModuleWorker(searchWorkerURLNewURLImportMetaURL()),\n      \"using `new URL(\u2026, import.meta.url)`\",\n      \"will\",\n    ],\n    [\n      async () =>\n        instantiateModuleWorker(await searchWorkerURLEsbuildWorkaround()),\n      \"using the `esbuild` workaround\",\n      \"will\",\n    ],\n  ];\n\n  for (const [fn, description, warnOnSuccess] of fallbackOrder) {\n    try {\n      const worker = await fn();\n      if (warnOnSuccess) {\n        if (searchOutsideDebugGlobals.showWorkerInstantiationWarnings) {\n          console.warn(\n            `Module worker instantiation required ${description}. \\`cubing.js\\` ${warnOnSuccess} not support this fallback in the future.`,\n          );\n        }\n      }\n      return worker;\n    } catch {\n      if (searchOutsideDebugGlobals.showWorkerInstantiationWarnings) {\n        console.warn(`${failed(description)}, falling back.`);\n      }\n    }\n  }\n\n  throw new Error(`${failed()}. There are no more fallbacks available.`);\n}\n", "import { Alg } from \"../alg\";\nimport type { KPuzzle } from \"../kpuzzle\";\n// import { preInitialize222 } from \"../implementations/2x2x2\";\nimport type { KPattern } from \"../kpuzzle/KPattern\";\nimport type { PrefetchLevel } from \"./inside/api\";\nimport { randomClockScrambleString } from \"./inside/solve/puzzles/clock\"; // TODO: don't reach into `inside` code.\nimport type { TwsearchOptions } from \"./inside/solve/twsearch\";\nimport {\n  type InsideOutsideAPI,\n  instantiateWorker,\n  mapToAllWorkers,\n} from \"./instantiator\";\n\nlet cachedWorkerInstance: Promise<InsideOutsideAPI> | undefined;\nfunction getCachedWorkerInstance(): Promise<InsideOutsideAPI> {\n  return (cachedWorkerInstance ??= instantiateWorker());\n}\n\n// Pre-initialize the scrambler for the given event. (Otherwise, an event is\n// initialized the first time you ask for a scramble for that event.)\n//\n// Some typical numbers for a fast computer:\n// - 3x3x3 initialization: 200ms\n// - Each 3x3x3 scramble: 50ms\n// - 4x4x4 initialization: 2500ms\n// - Each 4x4x4 scramble: 300ms to 800ms\n//\n// It is safe to immediately call for a scramble\n// any time after starting pre-initialization, or to call for them without\n// pre-initializing. Pre-initializing essentially gives the scramble worker a\n// head start in case a scramble doesn't get requested immediately.\n//\n// Note that events cannot be pre-initialized in parallel. Attempting to\n// pre-initialize multiple events will initialize them consecutively. Scrambles\n// for a given event cannot be computed while another event is being initialized.\nexport function _preInitializationHintForEvent(\n  eventID: string,\n  // callback?: () => void\n): void {\n  switch (eventID) {\n    case \"333oh\":\n      _preInitializationHintForEvent(\"333\");\n      return;\n  }\n  (async () => {\n    await (await getCachedWorkerInstance()).insideAPI.initialize(eventID);\n  })();\n}\n\nexport async function randomScrambleForEvent(eventID: string): Promise<Alg> {\n  switch (eventID) {\n    case \"clock\":\n      return Alg.fromString(await randomClockScrambleString());\n  }\n  const prom = _randomScrambleStringForEvent(eventID);\n  const wat = await prom;\n  return Alg.fromString(wat);\n}\n\nexport async function _randomScrambleStringForEvent(\n  eventID: string,\n): Promise<string> {\n  if (searchOutsideDebugGlobals.forceNewWorkerForEveryScramble) {\n  }\n  const worker = searchOutsideDebugGlobals.forceNewWorkerForEveryScramble\n    ? await instantiateWorker()\n    : await getCachedWorkerInstance();\n  return worker.insideAPI.randomScrambleStringForEvent(eventID);\n}\n\nexport async function randomScrambleStringForEvent(\n  eventID: string,\n): Promise<string> {\n  switch (eventID) {\n    case \"clock\":\n      return randomClockScrambleString();\n  }\n  return await _randomScrambleStringForEvent(eventID);\n}\n\nexport async function experimentalSolve3x3x3IgnoringCenters(\n  pattern: KPattern,\n): Promise<Alg> {\n  const cwi = await getCachedWorkerInstance();\n  return Alg.fromString(\n    await cwi.insideAPI.solve333ToString(pattern.patternData),\n  );\n}\n\nexport async function experimentalSolve2x2x2(pattern: KPattern): Promise<Alg> {\n  const cwi = await getCachedWorkerInstance();\n  return Alg.fromString(\n    await cwi.insideAPI.solve222ToString(pattern.patternData),\n  );\n}\n\nexport async function solveSkewb(pattern: KPattern): Promise<Alg> {\n  const cwi = await getCachedWorkerInstance();\n  return Alg.fromString(\n    await cwi.insideAPI.solveSkewbToString(pattern.patternData),\n  );\n}\n\nexport async function solvePyraminx(pattern: KPattern): Promise<Alg> {\n  const cwi = await getCachedWorkerInstance();\n  return Alg.fromString(\n    await cwi.insideAPI.solvePyraminxToString(pattern.patternData),\n  );\n}\n\nexport async function solveMegaminx(pattern: KPattern): Promise<Alg> {\n  const cwi = await getCachedWorkerInstance();\n  return Alg.fromString(\n    await cwi.insideAPI.solveMegaminxToString(pattern.patternData),\n  );\n}\n\nexport interface SolveTwsearchOptions {\n  generatorMoves?: string[];\n  targetPattern?: KPattern;\n  minDepth?: number;\n  maxDepth?: number;\n}\n\nexport async function solveTwsearch(\n  kpuzzle: KPuzzle,\n  pattern: KPattern,\n  options?: SolveTwsearchOptions,\n): Promise<Alg> {\n  const { targetPattern, ...otherOptions } = options ?? {};\n  const apiOptions: TwsearchOptions = otherOptions;\n  if (targetPattern) {\n    apiOptions.targetPattern = targetPattern.patternData;\n  }\n  const { ...def } = kpuzzle.definition;\n  delete def.experimentalIsPatternSolved;\n  // delete def.derivedMoves;\n  const dedicatedWorker = await instantiateWorker();\n  try {\n    return Alg.fromString(\n      await dedicatedWorker.insideAPI.solveTwsearchToString(\n        def,\n        pattern.patternData,\n        apiOptions,\n      ),\n    );\n  } finally {\n    console.log(\"Search ended, terminating dedicated `twsearch` worker.\");\n    // TODO: support re-using the same worker for multiple searches..\n    await dedicatedWorker.outsideAPI.terminate();\n  }\n}\n\ninterface SearchOutsideDebugGlobals {\n  logPerf: boolean;\n  scramblePrefetchLevel: `${PrefetchLevel}`;\n  disableStringWorker: boolean;\n  forceNewWorkerForEveryScramble: boolean;\n  showWorkerInstantiationWarnings: boolean;\n}\nexport const searchOutsideDebugGlobals: SearchOutsideDebugGlobals = {\n  logPerf: true,\n  scramblePrefetchLevel: \"auto\",\n  disableStringWorker: false,\n  forceNewWorkerForEveryScramble: false,\n  showWorkerInstantiationWarnings: true,\n};\n\nexport function setSearchDebug(\n  options: Partial<SearchOutsideDebugGlobals>,\n): void {\n  const { logPerf, scramblePrefetchLevel } = options;\n  if (typeof logPerf !== \"undefined\") {\n    searchOutsideDebugGlobals.logPerf = logPerf;\n    mapToAllWorkers((worker) => worker.insideAPI.setDebugMeasurePerf(logPerf));\n  }\n  if (typeof scramblePrefetchLevel !== \"undefined\") {\n    searchOutsideDebugGlobals.scramblePrefetchLevel = scramblePrefetchLevel;\n    mapToAllWorkers((worker) =>\n      worker.insideAPI.setScramblePrefetchLevel(\n        scramblePrefetchLevel as PrefetchLevel,\n      ),\n    );\n  }\n  if (\"disableStringWorker\" in options) {\n    searchOutsideDebugGlobals.disableStringWorker =\n      !!options.disableStringWorker;\n  }\n  if (\"forceNewWorkerForEveryScramble\" in options) {\n    searchOutsideDebugGlobals.forceNewWorkerForEveryScramble =\n      !!options.forceNewWorkerForEveryScramble;\n  }\n  if (\"showWorkerInstantiationWarnings\" in options) {\n    searchOutsideDebugGlobals.showWorkerInstantiationWarnings =\n      !!options.showWorkerInstantiationWarnings;\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/lib/cubing/chunks/{chunk-KO64SKMG.js → chunk-DWN2US56.js}

@@ -1,17 +1,17 @@
 import {
   puzzles
-} from "./chunk-WOAANT6Y.js";
+} from "./chunk-J6NSY47E.js";
 import {
   from
-} from "./chunk-YQVHA4F6.js";
+} from "./chunk-MITU5GJ5.js";
 import {
   KPattern
-} from "./chunk-TQF5J7MH.js";
+} from "./chunk-3YVVF3KK.js";
 import {
   Alg,
   AlgBuilder,
   Move
-} from "./chunk-2SBMIHZV.js";
+} from "./chunk-SWKNZGJF.js";
 
 // src/cubing/search/inside/solve/puzzles/3x3x3/index.ts
 import { randomChoice as randomChoice2 } from "random-uint-below";
@@ -143,18 +143,18 @@ function toMin2PhasePattern(pattern) {
 // src/cubing/search/inside/solve/puzzles/3x3x3/filter.ts
 function isEquivalentTranformationIgnoringCENTERS(t1, t2) {
   const t1NoCenterOri = new KPattern(t1.kpuzzle, {
-    EDGES: t1.patternData.EDGES,
-    CORNERS: t1.patternData.CORNERS,
+    EDGES: t1.patternData["EDGES"],
+    CORNERS: t1.patternData["CORNERS"],
     CENTERS: {
-      pieces: t1.patternData.CENTERS.pieces,
+      pieces: t1.patternData["CENTERS"].pieces,
       orientation: new Array(6).fill(0)
     }
   }).experimentalToTransformation();
   const t2NoCenterOri = new KPattern(t2.kpuzzle, {
-    EDGES: t2.patternData.EDGES,
-    CORNERS: t2.patternData.CORNERS,
+    EDGES: t2.patternData["EDGES"],
+    CORNERS: t2.patternData["CORNERS"],
     CENTERS: {
-      pieces: t2.patternData.CENTERS.pieces,
+      pieces: t2.patternData["CENTERS"].pieces,
       orientation: new Array(6).fill(0)
     }
   }).experimentalToTransformation();
@@ -602,4 +602,4 @@ export {
   initialize333,
   random333OrientedScramble
 };
-//# sourceMappingURL=chunk-KO64SKMG.js.map
+//# sourceMappingURL=chunk-DWN2US56.js.map

package/dist/lib/cubing/chunks/chunk-DWN2US56.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/cubing/search/inside/solve/puzzles/3x3x3/index.ts", "../../../../src/cubing/search/inside/inside-worker.ts", "../../../../src/cubing/search/inside/solve/addOrientationSuffix.ts", "../../../../src/cubing/search/inside/solve/puzzles/dynamic/3x3x3/index.ts", "../../../../src/cubing/search/inside/solve/puzzles/3x3x3/convert.ts", "../../../../src/cubing/search/inside/solve/puzzles/3x3x3/filter.ts", "../../../../src/cubing/search/inside/solve/puzzles/3x3x3/legacy-sgs.ts"],
+  "sourcesContent": ["import { randomChoice } from \"random-uint-below\";\nimport { Alg } from \"../../../../../alg\";\nimport type { KPattern } from \"../../../../../kpuzzle/KPattern\";\nimport { puzzles } from \"../../../../../puzzles\";\nimport { mustBeInsideWorker } from \"../../../inside-worker\";\nimport { addOrientationSuffix } from \"../../addOrientationSuffix\";\nimport { dynamic3x3x3min2phase } from \"../dynamic/3x3x3\";\nimport { toMin2PhasePattern } from \"./convert\";\nimport { passesFilter } from \"./filter\";\nimport { sgs3x3x3 } from \"./legacy-sgs\";\n\nexport async function random333Pattern(): Promise<KPattern> {\n  const kpuzzle = await puzzles[\"3x3x3\"].kpuzzle();\n  let pattern = kpuzzle.defaultPattern();\n  for (const piece of sgs3x3x3) {\n    pattern = pattern.applyAlg(Alg.fromString(randomChoice(piece)));\n  }\n  if (!passesFilter(kpuzzle, pattern)) {\n    return random333Pattern();\n  }\n  return pattern;\n}\n\nexport async function solve333(s: KPattern): Promise<Alg> {\n  mustBeInsideWorker();\n  return Alg.fromString(\n    (await dynamic3x3x3min2phase).solvePattern(toMin2PhasePattern(s)),\n  );\n}\n\nexport async function random333Scramble(): Promise<Alg> {\n  return solve333(await random333Pattern());\n}\n\nexport async function initialize333(): Promise<void> {\n  (await dynamic3x3x3min2phase).initialize();\n}\n\nconst randomSuffixes = [\n  [null, \"Rw\", \"Rw2\", \"Rw'\", \"Fw\", \"Fw'\"],\n  [null, \"Dw\", \"Dw2\", \"Dw'\"],\n];\n\nexport async function random333OrientedScramble(): Promise<Alg> {\n  return addOrientationSuffix(await random333Scramble(), randomSuffixes);\n}\n", "let isInsideWorker = false;\n\nexport function setIsInsideWorker(inside: boolean) {\n  isInsideWorker = inside;\n}\n\nexport function mustBeInsideWorker(): void {\n  if (!isInsideWorker) {\n    throw new Error(\n      \"Must be called from inside a worker, to avoid impact on page performance. Try importing from the top level of `cubing/solve`?\",\n    );\n  }\n}\n", "import { randomChoice } from \"random-uint-below\";\nimport { type Alg, AlgBuilder, Move } from \"../../../alg\";\n\nexport function addOrientationSuffix(\n  alg: Alg,\n  suffixSpec: (null | string)[][],\n): Alg {\n  const algBuilder = new AlgBuilder();\n  algBuilder.experimentalPushAlg(alg);\n  for (const suffix of suffixSpec) {\n    const choice = randomChoice(suffix);\n    if (choice !== null) {\n      algBuilder.push(Move.fromString(choice));\n    }\n  }\n  return algBuilder.toAlg();\n}\n", "import { from } from \"../../../../../../vendor/mit/p-lazy/p-lazy\";\n\nexport const dynamic3x3x3min2phase = from<\n  typeof import(\"./search-dynamic-solve-3x3x3\")\n>(() => import(\"./search-dynamic-solve-3x3x3\"));\n", "/*\n\nFace order:\n\n U\nLFRB\n D\n\n         | 0| 1| 2|\n         | 3| 4| 5|\n         | 6| 7| 8|\n| 9|10|11|18|19|20|27|28|29|36|37|38|\n|12|13|14|21|22|23|30|31|32|39|40|41|\n|15|16|17|24|25|26|33|34|35|42|43|44|\n         |45|46|47|\n         |48|49|50|\n         |51|52|53|\n*/\n\nimport type { KPattern } from \"../../../../../kpuzzle/KPattern\";\n\nconst reidEdgeOrder = \"UF UR UB UL DF DR DB DL FR FL BR BL\".split(\" \");\nconst reidCornerOrder = \"UFR URB UBL ULF DRF DFL DLB DBR\".split(\" \");\nconst centerOrder = \"U L F R B D\".split(\" \");\n\n// const stickers = [reidEdgeOrder, reidCornerOrder, centerOrder];\n\n// /*\n//                |1 20|0 20|1 10|\n//                |0 30|2 00|0 10|\n//                |1 30|0 00|1 00|\n// |1 22|0 31|1 31|1 32|0 01|1 01|1 02|0 11|1 11|1 12|0 21|1 21|\n// |0111|2 10|0 91|0 90|2 20|0 80|0 81|2 30|0101|0100|2 40|0110|\n// |1 61|0 71|1 52|1 51|0 41|1 42|1 41|0 51|1 72|1 71|0 61|1 62|\n//                |1 50|0 40|1 40|\n//                |0 70|2 50|0 50|\n//                |1 60|0 60|1 70|\n// */\n\nconst map: [number, number, number][] = [\n  [1, 2, 0],\n  [0, 2, 0],\n  [1, 1, 0],\n  [0, 3, 0],\n  [2, 0, 0],\n  [0, 1, 0],\n  [1, 3, 0],\n  [0, 0, 0],\n  [1, 0, 0],\n  [1, 0, 2],\n  [0, 1, 1],\n  [1, 1, 1],\n  [0, 8, 1],\n  [2, 3, 0],\n  [0, 10, 1],\n  [1, 4, 1],\n  [0, 5, 1],\n  [1, 7, 2],\n  [1, 3, 2],\n  [0, 0, 1],\n  [1, 0, 1],\n  [0, 9, 0],\n  [2, 2, 0],\n  [0, 8, 0],\n  [1, 5, 1],\n  [0, 4, 1],\n  [1, 4, 2],\n  [1, 5, 0],\n  [0, 4, 0],\n  [1, 4, 0],\n  [0, 7, 0],\n  [2, 5, 0],\n  [0, 5, 0],\n  [1, 6, 0],\n  [0, 6, 0],\n  [1, 7, 0],\n  [1, 2, 2],\n  [0, 3, 1],\n  [1, 3, 1],\n  [0, 11, 1],\n  [2, 1, 0],\n  [0, 9, 1],\n  [1, 6, 1],\n  [0, 7, 1],\n  [1, 5, 2],\n  [1, 1, 2],\n  [0, 2, 1],\n  [1, 2, 1],\n  [0, 10, 0],\n  [2, 4, 0],\n  [0, 11, 0],\n  [1, 7, 1],\n  [0, 6, 1],\n  [1, 6, 2],\n];\n\nfunction rotateLeft(s: string, i: number): string {\n  return s.slice(i) + s.slice(0, i);\n}\n\nfunction toReid333Struct(pattern: KPattern): string[][] {\n  const output: string[][] = [[], []];\n  for (let i = 0; i < 6; i++) {\n    if (pattern.patternData[\"CENTERS\"].pieces[i] !== i) {\n      throw new Error(\"non-oriented puzzles are not supported\");\n    }\n  }\n  for (let i = 0; i < 12; i++) {\n    output[0].push(\n      rotateLeft(\n        reidEdgeOrder[pattern.patternData[\"EDGES\"].pieces[i]],\n        pattern.patternData[\"EDGES\"].orientation[i],\n      ),\n    );\n  }\n  for (let i = 0; i < 8; i++) {\n    output[1].push(\n      rotateLeft(\n        reidCornerOrder[pattern.patternData[\"CORNERS\"].pieces[i]],\n        pattern.patternData[\"CORNERS\"].orientation[i],\n      ),\n    );\n  }\n  output.push(centerOrder);\n  return output;\n}\n\n// function toReid333String(state: Transformation): string {\n//   return toReid333Struct(state)\n//     .map((l) => l.join(\" \"))\n//     .join(\" \");\n// }\n\nexport function toMin2PhasePattern(pattern: KPattern): string {\n  const reid = toReid333Struct(pattern);\n  return map.map(([orbit, perm, ori]) => reid[orbit][perm][ori]).join(\"\");\n}\n", "import { Move } from \"../../../../../alg\";\nimport type { KPuzzle } from \"../../../../../kpuzzle\";\nimport { KPattern } from \"../../../../../kpuzzle\";\n\nexport function isEquivalentTranformationIgnoringCENTERS(\n  t1: KPattern,\n  t2: KPattern,\n): boolean {\n  const t1NoCenterOri = new KPattern(t1.kpuzzle, {\n    EDGES: t1.patternData[\"EDGES\"],\n    CORNERS: t1.patternData[\"CORNERS\"],\n    CENTERS: {\n      pieces: t1.patternData[\"CENTERS\"].pieces,\n      orientation: new Array(6).fill(0),\n    },\n  }).experimentalToTransformation()!;\n  const t2NoCenterOri = new KPattern(t2.kpuzzle, {\n    EDGES: t2.patternData[\"EDGES\"],\n    CORNERS: t2.patternData[\"CORNERS\"],\n    CENTERS: {\n      pieces: t2.patternData[\"CENTERS\"].pieces,\n      orientation: new Array(6).fill(0),\n    },\n  }).experimentalToTransformation()!;\n  return t1NoCenterOri.isIdentical(t2NoCenterOri);\n}\n\nexport function passesFilter(kpuzzle: KPuzzle, pattern: KPattern): boolean {\n  if (\n    isEquivalentTranformationIgnoringCENTERS(kpuzzle.defaultPattern(), pattern)\n  ) {\n    return false;\n  }\n\n  for (const face of \"ULFRBD\") {\n    for (let amount = 1; amount < 4; amount++) {\n      const transformation = kpuzzle\n        .moveToTransformation(new Move(face, amount))\n        .toKPattern();\n      if (isEquivalentTranformationIgnoringCENTERS(transformation, pattern)) {\n        return false;\n      }\n    }\n  }\n\n  return true;\n}\n// TODO: implement tests\n// {\n//   const def = await puzzles[\"3x3x3\"].def();\n//   const kpuzzle = new KPuzzle(def);\n//   console.log(passesFilter(def, kpuzzle.state));\n//   kpuzzle.applyAlg(parse(\"R\"));\n//   console.log(passesFilter(def, kpuzzle.state));\n//   kpuzzle.applyAlg(parse(\"D\"));\n//   console.log(passesFilter(def, kpuzzle.state));\n//   kpuzzle.reset();\n//   kpuzzle.applyAlg(parse(\"(R' U' R U')5\"));\n//   console.log(passesFilter(def, kpuzzle.state));\n// }\n", "// TODO: Verify\nexport const sgs3x3x3: string[][] = [\n  [\n    \"R U'\",\n    \"R2 B\", //\n    \"D2 B2\",\n    \"D' L B'\", //\n    \"R' U'\",\n    \"B\", //\n    \"D B2\",\n    \"R' B\", //\n    \"L' U\",\n    \"L2 B'\", //\n    \"B2\",\n    \"D L B'\", //\n    \"L U\",\n    \"B'\", //\n    \"U'\",\n    \"R B\", //\n    \"D' B2\",\n    \"L B'\", //\n    \"U2\",\n    \"U L' B'\", //\n    \"\",\n    \"U' L' B'\", //\n    \"U\",\n    \"L' B'\",\n  ],\n  [\n    \"F2 L2\",\n    \"F' L'\",\n    \"R' F L2\", //\n    \"D' L2\",\n    \"F L2\",\n    \"F2 L'\", //\n    \"R' F' L'\",\n    \"R2 F L2\",\n    \"R2 F2 L'\", //\n    \"L2\",\n    \"F L'\",\n    \"D' L\", //\n    \"D2 L2\",\n    \"R2 F' L'\",\n    \"D L\", //\n    \"\",\n    \"L2 F L'\",\n    \"L F' L2\", //\n    \"L F L'\",\n    \"F' L2\",\n    \"L'\", //\n    \"D L2\",\n    \"D F L'\",\n    \"L\",\n  ],\n  [\n    \"R B U2 B'\",\n    \"R2 B U' B'\", //\n    \"F2 B U B'\",\n    \"F B2 L' B2\", //\n    \"B2 L B2\",\n    \"B U' B'\", //\n    \"R2 B U2 B'\",\n    \"R' B U' B'\", //\n    \"B2 L' B2\",\n    \"F B U B'\", //\n    \"B2 U' B2\",\n    \"B' L B\", //\n    \"L F' B D' B'\",\n    \"B' U' B2 D B'\", //\n    \"B U2 B'\",\n    \"R B U' B'\", //\n    \"B2 L2 B2\",\n    \"D' B' L B\", //\n    \"B U B'\",\n    \"F' B2 L' B2\", //\n    \"\",\n    \"B2 L' B' U' B'\",\n  ],\n  [\n    \"U F2 L2 U'\",\n    \"F' U L' U'\", //\n    \"F2 U L' U'\",\n    \"U F L2 U'\", //\n    \"U2 B2 U2\",\n    \"R' U' B U\", //\n    \"D2 U L U'\",\n    \"D U2 B' U2\", //\n    \"U L2 U'\",\n    \"F U L' U'\", //\n    \"D U L U'\",\n    \"U2 B' U2\", //\n    \"\",\n    \"U2 B' U' L' U'\", //\n    \"U2 L' U2\",\n    \"U' B U\", //\n    \"U L U'\",\n    \"D' U2 B' U2\", //\n    \"U L' U'\",\n    \"U2 B U2\",\n  ],\n  [\n    \"R' D' F2\",\n    \"F'\", //\n    \"F2\",\n    \"D R F'\", //\n    \"R D' F2\",\n    \"R2 F'\", //\n    \"D' F2\",\n    \"R F'\", //\n    \"F2 R' D' F2\",\n    \"F\", //\n    \"D2 F2\",\n    \"D' R F'\", //\n    \"R2 D' F2\",\n    \"R' F'\", //\n    \"D F2\",\n    \"D2 R F'\", //\n    \"\",\n    \"F R' D' F2\",\n  ],\n  [\n    \"R' D2 F' D F\",\n    \"R F2 R2 F2\",\n    \"R2 F' D2 F\", //\n    \"F' R2 D2 F\",\n    \"L D' L'\",\n    \"D F' D2 F\", //\n    \"F2 R2 F2\",\n    \"R F' D2 F\",\n    \"F' R2 D' F\", //\n    \"F' R' D2 F\",\n    \"F2 R' F2\",\n    \"L D L'\", //\n    \"F' R D' F\",\n    \"F2 R F2\",\n    \"F' D2 F\", //\n    \"\",\n    \"L D2 R D' L'\",\n    \"F' D2 F' R F2\", //\n    \"D2 R2 F2 R2 F2\",\n    \"D F' D' F\",\n    \"F' D F\",\n  ],\n  [\n    \"U F2 U'\",\n    \"R U F' U'\", //\n    \"D R U F2 U'\",\n    \"U F U'\", //\n    \"R2 U F2 U'\",\n    \"R' U F' U'\", //\n    \"R U F2 U'\",\n    \"R2 U F' U'\", //\n    \"\",\n    \"U L D L' F U'\", //\n    \"F2 D' R D F2\",\n    \"D2 U F U'\", //\n    \"R' U F2 U'\",\n    \"U F' U'\", //\n    \"F2 D2 R D2 F2\",\n    \"D U F U'\",\n  ],\n  [\n    \"R2\",\n    \"R' B' D B\", //\n    \"D R'\",\n    \"F' R2 F\", //\n    \"\",\n    \"R B' D B\", //\n    \"R'\",\n    \"B' D B\", //\n    \"D' R'\",\n    \"D2 F' R2 F\", //\n    \"R\",\n    \"R2 B' D B\", //\n    \"D2 R'\",\n    \"B' D' B\",\n  ],\n  [\n    \"R2 D' R2\",\n    \"F' R' F R\",\n    \"R D' R2 D R'\", //\n    \"D2 R2 D2 R2\",\n    \"R' D' F' R F\",\n    \"U F D F' U'\", //\n    \"\",\n    \"R2 D2 B R' B' R'\",\n    \"R' F D' F2 R F\", //\n    \"R2 D R2\",\n    \"F2 U F U' F\",\n    \"R' D F' R F\", //\n    \"D R2 D2 R2\",\n    \"U F D' F' U'\",\n    \"D R' D2 F' R F\", //\n    \"R2 D2 R2\",\n    \"U F D2 F' U'\",\n    \"R' D2 F' R F\",\n  ],\n  [\n    \"B R B'\",\n    \"F D F' B R2 B'\", //\n    \"D B R2 B'\",\n    \"D2 B R' B'\", //\n    \"B R2 B'\",\n    \"D B R' B'\", //\n    \"D' B R2 B'\",\n    \"B R' B'\", //\n    \"\",\n    \"B R2 B' D B R' B'\", //\n    \"D2 B R2 B'\",\n    \"D' B R' B'\",\n  ],\n  [\n    \"\",\n    \"R' D R F D2 F'\", //\n    \"R' D R\",\n    \"D F D' F'\", //\n    \"R F' R' F\",\n    \"F D' F'\", //\n    \"R' D' R\",\n    \"F D2 F'\", //\n    \"R' D2 R\",\n    \"F D F'\",\n  ],\n  [\n    \"\",\n    \"F2 D2 R F' R' D2 F' D2 F'\",\n    \"F2 D2 F' D' F D' F' D2 F'\", //\n    \"F2 D F2 D F2 D2 F2\",\n    \"D2 F L D2 L' D2 F'\",\n    \"D F D2 L D2 L' F'\", //\n    \"R' D B' D2 B D' R\",\n    \"R' D2 B' D2 B R\",\n    \"F D2 F' D F D F'\", //\n    \"F D' L D2 L' D F'\",\n    \"B D' F D B' D' F'\",\n    \"F D2 L D2 L' F'\", //\n    \"F D' L D L' D F'\",\n    \"F L D2 L' D2 F'\",\n    \"R' B' D2 B D2 R\",\n  ],\n  [\n    \"D'\",\n    \"F L D L' D' F'\", //\n    \"D2\",\n    \"L B D B' D' L'\", //\n    \"D\",\n    \"B' L' D' L D B\", //\n    \"\",\n    \"D F L D L' D' F'\",\n  ],\n  [\n    \"F' D2 F D F' D F\",\n    \"F' D' R' D R F\", //\n    \"F' R' D' R D F\",\n    \"B D R D' R' B'\", //\n    \"\",\n    \"D B' D' L' D L B\",\n  ],\n  [\n    \"D F D F' D F D2 F'\",\n    \"F' U2 B' R' B U2 F' L F' L' F'\", //\n    \"\",\n    \"D2 L D L2 F L F2 D F\",\n  ],\n  [\n    \"L B' L' F L B L' F'\",\n    \"F2 U F' D2 F U' F' D2 F'\",\n    \"D' F' D B D' F D B'\", //\n    \"F L2 F R2 F' L2 F R2 F2\",\n    \"D B D' F' D B' D' F\",\n    \"R F L F' R' F L' F'\", //\n    \"\",\n    \"D2 B L' U2 L B' D2 B L' U2 L B'\",\n    \"D2 F R' U2 R F' D2 F R' U2 R F'\", //\n    \"R F L' F' R' F L F'\",\n    \"D F D' B' D F' D' B\",\n    \"L2 F2 L' B2 L F2 L' B2 L'\",\n  ],\n  [\n    \"L B R' B' L' B R B'\",\n    \"R' B R F' R' B' R F\",\n    \"L D2 L U L' D2 L U' L2\", //\n    \"\",\n    \"D2 B' D2 F D' L2 F L2 F' D2 B D' F'\",\n    \"D2 F' R' F R2 B' D2 B D2 R' F D2 F'\", //\n    \"L B L' F L B' L' F'\",\n    \"F' D2 F' U' F D2 F' U F2\",\n    \"D' B' D F D' B D F'\",\n  ],\n  [\"\", \"D2 F' L U2 L' F D2 F' L U2 L' F\", \"D2 B' R U2 R' B D2 B' R U2 R' B\"],\n];\n"],
+  "mappings": ";;;;;;;;;;;;;;;;AAAA,SAAS,gBAAAA,qBAAoB;;;ACA7B,IAAI,iBAAiB;AAEd,SAAS,kBAAkB,QAAiB;AACjD,mBAAiB;AACnB;AAEO,SAAS,qBAA2B;AACzC,MAAI,CAAC,gBAAgB;AACnB,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AAAA,EACF;AACF;;;ACZA,SAAS,oBAAoB;AAGtB,SAAS,qBACd,KACA,YACK;AACL,QAAM,aAAa,IAAI,WAAW;AAClC,aAAW,oBAAoB,GAAG;AAClC,aAAW,UAAU,YAAY;AAC/B,UAAM,SAAS,aAAa,MAAM;AAClC,QAAI,WAAW,MAAM;AACnB,iBAAW,KAAK,KAAK,WAAW,MAAM,CAAC;AAAA,IACzC;AAAA,EACF;AACA,SAAO,WAAW,MAAM;AAC1B;;;ACdO,IAAM,wBAAwB,KAEnC,MAAM,OAAO,0CAA8B,CAAC;;;ACiB9C,IAAM,gBAAgB,sCAAsC,MAAM,GAAG;AACrE,IAAM,kBAAkB,kCAAkC,MAAM,GAAG;AACnE,IAAM,cAAc,cAAc,MAAM,GAAG;AAgB3C,IAAM,MAAkC;AAAA,EACtC,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,IAAI,CAAC;AAAA,EACT,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,IAAI,CAAC;AAAA,EACT,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,IAAI,CAAC;AAAA,EACT,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,IAAI,CAAC;AAAA,EACT,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AAAA,EACR,CAAC,GAAG,GAAG,CAAC;AACV;AAEA,SAAS,WAAW,GAAW,GAAmB;AAChD,SAAO,EAAE,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,CAAC;AAClC;AAEA,SAAS,gBAAgB,SAA+B;AACtD,QAAM,SAAqB,CAAC,CAAC,GAAG,CAAC,CAAC;AAClC,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,QAAI,QAAQ,YAAY,SAAS,EAAE,OAAO,CAAC,MAAM,GAAG;AAClD,YAAM,IAAI,MAAM,wCAAwC;AAAA,IAC1D;AAAA,EACF;AACA,WAAS,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,WAAO,CAAC,EAAE;AAAA,MACR;AAAA,QACE,cAAc,QAAQ,YAAY,OAAO,EAAE,OAAO,CAAC,CAAC;AAAA,QACpD,QAAQ,YAAY,OAAO,EAAE,YAAY,CAAC;AAAA,MAC5C;AAAA,IACF;AAAA,EACF;AACA,WAAS,IAAI,GAAG,IAAI,GAAG,KAAK;AAC1B,WAAO,CAAC,EAAE;AAAA,MACR;AAAA,QACE,gBAAgB,QAAQ,YAAY,SAAS,EAAE,OAAO,CAAC,CAAC;AAAA,QACxD,QAAQ,YAAY,SAAS,EAAE,YAAY,CAAC;AAAA,MAC9C;AAAA,IACF;AAAA,EACF;AACA,SAAO,KAAK,WAAW;AACvB,SAAO;AACT;AAQO,SAAS,mBAAmB,SAA2B;AAC5D,QAAM,OAAO,gBAAgB,OAAO;AACpC,SAAO,IAAI,IAAI,CAAC,CAAC,OAAO,MAAM,GAAG,MAAM,KAAK,KAAK,EAAE,IAAI,EAAE,GAAG,CAAC,EAAE,KAAK,EAAE;AACxE;;;ACpIO,SAAS,yCACd,IACA,IACS;AACT,QAAM,gBAAgB,IAAI,SAAS,GAAG,SAAS;AAAA,IAC7C,OAAO,GAAG,YAAY,OAAO;AAAA,IAC7B,SAAS,GAAG,YAAY,SAAS;AAAA,IACjC,SAAS;AAAA,MACP,QAAQ,GAAG,YAAY,SAAS,EAAE;AAAA,MAClC,aAAa,IAAI,MAAM,CAAC,EAAE,KAAK,CAAC;AAAA,IAClC;AAAA,EACF,CAAC,EAAE,6BAA6B;AAChC,QAAM,gBAAgB,IAAI,SAAS,GAAG,SAAS;AAAA,IAC7C,OAAO,GAAG,YAAY,OAAO;AAAA,IAC7B,SAAS,GAAG,YAAY,SAAS;AAAA,IACjC,SAAS;AAAA,MACP,QAAQ,GAAG,YAAY,SAAS,EAAE;AAAA,MAClC,aAAa,IAAI,MAAM,CAAC,EAAE,KAAK,CAAC;AAAA,IAClC;AAAA,EACF,CAAC,EAAE,6BAA6B;AAChC,SAAO,cAAc,YAAY,aAAa;AAChD;AAEO,SAAS,aAAa,SAAkB,SAA4B;AACzE,MACE,yCAAyC,QAAQ,eAAe,GAAG,OAAO,GAC1E;AACA,WAAO;AAAA,EACT;AAEA,aAAW,QAAQ,UAAU;AAC3B,aAAS,SAAS,GAAG,SAAS,GAAG,UAAU;AACzC,YAAM,iBAAiB,QACpB,qBAAqB,IAAI,KAAK,MAAM,MAAM,CAAC,EAC3C,WAAW;AACd,UAAI,yCAAyC,gBAAgB,OAAO,GAAG;AACrE,eAAO;AAAA,MACT;AAAA,IACF;AAAA,EACF;AAEA,SAAO;AACT;;;AC7CO,IAAM,WAAuB;AAAA,EAClC;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA;AAAA,IACE;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AAAA,EACA,CAAC,IAAI,mCAAmC,iCAAiC;AAC3E;;;ANvRA,eAAsB,mBAAsC;AAC1D,QAAM,UAAU,MAAM,QAAQ,OAAO,EAAE,QAAQ;AAC/C,MAAI,UAAU,QAAQ,eAAe;AACrC,aAAW,SAAS,UAAU;AAC5B,cAAU,QAAQ,SAAS,IAAI,WAAWC,cAAa,KAAK,CAAC,CAAC;AAAA,EAChE;AACA,MAAI,CAAC,aAAa,SAAS,OAAO,GAAG;AACnC,WAAO,iBAAiB;AAAA,EAC1B;AACA,SAAO;AACT;AAEA,eAAsB,SAAS,GAA2B;AACxD,qBAAmB;AACnB,SAAO,IAAI;AAAA,KACR,MAAM,uBAAuB,aAAa,mBAAmB,CAAC,CAAC;AAAA,EAClE;AACF;AAEA,eAAsB,oBAAkC;AACtD,SAAO,SAAS,MAAM,iBAAiB,CAAC;AAC1C;AAEA,eAAsB,gBAA+B;AACnD,GAAC,MAAM,uBAAuB,WAAW;AAC3C;AAEA,IAAM,iBAAiB;AAAA,EACrB,CAAC,MAAM,MAAM,OAAO,OAAO,MAAM,KAAK;AAAA,EACtC,CAAC,MAAM,MAAM,OAAO,KAAK;AAC3B;AAEA,eAAsB,4BAA0C;AAC9D,SAAO,qBAAqB,MAAM,kBAAkB,GAAG,cAAc;AACvE;",
+  "names": ["randomChoice", "randomChoice"]
+}

package/dist/lib/cubing/chunks/{chunk-MA47PABE.js → chunk-EVYENG3X.js}

@@ -1,10 +1,43 @@
 import {
   cube3x3x3KPuzzleDefinition
-} from "./chunk-YQVHA4F6.js";
+} from "./chunk-MITU5GJ5.js";
 import {
   TraversalUp,
   functionFromTraversal
-} from "./chunk-2SBMIHZV.js";
+} from "./chunk-SWKNZGJF.js";
+
+// src/cubing/notation/CountAnimatedLeaves.ts
+var CountAnimatedLeaves = class extends TraversalUp {
+  traverseAlg(alg) {
+    let total = 0;
+    for (const part of alg.childAlgNodes()) {
+      total += this.traverseAlgNode(part);
+    }
+    return total;
+  }
+  traverseGrouping(grouping) {
+    return this.traverseAlg(grouping.alg) * Math.abs(grouping.amount);
+  }
+  traverseMove(_move) {
+    return 1;
+  }
+  traverseCommutator(commutator) {
+    return 2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B));
+  }
+  traverseConjugate(conjugate) {
+    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);
+  }
+  traversePause(_pause) {
+    return 1;
+  }
+  traverseNewline(_newline) {
+    return 0;
+  }
+  traverseLineComment(_comment) {
+    return 0;
+  }
+};
+var countAnimatedLeaves = functionFromTraversal(CountAnimatedLeaves);
 
 // src/cubing/notation/commonMetrics.ts
 var CommonMetric = /* @__PURE__ */ ((CommonMetric2) => {
@@ -145,7 +178,7 @@ var CountLeavesInExpansionForSimultaneousMoveIndexer = class extends TraversalUp
     const alg = grouping.alg;
     return this.traverseAlg(alg) * Math.abs(grouping.amount);
   }
-  traverseMove(move) {
+  traverseMove(_move) {
     return 1;
   }
   traverseCommutator(commutator) {
@@ -199,9 +232,7 @@ var countRangeBlockQuantumMovesPG = functionFromTraversal(CountMoves, [
 var countRangeBlockMovesPG = functionFromTraversal(CountMoves, [
   rangeBlockTurnMetric
 ]);
-var countLeavesInExpansionForSimultaneousMoveIndexer = functionFromTraversal(CountLeavesInExpansionForSimultaneousMoveIndexer, [
-  baseMetric
-]);
+var countLeavesInExpansionForSimultaneousMoveIndexer = functionFromTraversal(CountLeavesInExpansionForSimultaneousMoveIndexer, []);
 function countMetricMoves(puzzleLoader, metric, alg) {
   if (puzzleLoader.id === "3x3x3") {
     if (metric in costFactorsByMetric) {
@@ -230,46 +261,13 @@ function countMetricMoves(puzzleLoader, metric, alg) {
   throw new Error("Unsupported puzzle or metric.");
 }
 
-// src/cubing/notation/CountAnimatedLeaves.ts
-var CountAnimatedLeaves = class extends TraversalUp {
-  traverseAlg(alg) {
-    let total = 0;
-    for (const part of alg.childAlgNodes()) {
-      total += this.traverseAlgNode(part);
-    }
-    return total;
-  }
-  traverseGrouping(grouping) {
-    return this.traverseAlg(grouping.alg) * Math.abs(grouping.amount);
-  }
-  traverseMove(_move) {
-    return 1;
-  }
-  traverseCommutator(commutator) {
-    return 2 * (this.traverseAlg(commutator.A) + this.traverseAlg(commutator.B));
-  }
-  traverseConjugate(conjugate) {
-    return 2 * this.traverseAlg(conjugate.A) + this.traverseAlg(conjugate.B);
-  }
-  traversePause(_pause) {
-    return 1;
-  }
-  traverseNewline(_newline) {
-    return 0;
-  }
-  traverseLineComment(_comment) {
-    return 0;
-  }
-};
-var countAnimatedLeaves = functionFromTraversal(CountAnimatedLeaves);
-
 export {
+  countAnimatedLeaves,
   CommonMetric,
   CommonMetricAlias,
   countMoves,
   countMovesETM,
   countLeavesInExpansionForSimultaneousMoveIndexer,
-  countMetricMoves,
-  countAnimatedLeaves
+  countMetricMoves
 };
-//# sourceMappingURL=chunk-MA47PABE.js.map
+//# sourceMappingURL=chunk-EVYENG3X.js.map