cube-state-engine 1.2.0 → 1.4.0

package/dist/index.d.ts

@@ -1,54 +1,43 @@
 class CubeEngine {
   MOVES = [];
+  size = 3;
+
+  constructor(initialScramble = "", options = { size: 3 }) {
+    const allowedSizes = [2, 3];
+    this.size = allowedSizes.includes(options.size) ? options.size : 3;
+
+    this.#initializeState();
 
-  constructor(initialScramble = "") {
     // If an initial scramble string is provided, apply it without recording moves
     if (typeof initialScramble === "string" && initialScramble.trim().length > 0) {
       this.#applyMovesFromString(initialScramble, false);
-      // Ensure history is empty for initial position
       this.MOVES = [];
     }
   }
 
-  // States object for the rotation
-  STATES = {
-    UPPER: [
-      // (White)
-      [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
-      [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
-      [COLOR.W[6], COLOR.W[7], COLOR.W[8]],
-    ],
-    LEFT: [
-      // (Orange)
-      [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
-      [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
-      [COLOR.O[6], COLOR.O[7], COLOR.O[8]],
-    ],
-    FRONT: [
-      // (Green)
-      [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
-      [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
-      [COLOR.G[6], COLOR.G[7], COLOR.G[8]],
-    ],
-    RIGHT: [
-      // (Red)
-      [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
-      [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
-      [COLOR.R[6], COLOR.R[7], COLOR.R[8]],
-    ],
-    BACK: [
-      // (Blue)
-      [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
-      [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
-      [COLOR.B[6], COLOR.B[7], COLOR.B[8]],
-    ],
-    DOWN: [
-      // (Yellow)
-      [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
-      [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
-      [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]],
-    ],
-  };
+  #initializeState() {
+    this.STATES = {
+      UPPER: this.#createFace("W"),
+      LEFT: this.#createFace("O"),
+      FRONT: this.#createFace("G"),
+      RIGHT: this.#createFace("R"),
+      BACK: this.#createFace("B"),
+      DOWN: this.#createFace("Y"),
+    };
+  }
+
+  // Create a face matrix based on cube size
+  #createFace(color) {
+    const face = [];
+    for (let i = 0; i < this.size; i++) {
+      const row = [];
+      for (let j = 0; j < this.size; j++) {
+        row.push(color);
+      }
+      face.push(row);
+    }
+    return face;
+  }
 
   /**
    * Rotates the (UPPER) layer clockwise or counterclockwise.
@@ -116,6 +105,33 @@ class CubeEngine {
     }
   }
 
+  /**
+   * Rotates the (BACK) layer clockwise or counterclockwise.
+   */
+  rotateB(clockwise = true) {
+    if (clockwise) {
+      this.#rotateB(true);
+      this.MOVES.push("B");
+    } else {
+      this.#rotateB(false);
+      this.MOVES.push("B'");
+    }
+  }
+
+  #rotateB(clockwise = true) {
+    // Implement B as y2 F y2
+    // Clockwise/counterclockwise direction is preserved through y2 conjugation
+    this.#rotateY(true);
+    this.#rotateY(true);
+    if (clockwise) {
+      this.#rotateF(true);
+    } else {
+      this.#rotateF(false);
+    }
+    this.#rotateY(false);
+    this.#rotateY(false);
+  }
+
   /**
    * Rotates the (RIGHT) layer clockwise or counterclockwise.
    */
@@ -203,6 +219,7 @@ class CubeEngine {
    * Rotates the wide (DOWN two layers) clockwise or counterclockwise.
    */
   rotateDw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       this.#rotateDw(true);
       this.MOVES.push("Dw");
@@ -226,6 +243,7 @@ class CubeEngine {
    * Rotates the wide (UPPER two layers) clockwise or counterclockwise.
    */
   rotateUw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       this.#rotateUw(true);
       this.MOVES.push("Uw");
@@ -249,6 +267,7 @@ class CubeEngine {
    * Rotates the wide (RIGHT two layers) clockwise or counterclockwise.
    */
   rotateRw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       this.#rotateRw(true);
       this.MOVES.push("Rw");
@@ -272,6 +291,7 @@ class CubeEngine {
    * Rotates the wide (LEFT two layers) clockwise or counterclockwise.
    */
   rotateLw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       this.#rotateLw(true);
       this.MOVES.push("Lw");
@@ -296,6 +316,7 @@ class CubeEngine {
    * Rotates the middle slice (M) parallel to L/R. Clockwise corresponds to Lw followed by L'.
    */
   rotateM(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       this.#rotateM(true);
       this.MOVES.push("M");
@@ -447,21 +468,42 @@ class CubeEngine {
    */
   #switchMatrix(matrix, clockwise = true) {
     const clone = structuredClone(matrix);
+    const size = this.size;
 
-    const tempMatrix = [...clone[0], ...clone[1], ...clone[2]];
+    // Flatten the matrix
+    let tempMatrix = [];
+    for (let i = 0; i < size; i++) {
+      tempMatrix = [...tempMatrix, ...clone[i]];
+    }
 
-    if (clockwise) {
-      return [
-        [tempMatrix[6], tempMatrix[3], tempMatrix[0]],
-        [tempMatrix[7], tempMatrix[4], tempMatrix[1]],
-        [tempMatrix[8], tempMatrix[5], tempMatrix[2]],
-      ];
+    if (size === 2) {
+      // For 2x2 cubes
+      if (clockwise) {
+        return [
+          [tempMatrix[2], tempMatrix[0]],
+          [tempMatrix[3], tempMatrix[1]]
+        ];
+      } else {
+        return [
+          [tempMatrix[1], tempMatrix[3]],
+          [tempMatrix[0], tempMatrix[2]]
+        ];
+      }
     } else {
-      return [
-        [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
-        [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
-        [tempMatrix[0], tempMatrix[3], tempMatrix[6]],
-      ];
+      // For 3x3 cubes (original logic)
+      if (clockwise) {
+        return [
+          [tempMatrix[6], tempMatrix[3], tempMatrix[0]],
+          [tempMatrix[7], tempMatrix[4], tempMatrix[1]],
+          [tempMatrix[8], tempMatrix[5], tempMatrix[2]],
+        ];
+      } else {
+        return [
+          [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
+          [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
+          [tempMatrix[0], tempMatrix[3], tempMatrix[6]],
+        ];
+      }
     }
   }
 
@@ -489,13 +531,15 @@ class CubeEngine {
     };
 
     const layersSolved = Object.keys(temp).map((layer) => {
-      const mixedMatrix = [
-        ...temp[layer][0],
-        ...temp[layer][1],
-        ...temp[layer][2],
-      ];
 
-      const centerColor = mixedMatrix[4];
+      let mixedMatrix = [];
+      for (let i = 0; i < this.size; i++) {
+        mixedMatrix = [...mixedMatrix, ...temp[layer][i]];
+      }
+
+      // For a 2x2 cube, there is no center; we use the first color as reference
+      // For a 3x3 cube, we use the color of the center (position 4)
+      const centerColor = this.size === 2 ? mixedMatrix[0] : mixedMatrix[4];
 
       return mixedMatrix.every((currentColor) => currentColor === centerColor);
     });
@@ -517,38 +561,7 @@ class CubeEngine {
    * Resets the cube to the solved state and clears the move history.
    */
   reset() {
-    this.STATES = {
-      UPPER: [
-        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
-        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
-        [COLOR.W[6], COLOR.W[7], COLOR.W[8]],
-      ],
-      LEFT: [
-        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
-        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
-        [COLOR.O[6], COLOR.O[7], COLOR.O[8]],
-      ],
-      FRONT: [
-        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
-        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
-        [COLOR.G[6], COLOR.G[7], COLOR.G[8]],
-      ],
-      RIGHT: [
-        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
-        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
-        [COLOR.R[6], COLOR.R[7], COLOR.R[8]],
-      ],
-      BACK: [
-        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
-        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
-        [COLOR.B[6], COLOR.B[7], COLOR.B[8]],
-      ],
-      DOWN: [
-        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
-        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
-        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]],
-      ],
-    };
+    this.#initializeState();
     this.MOVES = [];
   }
 
@@ -579,7 +592,6 @@ class CubeEngine {
 
       const exec = (fnClockwise, fnCounter) => {
         if (isDouble) {
-          // Double turns ignore prime; do two clockwise quarter-turns
           fnClockwise();
           fnClockwise();
         } else {
@@ -662,6 +674,12 @@ class CubeEngine {
             () => (record ? this.rotateF(false) : this.#rotateF(false))
           );
           break;
+        case 'B':
+          exec(
+            () => (record ? this.rotateB(true) : this.#rotateB(true)),
+            () => (record ? this.rotateB(false) : this.#rotateB(false))
+          );
+          break;
         case 'x':
           exec(
             () => (record ? this.rotateX(true) : this.#rotateX(true)),

package/dist/index.js

@@ -45,50 +45,15 @@ __export(src_exports, {
   CubeEngine: () => CubeEngine
 });
 module.exports = __toCommonJS(src_exports);
-var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
+var _CubeEngine_instances, initializeState_fn, createFace_fn, rotateU_fn, rotateF_fn, rotateB_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateDw_fn, rotateUw_fn, rotateRw_fn, rotateLw_fn, rotateM_fn, rotateX_fn, rotateZ_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn, applyMovesFromString_fn;
 var CubeEngine = class {
-  constructor(initialScramble = "") {
+  constructor(initialScramble = "", options = { size: 3 }) {
     __privateAdd(this, _CubeEngine_instances);
     __publicField(this, "MOVES", []);
-    // States object for the rotation
-    __publicField(this, "STATES", {
-      UPPER: [
-        // (White)
-        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
-        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
-        [COLOR.W[6], COLOR.W[7], COLOR.W[8]]
-      ],
-      LEFT: [
-        // (Orange)
-        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
-        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
-        [COLOR.O[6], COLOR.O[7], COLOR.O[8]]
-      ],
-      FRONT: [
-        // (Green)
-        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
-        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
-        [COLOR.G[6], COLOR.G[7], COLOR.G[8]]
-      ],
-      RIGHT: [
-        // (Red)
-        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
-        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
-        [COLOR.R[6], COLOR.R[7], COLOR.R[8]]
-      ],
-      BACK: [
-        // (Blue)
-        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
-        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
-        [COLOR.B[6], COLOR.B[7], COLOR.B[8]]
-      ],
-      DOWN: [
-        // (Yellow)
-        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
-        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
-        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]]
-      ]
-    });
+    __publicField(this, "size", 3);
+    const allowedSizes = [2, 3];
+    this.size = allowedSizes.includes(options.size) ? options.size : 3;
+    __privateMethod(this, _CubeEngine_instances, initializeState_fn).call(this);
     if (typeof initialScramble === "string" && initialScramble.trim().length > 0) {
       __privateMethod(this, _CubeEngine_instances, applyMovesFromString_fn).call(this, initialScramble, false);
       this.MOVES = [];
@@ -118,6 +83,18 @@ var CubeEngine = class {
       this.MOVES.push("F'");
     }
   }
+  /**
+   * Rotates the (BACK) layer clockwise or counterclockwise.
+   */
+  rotateB(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true);
+      this.MOVES.push("B");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false);
+      this.MOVES.push("B'");
+    }
+  }
   /**
    * Rotates the (RIGHT) layer clockwise or counterclockwise.
    */
@@ -158,6 +135,7 @@ var CubeEngine = class {
    * Rotates the wide (DOWN two layers) clockwise or counterclockwise.
    */
   rotateDw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, true);
       this.MOVES.push("Dw");
@@ -170,6 +148,7 @@ var CubeEngine = class {
    * Rotates the wide (UPPER two layers) clockwise or counterclockwise.
    */
   rotateUw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, true);
       this.MOVES.push("Uw");
@@ -182,6 +161,7 @@ var CubeEngine = class {
    * Rotates the wide (RIGHT two layers) clockwise or counterclockwise.
    */
   rotateRw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, true);
       this.MOVES.push("Rw");
@@ -194,6 +174,7 @@ var CubeEngine = class {
    * Rotates the wide (LEFT two layers) clockwise or counterclockwise.
    */
   rotateLw(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true);
       this.MOVES.push("Lw");
@@ -206,6 +187,7 @@ var CubeEngine = class {
    * Rotates the middle slice (M) parallel to L/R. Clockwise corresponds to Lw followed by L'.
    */
   rotateM(clockwise = true) {
+    if (this.size === 2) return;
     if (clockwise) {
       __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, true);
       this.MOVES.push("M");
@@ -262,12 +244,11 @@ var CubeEngine = class {
   isSolved() {
     const temp = __spreadValues({}, this.STATES);
     const layersSolved = Object.keys(temp).map((layer) => {
-      const mixedMatrix = [
-        ...temp[layer][0],
-        ...temp[layer][1],
-        ...temp[layer][2]
-      ];
-      const centerColor = mixedMatrix[4];
+      let mixedMatrix = [];
+      for (let i = 0; i < this.size; i++) {
+        mixedMatrix = [...mixedMatrix, ...temp[layer][i]];
+      }
+      const centerColor = this.size === 2 ? mixedMatrix[0] : mixedMatrix[4];
       return mixedMatrix.every((currentColor) => currentColor === centerColor);
     });
     return layersSolved.every((isLayerSolved) => isLayerSolved);
@@ -285,38 +266,7 @@ var CubeEngine = class {
    * Resets the cube to the solved state and clears the move history.
    */
   reset() {
-    this.STATES = {
-      UPPER: [
-        [COLOR.W[0], COLOR.W[1], COLOR.W[2]],
-        [COLOR.W[3], COLOR.W[4], COLOR.W[5]],
-        [COLOR.W[6], COLOR.W[7], COLOR.W[8]]
-      ],
-      LEFT: [
-        [COLOR.O[0], COLOR.O[1], COLOR.O[2]],
-        [COLOR.O[3], COLOR.O[4], COLOR.O[5]],
-        [COLOR.O[6], COLOR.O[7], COLOR.O[8]]
-      ],
-      FRONT: [
-        [COLOR.G[0], COLOR.G[1], COLOR.G[2]],
-        [COLOR.G[3], COLOR.G[4], COLOR.G[5]],
-        [COLOR.G[6], COLOR.G[7], COLOR.G[8]]
-      ],
-      RIGHT: [
-        [COLOR.R[0], COLOR.R[1], COLOR.R[2]],
-        [COLOR.R[3], COLOR.R[4], COLOR.R[5]],
-        [COLOR.R[6], COLOR.R[7], COLOR.R[8]]
-      ],
-      BACK: [
-        [COLOR.B[0], COLOR.B[1], COLOR.B[2]],
-        [COLOR.B[3], COLOR.B[4], COLOR.B[5]],
-        [COLOR.B[6], COLOR.B[7], COLOR.B[8]]
-      ],
-      DOWN: [
-        [COLOR.Y[0], COLOR.Y[1], COLOR.Y[2]],
-        [COLOR.Y[3], COLOR.Y[4], COLOR.Y[5]],
-        [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]]
-      ]
-    };
+    __privateMethod(this, _CubeEngine_instances, initializeState_fn).call(this);
     this.MOVES = [];
   }
   /**
@@ -331,6 +281,28 @@ var CubeEngine = class {
   }
 };
 _CubeEngine_instances = new WeakSet();
+initializeState_fn = function() {
+  this.STATES = {
+    UPPER: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "W"),
+    LEFT: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "O"),
+    FRONT: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "G"),
+    RIGHT: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "R"),
+    BACK: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "B"),
+    DOWN: __privateMethod(this, _CubeEngine_instances, createFace_fn).call(this, "Y")
+  };
+};
+// Create a face matrix based on cube size
+createFace_fn = function(color) {
+  const face = [];
+  for (let i = 0; i < this.size; i++) {
+    const row = [];
+    for (let j = 0; j < this.size; j++) {
+      row.push(color);
+    }
+    face.push(row);
+  }
+  return face;
+};
 rotateU_fn = function(clockwise = true) {
   if (clockwise) {
     this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, true);
@@ -365,6 +337,17 @@ rotateF_fn = function(clockwise = true) {
     __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
   }
 };
+rotateB_fn = function(clockwise = true) {
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false);
+  }
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+  __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+};
 rotateR_fn = function(clockwise = true) {
   if (clockwise) {
     __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
@@ -523,19 +506,37 @@ rotateY_fn = function(clockwise = true) {
  */
 switchMatrix_fn = function(matrix, clockwise = true) {
   const clone = structuredClone(matrix);
-  const tempMatrix = [...clone[0], ...clone[1], ...clone[2]];
-  if (clockwise) {
-    return [
-      [tempMatrix[6], tempMatrix[3], tempMatrix[0]],
-      [tempMatrix[7], tempMatrix[4], tempMatrix[1]],
-      [tempMatrix[8], tempMatrix[5], tempMatrix[2]]
-    ];
+  const size = this.size;
+  let tempMatrix = [];
+  for (let i = 0; i < size; i++) {
+    tempMatrix = [...tempMatrix, ...clone[i]];
+  }
+  if (size === 2) {
+    if (clockwise) {
+      return [
+        [tempMatrix[2], tempMatrix[0]],
+        [tempMatrix[3], tempMatrix[1]]
+      ];
+    } else {
+      return [
+        [tempMatrix[1], tempMatrix[3]],
+        [tempMatrix[0], tempMatrix[2]]
+      ];
+    }
   } else {
-    return [
-      [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
-      [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
-      [tempMatrix[0], tempMatrix[3], tempMatrix[6]]
-    ];
+    if (clockwise) {
+      return [
+        [tempMatrix[6], tempMatrix[3], tempMatrix[0]],
+        [tempMatrix[7], tempMatrix[4], tempMatrix[1]],
+        [tempMatrix[8], tempMatrix[5], tempMatrix[2]]
+      ];
+    } else {
+      return [
+        [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
+        [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
+        [tempMatrix[0], tempMatrix[3], tempMatrix[6]]
+      ];
+    }
   }
 };
 specialFlip_fn = function(matrix) {
@@ -550,7 +551,6 @@ applyMovesFromString_fn = function(sequence, record = true) {
     const rest = token.slice(1);
     const isDouble = rest.includes("2");
     const isPrime = rest.includes("'");
-    const times = isDouble ? 2 : 1;
     const exec = (fnClockwise, fnCounter) => {
       if (isDouble) {
         fnClockwise();
@@ -634,6 +634,12 @@ applyMovesFromString_fn = function(sequence, record = true) {
           () => record ? this.rotateF(false) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false)
         );
         break;
+      case "B":
+        exec(
+          () => record ? this.rotateB(true) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, true),
+          () => record ? this.rotateB(false) : __privateMethod(this, _CubeEngine_instances, rotateB_fn).call(this, false)
+        );
+        break;
       case "x":
         exec(
           () => record ? this.rotateX(true) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true),