cubing 0.57.4 → 0.58.1

package/dist/lib/cubing/chunks/{chunk-666TWRT6.js → chunk-Z4CZPP2W.js}

@@ -1,11 +1,17 @@
 import {
   KPattern,
   KPuzzle
-} from "./chunk-3YVVF3KK.js";
+} from "./chunk-CZGLT7LF.js";
 import {
   Alg,
-  Move
-} from "./chunk-SWKNZGJF.js";
+  Commutator,
+  Conjugate,
+  Move,
+  Pause,
+  QuantumMove,
+  TraversalDownUp,
+  functionFromTraversal
+} from "./chunk-3MMNI5O2.js";
 
 // src/cubing/vendor/mit/p-lazy/p-lazy.ts
 var PLazy = class _PLazy extends Promise {
@@ -851,6 +857,7 @@ var CubePGPuzzleLoader = class extends PGPuzzleLoader {
     return cubeLikeStickeringMask(this, stickering);
   }
   stickerings = () => cubeLikeStickeringList(this.id, { use3x3x3Fallbacks: true });
+  algTransformData = cubeMirrorTransforms;
 };
 function puzzleSpecificSimplifyOptionsPromise(kpuzzlePromiseFn) {
   return new PLazy(
@@ -1164,6 +1171,67 @@ var cube3x3x3KPuzzleDefinition = {
   }
 };
 
+// src/cubing/puzzles/implementations/dynamic/3x3x3/puzzle-orientation.ts
+function puzzleOrientation3x3x3Idx(pattern) {
+  const idxU = pattern.patternData["CENTERS"].pieces[0];
+  const idxD = pattern.patternData["CENTERS"].pieces[5];
+  const unadjustedIdxL = pattern.patternData["CENTERS"].pieces[1];
+  let idxL = unadjustedIdxL;
+  if (idxU < unadjustedIdxL) {
+    idxL--;
+  }
+  if (idxD < unadjustedIdxL) {
+    idxL--;
+  }
+  return [idxU, idxL];
+}
+var puzzleOrientationCacheRaw = new Array(6).fill(0).map(() => {
+  return new Array(6);
+});
+var puzzleOrientationCacheInitialized = false;
+function puzzleOrientation3x3x3Cache() {
+  if (!puzzleOrientationCacheInitialized) {
+    {
+      const uAlgs = ["", "z", "x", "z'", "x'", "x2"].map(
+        (s) => Alg.fromString(s)
+      );
+      const yAlg = new Alg("y");
+      for (const uAlg of uAlgs) {
+        let transformation = experimental3x3x3KPuzzle.algToTransformation(uAlg);
+        for (let i = 0; i < 4; i++) {
+          transformation = transformation.applyAlg(yAlg);
+          const [idxU, idxL] = puzzleOrientation3x3x3Idx(
+            transformation.toKPattern()
+          );
+          puzzleOrientationCacheRaw[idxU][idxL] = transformation.invert();
+        }
+      }
+    }
+  }
+  return puzzleOrientationCacheRaw;
+}
+function normalize3x3x3Orientation(pattern) {
+  const [idxU, idxL] = puzzleOrientation3x3x3Idx(pattern);
+  const orientationTransformation = puzzleOrientation3x3x3Cache()[idxU][idxL];
+  return pattern.applyTransformation(orientationTransformation);
+}
+function experimentalIs3x3x3Solved(pattern, options) {
+  if (options.ignorePuzzleOrientation) {
+    pattern = normalize3x3x3Orientation(pattern);
+  }
+  if (options.ignoreCenterOrientation) {
+    pattern = new KPattern(pattern.kpuzzle, {
+      EDGES: pattern.patternData["EDGES"],
+      CORNERS: pattern.patternData["CORNERS"],
+      CENTERS: {
+        pieces: pattern.patternData["CENTERS"].pieces,
+        orientation: new Array(6).fill(0)
+      }
+    });
+  }
+  return !!pattern.experimentalToTransformation()?.isIdentityTransformation();
+}
+
 // src/cubing/puzzles/PuzzleLoader.ts
 async function getPartialAppendOptionsForPuzzleSpecificSimplifyOptions(puzzleLoader) {
   const puzzleSpecificSimplifyOptions = await (puzzleLoader.puzzleSpecificSimplifyOptions ?? puzzleLoader.puzzleSpecificSimplifyOptionsPromise);
@@ -1173,6 +1241,57 @@ async function getPartialAppendOptionsForPuzzleSpecificSimplifyOptions(puzzleLoa
   return { puzzleLoader: { puzzleSpecificSimplifyOptions } };
 }
 
+// src/cubing/puzzles/transformAlg.ts
+var TransformAlg = class extends TraversalDownUp {
+  traverseAlg(alg, dataDown) {
+    const algNodes = [];
+    for (const algNode of alg.childAlgNodes()) {
+      algNodes.push(this.traverseAlgNode(algNode, dataDown));
+    }
+    return new Alg(algNodes);
+  }
+  traverseGrouping(grouping, dataDown) {
+    return grouping.modified({ alg: this.traverseAlg(grouping.alg, dataDown) });
+  }
+  traverseMove(move, dataDown) {
+    const invert = (() => {
+      const { invertExceptByFamily } = dataDown;
+      if (!invertExceptByFamily) {
+        return false;
+      }
+      return !invertExceptByFamily.has(move.family);
+    })();
+    return move.modified({
+      amount: invert ? -move.amount : move.amount,
+      family: dataDown.replaceMovesByFamily[move.family] ?? move.family
+    });
+  }
+  traverseCommutator(commutator, dataDown) {
+    return new Commutator(
+      this.traverseAlg(commutator.A, dataDown),
+      this.traverseAlg(commutator.B, dataDown)
+    );
+  }
+  traverseConjugate(conjugate, dataDown) {
+    return new Conjugate(
+      this.traverseAlg(conjugate.A, dataDown),
+      this.traverseAlg(conjugate.B, dataDown)
+    );
+  }
+  // TODO: Remove spaces between repeated pauses (in traverseSequence)
+  traversePause(pause, _dataDown) {
+    return pause;
+  }
+  traverseNewline(newLine, _dataDown) {
+    return newLine;
+  }
+  // TODO: Enforce being followed by a newline (or the end of the alg)?
+  traverseLineComment(comment, _dataDown) {
+    return comment;
+  }
+};
+var transformAlg = functionFromTraversal(TransformAlg);
+
 // src/cubing/puzzles/customPGPuzzleLoader.ts
 async function descAsyncGetPuzzleGeometry(desc, options) {
   const puzzleGeometry = await import("../puzzle-geometry/index.js");
@@ -1229,10 +1348,10 @@ function puzzleOrientation2x2x2Idx(pattern) {
   const inverseDFL = inverse.transformationData["CORNERS"];
   return inverseDFL.permutation[6] * 3 + inverseDFL.orientationDelta[6];
 }
-var puzzleOrientationCacheRaw = new Array(24);
-var puzzleOrientationCacheInitialized = false;
+var puzzleOrientationCacheRaw2 = new Array(24);
+var puzzleOrientationCacheInitialized2 = false;
 function puzzleOrientation2x2x2Cache(kpuzzle) {
-  if (!puzzleOrientationCacheInitialized) {
+  if (!puzzleOrientationCacheInitialized2) {
     {
       const uAlgs = ["", "z", "x", "z'", "x'", "x2"].map(
         (s) => Alg.fromString(s)
@@ -1243,7 +1362,7 @@ function puzzleOrientation2x2x2Cache(kpuzzle) {
         for (let i = 0; i < 4; i++) {
           transformation = transformation.applyAlg(yAlg);
           const idx = puzzleOrientation2x2x2Idx(transformation.toKPattern());
-          puzzleOrientationCacheRaw[idx] = {
+          puzzleOrientationCacheRaw2[idx] = {
             transformation: transformation.invert(),
             alg: uAlg.concat(yAlg)
           };
@@ -1251,7 +1370,7 @@ function puzzleOrientation2x2x2Cache(kpuzzle) {
       }
     }
   }
-  return puzzleOrientationCacheRaw;
+  return puzzleOrientationCacheRaw2;
 }
 function normalize2x2x2Orientation(pattern) {
   const idx = puzzleOrientation2x2x2Idx(pattern);
@@ -1274,82 +1393,343 @@ var experimental3x3x3KPuzzle = new KPuzzle(
 );
 cube3x3x3KPuzzleDefinition.experimentalIsPatternSolved = experimentalIs3x3x3Solved;
 var bigCubePuzzleOrientation = getCached(
-  () => import("./big-puzzle-orientation-SKZG73EB.js")
+  () => import("./big-puzzle-orientation-CQUVRARW.js")
 );
 
-// src/cubing/puzzles/implementations/dynamic/3x3x3/puzzle-orientation.ts
-function puzzleOrientation3x3x3Idx(pattern) {
-  const idxU = pattern.patternData["CENTERS"].pieces[0];
-  const idxD = pattern.patternData["CENTERS"].pieces[5];
-  const unadjustedIdxL = pattern.patternData["CENTERS"].pieces[1];
-  let idxL = unadjustedIdxL;
-  if (idxU < unadjustedIdxL) {
-    idxL--;
+// src/cubing/puzzles/implementations/3x3x3/cube3x3x3KeyMapping.ts
+var cube3x3x3KeyMapping = {
+  KeyI: new Move("R"),
+  KeyK: new Move("R'"),
+  KeyW: new Move("B"),
+  KeyO: new Move("B'"),
+  KeyS: new Move("D"),
+  KeyL: new Move("D'"),
+  KeyD: new Move("L"),
+  KeyE: new Move("L'"),
+  KeyJ: new Move("U"),
+  KeyF: new Move("U'"),
+  KeyH: new Move("F"),
+  KeyG: new Move("F'"),
+  KeyC: new Move("l"),
+  KeyR: new Move("l'"),
+  KeyU: new Move("r"),
+  KeyM: new Move("r'"),
+  KeyX: new Move("d"),
+  Comma: new Move("d'"),
+  KeyT: new Move("x"),
+  KeyY: new Move("x"),
+  KeyV: new Move("x'"),
+  KeyN: new Move("x'"),
+  Semicolon: new Move("y"),
+  KeyA: new Move("y'"),
+  KeyP: new Move("z"),
+  KeyQ: new Move("z'"),
+  KeyZ: new Move("M'"),
+  KeyB: new Move("M"),
+  Period: new Move("M'"),
+  Backquote: new Pause()
+};
+
+// src/cubing/puzzles/implementations/3x3x3/puzzle-specific-simplifications.ts
+function makeSourceInfo(moveStrings, type, from2, to) {
+  const output = [];
+  for (const moveString of moveStrings) {
+    const move = Move.fromString(moveString);
+    const { family, amount: direction } = move;
+    if (![-1, 1].includes(direction)) {
+      throw new Error("Invalid config move");
+    }
+    output.push({ family, direction, type, from: from2, to });
   }
-  if (idxD < unadjustedIdxL) {
-    idxL--;
+  return output;
+}
+var axisInfos = {
+  ["x axis" /* X */]: {
+    sliceDiameter: 3,
+    extendsThroughEntirePuzzle: true,
+    moveSourceInfos: [
+      ...makeSourceInfo(["R"], 0 /* INDEXABLE_SLICE_NEAR */, 0, 3),
+      ...makeSourceInfo(["L'"], 1 /* INDEXABLE_SLICE_FAR */, 0, 3),
+      ...makeSourceInfo(["r", "Rw"], 2 /* INDEXABLE_WIDE_NEAR */, 0, 2),
+      ...makeSourceInfo(["l'", "Lw'"], 3 /* INDEXABLE_WIDE_FAR */, 0, 2),
+      ...makeSourceInfo(["M'"], 4 /* SPECIFIC_SLICE */, 1, 2),
+      // TODO: remove some indices?
+      ...makeSourceInfo(["x", "Uv", "Dv'"], 5 /* ROTATION */, 0, 3)
+      // TODO: remove some indices?
+    ]
+  },
+  ["y axis" /* Y */]: {
+    sliceDiameter: 3,
+    extendsThroughEntirePuzzle: true,
+    moveSourceInfos: [
+      ...makeSourceInfo(["U"], 0 /* INDEXABLE_SLICE_NEAR */, 0, 3),
+      ...makeSourceInfo(["D'"], 1 /* INDEXABLE_SLICE_FAR */, 0, 3),
+      ...makeSourceInfo(["u", "Uw"], 2 /* INDEXABLE_WIDE_NEAR */, 0, 2),
+      ...makeSourceInfo(["d'", "Dw'"], 3 /* INDEXABLE_WIDE_FAR */, 0, 2),
+      ...makeSourceInfo(["E'"], 4 /* SPECIFIC_SLICE */, 1, 2),
+      // TODO: remove some indices?
+      ...makeSourceInfo(["y", "Uv", "Dv'"], 5 /* ROTATION */, 0, 3)
+      // TODO: remove some indices?
+    ]
+  },
+  ["z axis" /* Z */]: {
+    sliceDiameter: 3,
+    extendsThroughEntirePuzzle: true,
+    moveSourceInfos: [
+      ...makeSourceInfo(["F"], 0 /* INDEXABLE_SLICE_NEAR */, 0, 3),
+      ...makeSourceInfo(["B'"], 1 /* INDEXABLE_SLICE_FAR */, 0, 3),
+      ...makeSourceInfo(["f", "Fw"], 2 /* INDEXABLE_WIDE_NEAR */, 0, 3),
+      ...makeSourceInfo(["b'", "Bw'"], 3 /* INDEXABLE_WIDE_FAR */, 0, 3),
+      ...makeSourceInfo(["S"], 4 /* SPECIFIC_SLICE */, 1, 2),
+      // TODO: remove some indices?
+      ...makeSourceInfo(["z", "Fv", "Bv'"], 5 /* ROTATION */, 0, 3)
+      // TODO: remove some indices?
+    ]
+  }
+};
+var byFamily = {};
+for (const [axis, info] of Object.entries(axisInfos)) {
+  for (const moveSourceInfo of info.moveSourceInfos) {
+    byFamily[moveSourceInfo.family] = { axis, moveSourceInfo };
   }
-  return [idxU, idxL];
 }
-var puzzleOrientationCacheRaw2 = new Array(6).fill(0).map(() => {
-  return new Array(6);
-});
-var puzzleOrientationCacheInitialized2 = false;
-function puzzleOrientation3x3x3Cache() {
-  if (!puzzleOrientationCacheInitialized2) {
-    {
-      const uAlgs = ["", "z", "x", "z'", "x'", "x2"].map(
-        (s) => Alg.fromString(s)
-      );
-      const yAlg = new Alg("y");
-      for (const uAlg of uAlgs) {
-        let transformation = experimental3x3x3KPuzzle.algToTransformation(uAlg);
-        for (let i = 0; i < 4; i++) {
-          transformation = transformation.applyAlg(yAlg);
-          const [idxU, idxL] = puzzleOrientation3x3x3Idx(
-            transformation.toKPattern()
-          );
-          puzzleOrientationCacheRaw2[idxU][idxL] = transformation.invert();
-        }
-      }
+var byAxisThenType = {};
+for (const axis of Object.keys(axisInfos)) {
+  const entry = {};
+  byAxisThenType[axis] = entry;
+  for (const moveSourceInfo of axisInfos[axis].moveSourceInfos) {
+    (entry[moveSourceInfo.type] ??= []).push(moveSourceInfo);
+  }
+}
+var byAxisThenSpecificSlices = {};
+for (const axis of Object.keys(axisInfos)) {
+  const entry = /* @__PURE__ */ new Map();
+  byAxisThenSpecificSlices[axis] = entry;
+  for (const moveSourceInfo of axisInfos[axis].moveSourceInfos) {
+    if (!entry.get(moveSourceInfo.from)) {
+      entry.set(moveSourceInfo.from, moveSourceInfo);
     }
   }
-  return puzzleOrientationCacheRaw2;
 }
-function normalize3x3x3Orientation(pattern) {
-  const [idxU, idxL] = puzzleOrientation3x3x3Idx(pattern);
-  const orientationTransformation = puzzleOrientation3x3x3Cache()[idxU][idxL];
-  return pattern.applyTransformation(orientationTransformation);
+function firstOfType(axis, moveSourceType) {
+  const entry = byAxisThenType[axis][moveSourceType]?.[0];
+  if (!entry) {
+    throw new Error(
+      `Could not find a reference move (axis: ${axis}, move source type: ${moveSourceType})`
+    );
+  }
+  return entry;
 }
-function experimentalIs3x3x3Solved(pattern, options) {
-  if (options.ignorePuzzleOrientation) {
-    pattern = normalize3x3x3Orientation(pattern);
+var areQuantumMovesSameAxis = (quantumMove1, quantumMove2) => {
+  return byFamily[quantumMove1.family].axis === byFamily[quantumMove2.family].axis;
+};
+function simplestMove(axis, from2, to, directedAmount) {
+  if (from2 + 1 === to) {
+    const sliceSpecificInfo = byAxisThenSpecificSlices[axis].get(from2);
+    if (sliceSpecificInfo) {
+      return new Move(
+        new QuantumMove(sliceSpecificInfo.family),
+        directedAmount * sliceSpecificInfo.direction
+      );
+    }
   }
-  if (options.ignoreCenterOrientation) {
-    pattern = new KPattern(pattern.kpuzzle, {
-      EDGES: pattern.patternData["EDGES"],
-      CORNERS: pattern.patternData["CORNERS"],
-      CENTERS: {
-        pieces: pattern.patternData["CENTERS"].pieces,
-        orientation: new Array(6).fill(0)
+  const axisInfo = axisInfos[axis];
+  const { sliceDiameter } = axisInfo;
+  if (from2 === 0 && to === sliceDiameter) {
+    const moveSourceInfo2 = firstOfType(axis, 5 /* ROTATION */);
+    return new Move(
+      new QuantumMove(moveSourceInfo2.family),
+      directedAmount * moveSourceInfo2.direction
+    );
+  }
+  const far = from2 + to > sliceDiameter;
+  if (far) {
+    [from2, to] = [sliceDiameter - to, sliceDiameter - from2];
+  }
+  let outerLayer = from2 + 1;
+  let innerLayer = to;
+  const slice = outerLayer === innerLayer;
+  if (slice) {
+    innerLayer = null;
+  }
+  if (outerLayer === 1) {
+    outerLayer = null;
+  }
+  if (slice && outerLayer === 1) {
+    innerLayer = null;
+  }
+  if (!slice && innerLayer === 2) {
+    innerLayer = null;
+  }
+  const moveSourceType = slice ? far ? 1 /* INDEXABLE_SLICE_FAR */ : 0 /* INDEXABLE_SLICE_NEAR */ : far ? 3 /* INDEXABLE_WIDE_FAR */ : 2 /* INDEXABLE_WIDE_NEAR */;
+  const moveSourceInfo = firstOfType(axis, moveSourceType);
+  return new Move(
+    new QuantumMove(moveSourceInfo.family, innerLayer, outerLayer),
+    directedAmount * moveSourceInfo.direction
+  );
+}
+function simplifySameAxisMoves(moves, quantumMod = true) {
+  if (moves.length === 0) {
+    return [];
+  }
+  const axis = byFamily[moves[0].family].axis;
+  const axisInfo = axisInfos[axis];
+  const { sliceDiameter } = axisInfo;
+  const sliceDeltas = /* @__PURE__ */ new Map();
+  let lastCandidateRange = null;
+  function adjustValue(idx, relativeDelta) {
+    let newDelta = (sliceDeltas.get(idx) ?? 0) + relativeDelta;
+    if (quantumMod) {
+      newDelta = newDelta % 4 + 5 % 4 - 1;
+    }
+    if (newDelta === 0) {
+      sliceDeltas.delete(idx);
+    } else {
+      sliceDeltas.set(idx, newDelta);
+    }
+  }
+  let suffixLength = 0;
+  for (const move of Array.from(moves).reverse()) {
+    suffixLength++;
+    const { moveSourceInfo } = byFamily[move.family];
+    const directedAmount2 = move.amount * moveSourceInfo.direction;
+    switch (moveSourceInfo.type) {
+      case 0 /* INDEXABLE_SLICE_NEAR */: {
+        const idx = (move.innerLayer ?? 1) - 1;
+        adjustValue(idx, directedAmount2);
+        adjustValue(idx + 1, -directedAmount2);
+        break;
       }
-    });
+      case 1 /* INDEXABLE_SLICE_FAR */: {
+        const idx = sliceDiameter - (move.innerLayer ?? 1);
+        adjustValue(idx, directedAmount2);
+        adjustValue(idx + 1, -directedAmount2);
+        break;
+      }
+      case 2 /* INDEXABLE_WIDE_NEAR */: {
+        adjustValue((move.outerLayer ?? 1) - 1, directedAmount2);
+        adjustValue(move.innerLayer ?? 2, -directedAmount2);
+        break;
+      }
+      case 3 /* INDEXABLE_WIDE_FAR */: {
+        adjustValue(sliceDiameter - (move.innerLayer ?? 2), directedAmount2);
+        adjustValue(
+          sliceDiameter - ((move.outerLayer ?? 1) - 1),
+          -directedAmount2
+        );
+        break;
+      }
+      case 4 /* SPECIFIC_SLICE */: {
+        adjustValue(moveSourceInfo.from, directedAmount2);
+        adjustValue(moveSourceInfo.to, -directedAmount2);
+        break;
+      }
+      case 5 /* ROTATION */: {
+        adjustValue(0, directedAmount2);
+        adjustValue(sliceDiameter, -directedAmount2);
+        break;
+      }
+    }
+    if ([0, 2].includes(sliceDeltas.size)) {
+      lastCandidateRange = { suffixLength, sliceDeltas: new Map(sliceDeltas) };
+    }
   }
-  return !!pattern.experimentalToTransformation()?.isIdentityTransformation();
+  if (sliceDeltas.size === 0) {
+    return [];
+  }
+  if (!lastCandidateRange) {
+    return moves;
+  }
+  let [from2, to] = lastCandidateRange.sliceDeltas.keys();
+  if (from2 > to) {
+    [from2, to] = [to, from2];
+  }
+  const directedAmount = lastCandidateRange.sliceDeltas.get(from2);
+  return [
+    ...moves.slice(0, -lastCandidateRange.suffixLength),
+    ...directedAmount !== 0 ? [simplestMove(axis, from2, to, directedAmount)] : []
+  ];
 }
+var puzzleSpecificSimplifyOptions333 = {
+  quantumMoveOrder: () => 4,
+  // doQuantumMovesCommute: areQuantumMovesSameAxis,
+  axis: { areQuantumMovesSameAxis, simplifySameAxisMoves }
+};
+
+// src/cubing/puzzles/implementations/3x3x3/index.ts
+var cubeMirrorTransforms = {
+  "\u2194 Mirror (M)": {
+    replaceMovesByFamily: {
+      L: "R",
+      R: "L",
+      l: "r",
+      r: "l",
+      Lw: "Rw",
+      Rw: "Lw",
+      Lv: "Rv",
+      Rv: "Lv"
+    },
+    invertExceptByFamily: /* @__PURE__ */ new Set(["x", "M", "m"])
+  },
+  "\u2922 Mirror (S)": {
+    replaceMovesByFamily: {
+      F: "B",
+      B: "F",
+      f: "b",
+      b: "f",
+      Fw: "Bw",
+      Bw: "Fw",
+      Fv: "Bv",
+      Bv: "Fv"
+    },
+    invertExceptByFamily: /* @__PURE__ */ new Set(["z", "S", "s"])
+  },
+  "\u2195 Mirror (E)": {
+    replaceMovesByFamily: {
+      U: "D",
+      D: "U",
+      u: "d",
+      d: "u",
+      Uw: "Dw",
+      Dw: "Uw",
+      Uv: "Dv",
+      Dv: "Uv"
+    },
+    invertExceptByFamily: /* @__PURE__ */ new Set(["y", "E", "e"])
+  }
+};
+var cube3x3x3 = {
+  id: "3x3x3",
+  fullName: "3\xD73\xD73 Cube",
+  inventedBy: ["Ern\u0151 Rubik"],
+  inventionYear: 1974,
+  // https://en.wikipedia.org/wiki/Rubik%27s_Cube#Conception_and_development
+  kpuzzle: getCached(async () => {
+    return experimental3x3x3KPuzzle;
+  }),
+  svg: getCached(async () => {
+    return (await import("./puzzles-dynamic-3x3x3-JWIWLLZA.js")).cube3x3x3SVG;
+  }),
+  llSVG: getCached(async () => {
+    return (await import("./puzzles-dynamic-3x3x3-JWIWLLZA.js")).cube3x3x3LLSVG;
+  }),
+  llFaceSVG: getCached(async () => {
+    return (await import("./puzzles-dynamic-3x3x3-JWIWLLZA.js")).cube3x3x3LLFaceSVG;
+  }),
+  pg: getCached(async () => {
+    return asyncGetPuzzleGeometry("3x3x3");
+  }),
+  stickeringMask: (stickering) => cubeLikeStickeringMask(cube3x3x3, stickering),
+  stickerings: () => cubeLikeStickeringList("3x3x3"),
+  puzzleSpecificSimplifyOptions: puzzleSpecificSimplifyOptions333,
+  keyMapping: async () => cube3x3x3KeyMapping,
+  // TODO: async loading
+  algTransformData: cubeMirrorTransforms
+};
 
 export {
   from,
-  getFaceletStickeringMask,
-  getPieceStickeringMask,
-  PuzzleStickering,
-  StickeringManager,
-  cubeLikeStickeringMask,
-  cubeLikeStickeringList,
   getCached,
-  asyncGetPuzzleGeometry,
-  PGPuzzleLoader,
-  CubePGPuzzleLoader,
   cube3x3x3KPuzzleDefinition,
   puzzleOrientation3x3x3Idx,
   puzzleOrientation3x3x3Cache,
@@ -1359,7 +1739,19 @@ export {
   asyncGetKPuzzleByDesc,
   customPGPuzzleLoader,
   experimentalIs2x2x2Solved,
+  getFaceletStickeringMask,
+  getPieceStickeringMask,
+  PuzzleStickering,
+  StickeringManager,
   experimental3x3x3KPuzzle,
-  bigCubePuzzleOrientation
+  bigCubePuzzleOrientation,
+  cubeLikeStickeringMask,
+  cubeLikeStickeringList,
+  cube3x3x3KeyMapping,
+  cubeMirrorTransforms,
+  cube3x3x3,
+  asyncGetPuzzleGeometry,
+  PGPuzzleLoader,
+  CubePGPuzzleLoader
 };
-//# sourceMappingURL=chunk-666TWRT6.js.map
+//# sourceMappingURL=chunk-Z4CZPP2W.js.map