cube-state-engine 1.0.4 → 1.1.0

package/dist/index.d.ts

@@ -1,6 +1,15 @@
 class CubeEngine {
   MOVES = [];
 
+  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: [
@@ -190,6 +199,122 @@ class CubeEngine {
     }
   }
 
+  /**
+   * Rotates the wide (DOWN two layers) clockwise or counterclockwise.
+   */
+  rotateDw(clockwise = true) {
+    if (clockwise) {
+      this.#rotateDw(true);
+      this.MOVES.push("Dw");
+    } else {
+      this.#rotateDw(false);
+      this.MOVES.push("Dw'");
+    }
+  }
+
+  #rotateDw(clockwise = true) {
+    if (clockwise) {
+      this.#rotateY(false);
+      this.#rotateU(true);
+    } else {
+      this.#rotateY(true);
+      this.#rotateU(false);
+    }
+  }
+
+  /**
+   * Rotates the wide (UPPER two layers) clockwise or counterclockwise.
+   */
+  rotateUw(clockwise = true) {
+    if (clockwise) {
+      this.#rotateUw(true);
+      this.MOVES.push("Uw");
+    } else {
+      this.#rotateUw(false);
+      this.MOVES.push("Uw'");
+    }
+  }
+
+  #rotateUw(clockwise = true) {
+    if (clockwise) {
+      this.#rotateY(true);
+      this.#rotateD(true);
+    } else {
+      this.#rotateY(false);
+      this.#rotateD(false);
+    }
+  }
+
+  /**
+   * Rotates the wide (RIGHT two layers) clockwise or counterclockwise.
+   */
+  rotateRw(clockwise = true) {
+    if (clockwise) {
+      this.#rotateRw(true);
+      this.MOVES.push("Rw");
+    } else {
+      this.#rotateRw(false);
+      this.MOVES.push("Rw'");
+    }
+  }
+
+  #rotateRw(clockwise = true) {
+    if (clockwise) {
+      this.#rotateX(true);
+      this.#rotateL(true);
+    } else {
+      this.#rotateX(false);
+      this.#rotateL(false);
+    }
+  }
+
+  /**
+   * Rotates the wide (LEFT two layers) clockwise or counterclockwise.
+   */
+  rotateLw(clockwise = true) {
+    if (clockwise) {
+      this.#rotateLw(true);
+      this.MOVES.push("Lw");
+    } else {
+      this.#rotateLw(false);
+      this.MOVES.push("Lw'");
+    }
+  }
+
+  #rotateLw(clockwise = true) {
+    if (clockwise) {
+      // Lw equals x' R
+      this.#rotateX(false);
+      this.#rotateR(true);
+    } else {
+      this.#rotateX(true);
+      this.#rotateR(false);
+    }
+  }
+
+  /**
+   * Rotates the middle slice (M) parallel to L/R. Clockwise corresponds to Lw followed by L'.
+   */
+  rotateM(clockwise = true) {
+    if (clockwise) {
+      this.#rotateM(true);
+      this.MOVES.push("M");
+    } else {
+      this.#rotateM(false);
+      this.MOVES.push("M'");
+    }
+  }
+
+  #rotateM(clockwise = true) {
+    if (clockwise) {
+      this.#rotateLw(true);
+      this.#rotateL(false);
+    } else {
+      this.#rotateLw(false);
+      this.#rotateL(true);
+    }
+  }
+
   /**
    * Rotates the (x) axis clockwise or counterclockwise.
    */
@@ -235,6 +360,50 @@ class CubeEngine {
     }
   }
 
+  /**
+   * Rotates the (z) axis clockwise or counterclockwise.
+   */
+  rotateZ(clockwise = true) {
+    if (clockwise) {
+      this.#rotateZ(true);
+      this.MOVES.push("z");
+    } else {
+      this.#rotateZ(false);
+      this.MOVES.push("z'");
+    }
+  }
+
+  #rotateZ(clockwise = true) {
+    const tempUpper = structuredClone(this.STATES.UPPER);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    const tempDown = structuredClone(this.STATES.DOWN);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempBack = structuredClone(this.STATES.BACK);
+
+    if (clockwise) {
+      // Rotate faces on the rotation axis
+      this.STATES.FRONT = this.#switchMatrix(tempFront, true);
+      this.STATES.BACK = this.#switchMatrix(tempBack, false);
+
+      // Cycle U -> R -> D -> L -> U with proper orientation
+      this.STATES.RIGHT = this.#switchMatrix(tempUpper, true);
+      this.STATES.DOWN = this.#switchMatrix(tempRight, true);
+      this.STATES.LEFT = this.#switchMatrix(tempDown, true);
+      this.STATES.UPPER = this.#switchMatrix(tempLeft, true);
+    } else {
+      // Counterclockwise
+      this.STATES.FRONT = this.#switchMatrix(tempFront, false);
+      this.STATES.BACK = this.#switchMatrix(tempBack, true);
+
+      // Cycle U -> L -> D -> R -> U (inverse of clockwise), rotate CCW
+      this.STATES.RIGHT = this.#switchMatrix(tempDown, false);
+      this.STATES.DOWN = this.#switchMatrix(tempLeft, false);
+      this.STATES.LEFT = this.#switchMatrix(tempUpper, false);
+      this.STATES.UPPER = this.#switchMatrix(tempRight, false);
+    }
+  }
+
   /**
    * Rotates the (y) axis clockwise or counterclockwise.
    */
@@ -341,7 +510,145 @@ class CubeEngine {
    * @returns {string|array} The history of movements as an array or string.
    */
   getMoves(asString = true) {
-    return asString ? this.MOVES : this.MOVES.join(" ");
+    return asString ? this.MOVES.join(" ") : this.MOVES;
+  }
+
+  /**
+   * Applies a sequence of moves provided as a string.
+   * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
+   * @param {string} sequence - e.g. "R U' F R2 D Dw Uw Rw Rw' Lw Lw2 M M' M2"
+   * @param {object} options - { record: boolean } whether to record moves in history (default true)
+   */
+  applyMoves(sequence, options = { record: false }) {
+    const record = options?.record !== false;
+    this.#applyMovesFromString(sequence, record);
+  }
+
+  // Internal: parses and applies moves. If record=false, uses private methods to avoid logging.
+  #applyMovesFromString(sequence, record = true) {
+    if (typeof sequence !== "string") return;
+    const tokens = sequence
+      .split(/\s+/)
+      .map((t) => t.trim())
+      .filter((t) => t.length > 0);
+
+    for (const token of tokens) {
+      const base = token[0];
+      const rest = token.slice(1);
+      const isDouble = rest.includes("2");
+      const isPrime = rest.includes("'");
+
+      const exec = (fnClockwise, fnCounter) => {
+        if (isDouble) {
+          // Double turns ignore prime; do two clockwise quarter-turns
+          fnClockwise();
+          fnClockwise();
+        } else {
+          if (isPrime) {
+            fnCounter();
+          } else {
+            fnClockwise();
+          }
+        }
+      };
+
+      switch (base) {
+        case 'U':
+          {
+            const isWide = /w/i.test(rest);
+            if (isWide) {
+              exec(
+                () => (record ? this.rotateUw(true) : this.#rotateUw(true)),
+                () => (record ? this.rotateUw(false) : this.#rotateUw(false))
+              );
+            } else {
+              exec(
+                () => (record ? this.rotateU(true) : this.#rotateU(true)),
+                () => (record ? this.rotateU(false) : this.#rotateU(false))
+              );
+            }
+          }
+          break;
+        case 'D':
+          {
+            const isWide = /w/i.test(rest);
+            if (isWide) {
+              exec(
+                () => (record ? this.rotateDw(true) : this.#rotateDw(true)),
+                () => (record ? this.rotateDw(false) : this.#rotateDw(false))
+              );
+            } else {
+              exec(
+                () => (record ? this.rotateD(true) : this.#rotateD(true)),
+                () => (record ? this.rotateD(false) : this.#rotateD(false))
+              );
+            }
+          }
+          break;
+        case 'L':
+          {
+            const isWide = /w/i.test(rest);
+            if (isWide) {
+              exec(
+                () => (record ? this.rotateLw(true) : this.#rotateLw(true)),
+                () => (record ? this.rotateLw(false) : this.#rotateLw(false))
+              );
+            } else {
+              exec(
+                () => (record ? this.rotateL(true) : this.#rotateL(true)),
+                () => (record ? this.rotateL(false) : this.#rotateL(false))
+              );
+            }
+          }
+          break;
+        case 'R':
+          {
+            const isWide = /w/i.test(rest);
+            if (isWide) {
+              exec(
+                () => (record ? this.rotateRw(true) : this.#rotateRw(true)),
+                () => (record ? this.rotateRw(false) : this.#rotateRw(false))
+              );
+            } else {
+              exec(
+                () => (record ? this.rotateR(true) : this.#rotateR(true)),
+                () => (record ? this.rotateR(false) : this.#rotateR(false))
+              );
+            }
+          }
+          break;
+        case 'F':
+          exec(
+            () => (record ? this.rotateF(true) : this.#rotateF(true)),
+            () => (record ? this.rotateF(false) : this.#rotateF(false))
+          );
+          break;
+        case 'x':
+          exec(
+            () => (record ? this.rotateX(true) : this.#rotateX(true)),
+            () => (record ? this.rotateX(false) : this.#rotateX(false))
+          );
+          break;
+        case 'y':
+          exec(
+            () => (record ? this.rotateY(true) : this.#rotateY(true)),
+            () => (record ? this.rotateY(false) : this.#rotateY(false))
+          );
+          break;
+        case 'z':
+          exec(
+            () => (record ? this.rotateZ(true) : this.#rotateZ(true)),
+            () => (record ? this.rotateZ(false) : this.#rotateZ(false))
+          );
+          break;
+        case 'M':
+          exec(
+            () => (record ? this.rotateM(true) : this.#rotateM(true)),
+            () => (record ? this.rotateM(false) : this.#rotateM(false))
+          );
+          break;
+      }
+    }
   }
 }
 

package/dist/index.js

@@ -45,9 +45,9 @@ __export(src_exports, {
   CubeEngine: () => CubeEngine
 });
 module.exports = __toCommonJS(src_exports);
-var _CubeEngine_instances, rotateU_fn, rotateF_fn, rotateR_fn, rotateL_fn, rotateD_fn, rotateX_fn, rotateY_fn, switchMatrix_fn, specialFlip_fn;
+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 = class {
-  constructor() {
+  constructor(initialScramble) {
     __privateAdd(this, _CubeEngine_instances);
     __publicField(this, "MOVES", []);
     // States object for the rotation
@@ -89,6 +89,10 @@ var CubeEngine = class {
         [COLOR.Y[6], COLOR.Y[7], COLOR.Y[8]]
       ]
     });
+    if (typeof initialScramble === "string" && initialScramble.trim().length > 0) {
+      __privateMethod(this, _CubeEngine_instances, applyMovesFromString_fn).call(this, initialScramble, false);
+      this.MOVES = [];
+    }
   }
   /**
    * Rotates the (UPPER) layer clockwise or counterclockwise.
@@ -150,6 +154,66 @@ var CubeEngine = class {
       this.MOVES.push("D'");
     }
   }
+  /**
+   * Rotates the wide (DOWN two layers) clockwise or counterclockwise.
+   */
+  rotateDw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, true);
+      this.MOVES.push("Dw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, false);
+      this.MOVES.push("Dw'");
+    }
+  }
+  /**
+   * Rotates the wide (UPPER two layers) clockwise or counterclockwise.
+   */
+  rotateUw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, true);
+      this.MOVES.push("Uw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, false);
+      this.MOVES.push("Uw'");
+    }
+  }
+  /**
+   * Rotates the wide (RIGHT two layers) clockwise or counterclockwise.
+   */
+  rotateRw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, true);
+      this.MOVES.push("Rw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, false);
+      this.MOVES.push("Rw'");
+    }
+  }
+  /**
+   * Rotates the wide (LEFT two layers) clockwise or counterclockwise.
+   */
+  rotateLw(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true);
+      this.MOVES.push("Lw");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false);
+      this.MOVES.push("Lw'");
+    }
+  }
+  /**
+   * Rotates the middle slice (M) parallel to L/R. Clockwise corresponds to Lw followed by L'.
+   */
+  rotateM(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, true);
+      this.MOVES.push("M");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, false);
+      this.MOVES.push("M'");
+    }
+  }
   /**
    * Rotates the (x) axis clockwise or counterclockwise.
    */
@@ -162,6 +226,18 @@ var CubeEngine = class {
       this.MOVES.push("x'");
     }
   }
+  /**
+   * Rotates the (z) axis clockwise or counterclockwise.
+   */
+  rotateZ(clockwise = true) {
+    if (clockwise) {
+      __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, true);
+      this.MOVES.push("z");
+    } else {
+      __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, false);
+      this.MOVES.push("z'");
+    }
+  }
   /**
    * Rotates the (y) axis clockwise or counterclockwise.
    */
@@ -203,7 +279,17 @@ var CubeEngine = class {
    * @returns {string|array} The history of movements as an array or string.
    */
   getMoves(asString = true) {
-    return asString ? this.MOVES : this.MOVES.join(" ");
+    return asString ? this.MOVES.join(" ") : this.MOVES;
+  }
+  /**
+   * Applies a sequence of moves provided as a string.
+   * Supports: U, D, L, R, F, x, y, z; slice moves: M; and wide moves: Dw, Uw, Rw, Lw with optional ' for counterclockwise and 2 for double turns.
+   * @param {string} sequence - e.g. "R U' F R2 D Dw Uw Rw Rw' Lw Lw2 M M' M2"
+   * @param {object} options - { record: boolean } whether to record moves in history (default true)
+   */
+  applyMoves(sequence, options = { record: false }) {
+    const record = (options == null ? void 0 : options.record) !== false;
+    __privateMethod(this, _CubeEngine_instances, applyMovesFromString_fn).call(this, sequence, record);
   }
 };
 _CubeEngine_instances = new WeakSet();
@@ -282,6 +368,51 @@ rotateD_fn = function(clockwise = true) {
     __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
   }
 };
+rotateDw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false);
+  }
+};
+rotateUw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, false);
+  }
+};
+rotateRw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false);
+  }
+};
+rotateLw_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, true);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, false);
+  }
+};
+rotateM_fn = function(clockwise = true) {
+  if (clockwise) {
+    __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false);
+  } else {
+    __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false);
+    __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true);
+  }
+};
 rotateX_fn = function(clockwise = true) {
   const tempFront = structuredClone(this.STATES.FRONT);
   const tempDown = structuredClone(this.STATES.DOWN);
@@ -305,6 +436,29 @@ rotateX_fn = function(clockwise = true) {
     this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
   }
 };
+rotateZ_fn = function(clockwise = true) {
+  const tempUpper = structuredClone(this.STATES.UPPER);
+  const tempRight = structuredClone(this.STATES.RIGHT);
+  const tempDown = structuredClone(this.STATES.DOWN);
+  const tempLeft = structuredClone(this.STATES.LEFT);
+  const tempFront = structuredClone(this.STATES.FRONT);
+  const tempBack = structuredClone(this.STATES.BACK);
+  if (clockwise) {
+    this.STATES.FRONT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempFront, true);
+    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempBack, false);
+    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempUpper, true);
+    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, true);
+    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempDown, true);
+    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, true);
+  } else {
+    this.STATES.FRONT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempFront, false);
+    this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempBack, true);
+    this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempDown, false);
+    this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, false);
+    this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempUpper, false);
+    this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, false);
+  }
+};
 rotateY_fn = function(clockwise = true) {
   const tempFront = structuredClone(this.STATES.FRONT);
   const tempRight = structuredClone(this.STATES.RIGHT);
@@ -349,6 +503,128 @@ switchMatrix_fn = function(matrix, clockwise = true) {
 specialFlip_fn = function(matrix) {
   return structuredClone(matrix).reverse().map((row) => [...row].reverse());
 };
+// Internal: parses and applies moves. If record=false, uses private methods to avoid logging.
+applyMovesFromString_fn = function(sequence, record = true) {
+  if (typeof sequence !== "string") return;
+  const tokens = sequence.split(/\s+/).map((t) => t.trim()).filter((t) => t.length > 0);
+  for (const token of tokens) {
+    const base = token[0];
+    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();
+        fnClockwise();
+      } else {
+        if (isPrime) {
+          fnCounter();
+        } else {
+          fnClockwise();
+        }
+      }
+    };
+    switch (base) {
+      case "U":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateUw(true) : __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, true),
+              () => record ? this.rotateUw(false) : __privateMethod(this, _CubeEngine_instances, rotateUw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateU(true) : __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, true),
+              () => record ? this.rotateU(false) : __privateMethod(this, _CubeEngine_instances, rotateU_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "D":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateDw(true) : __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, true),
+              () => record ? this.rotateDw(false) : __privateMethod(this, _CubeEngine_instances, rotateDw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateD(true) : __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, true),
+              () => record ? this.rotateD(false) : __privateMethod(this, _CubeEngine_instances, rotateD_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "L":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateLw(true) : __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, true),
+              () => record ? this.rotateLw(false) : __privateMethod(this, _CubeEngine_instances, rotateLw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateL(true) : __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, true),
+              () => record ? this.rotateL(false) : __privateMethod(this, _CubeEngine_instances, rotateL_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "R":
+        {
+          const isWide = /w/i.test(rest);
+          if (isWide) {
+            exec(
+              () => record ? this.rotateRw(true) : __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, true),
+              () => record ? this.rotateRw(false) : __privateMethod(this, _CubeEngine_instances, rotateRw_fn).call(this, false)
+            );
+          } else {
+            exec(
+              () => record ? this.rotateR(true) : __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, true),
+              () => record ? this.rotateR(false) : __privateMethod(this, _CubeEngine_instances, rotateR_fn).call(this, false)
+            );
+          }
+        }
+        break;
+      case "F":
+        exec(
+          () => record ? this.rotateF(true) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, true),
+          () => record ? this.rotateF(false) : __privateMethod(this, _CubeEngine_instances, rotateF_fn).call(this, false)
+        );
+        break;
+      case "x":
+        exec(
+          () => record ? this.rotateX(true) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, true),
+          () => record ? this.rotateX(false) : __privateMethod(this, _CubeEngine_instances, rotateX_fn).call(this, false)
+        );
+        break;
+      case "y":
+        exec(
+          () => record ? this.rotateY(true) : __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, true),
+          () => record ? this.rotateY(false) : __privateMethod(this, _CubeEngine_instances, rotateY_fn).call(this, false)
+        );
+        break;
+      case "z":
+        exec(
+          () => record ? this.rotateZ(true) : __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, true),
+          () => record ? this.rotateZ(false) : __privateMethod(this, _CubeEngine_instances, rotateZ_fn).call(this, false)
+        );
+        break;
+      case "M":
+        exec(
+          () => record ? this.rotateM(true) : __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, true),
+          () => record ? this.rotateM(false) : __privateMethod(this, _CubeEngine_instances, rotateM_fn).call(this, false)
+        );
+        break;
+      default:
+        break;
+    }
+  }
+};
 var COLOR = {
   W: ["W", "W", "W", "W", "W", "W", "W", "W", "W"],
   G: ["G", "G", "G", "G", "G", "G", "G", "G", "G"],