cube-state-engine 1.0.1 → 1.0.3

package/README.md

@@ -1,3 +1,57 @@
-# cube-state-engine
+# CUBE STATE ENGINE
 
-An efficient representation in memory for tracking the Rubik's cube state on each movement.
+A core state manager designed to integrate with custom 3D cube models. This engine makes it easy to track and update the cube's state after every move, providing contextual information such as whether the cube is solved.
+
+---
+
+## Methods
+
+| Method                        | Description                                                                | Return Type |
+| ----------------------------- | -------------------------------------------------------------------------- | ----------- |
+| `isSolved()`                  | Checks if the cube is solved.                                              | `boolean`   |
+| `state()`                     | Returns the current state of the cube as an object representing each face. | `object`    |
+| `rotateU(clockwise: boolean)` | Rotates the **Upper** face clockwise or counterclockwise.                  | `void`      |
+| `rotateF(clockwise: boolean)` | Rotates the **Front** face clockwise or counterclockwise.                  | `void`      |
+| `rotateD(clockwise: boolean)` | Rotates the **Down** face clockwise or counterclockwise.                   | `void`      |
+| `rotateX(clockwise: boolean)` | Rotates the cube along the **X-axis** clockwise or counterclockwise.       | `void`      |
+| `rotateY(clockwise: boolean)` | Rotates the cube along the **Y-axis** clockwise or counterclockwise.       | `void`      |
+| `rotateL(clockwise: boolean)` | Rotates the **Left** face clockwise or counterclockwise.                   | `void`      |
+| `rotateR(clockwise: boolean)` | Rotates the **Right** face clockwise or counterclockwise.                  | `void`      |
+
+---
+
+## Cube State Structure
+
+The `state()` method returns the current state of the cube as an object with six properties, each representing a face:
+
+| Face    | Description                  | Structure    |
+| ------- | ---------------------------- | ------------ |
+| `UPPER` | The top face of the cube.    | `string[][]` |
+| `LEFT`  | The left face of the cube.   | `string[][]` |
+| `FRONT` | The front face of the cube.  | `string[][]` |
+| `RIGHT` | The right face of the cube.  | `string[][]` |
+| `BACK`  | The back face of the cube.   | `string[][]` |
+| `DOWN`  | The bottom face of the cube. | `string[][]` |
+
+---
+
+## Example Usage
+
+```javascript
+import { CubeEngine } from "cube-state-engine";
+
+// Initialize the engine
+const cube = new CubeEngine();
+
+// Check if the cube is solved
+console.log(cube.isSolved()); // true
+
+// Rotate the upper face clockwise
+cube.rotateU(true);
+
+// Get the current cube state
+console.log(cube.state());
+
+// Rotate the cube along the Y-axis
+cube.rotateY(false);
+```

package/{src/index.js → dist/index.d.mts}

@@ -1,4 +1,4 @@
-export class CubeEngine {
+class CubeEngine {
   // States object for the rotation
   STATES = {
     UPPER: [
@@ -265,11 +265,13 @@ export class CubeEngine {
   }
 }
 
-export const COLOR = {
+const COLOR = {
   W: ["W", "W", "W", "W", "W", "W", "W", "W", "W"],
   G: ["G", "G", "G", "G", "G", "G", "G", "G", "G"],
   R: ["R", "R", "R", "R", "R", "R", "R", "R", "R"],
   B: ["B", "B", "B", "B", "B", "B", "B", "B", "B"],
   O: ["O", "O", "O", "O", "O", "O", "O", "O", "O"],
   Y: ["Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"],
-};
+};
+
+export { COLOR, CubeEngine };

package/dist/index.d.ts

@@ -0,0 +1,277 @@
+class CubeEngine {
+  // 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]],
+    ],
+  };
+
+  /**
+   * Rotates the top (U) layer clockwise or counterclockwise.
+   */
+  rotateU(clockwise = true) {
+    if (clockwise) {
+      // Rotate the top layer (UPPER) clockwise
+      this.STATES.UPPER = this.#switchMatrix(this.STATES.UPPER, true);
+
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+
+      this.STATES.FRONT[0] = [...tempRight];
+      this.STATES.LEFT[0] = [...tempFront];
+      this.STATES.BACK[0] = [...tempLeft];
+      this.STATES.RIGHT[0] = [...tempBack];
+    } else {
+      // Rotate the top layer (UPPER) counterclockwise
+      this.STATES.UPPER = this.#switchMatrix(this.STATES.UPPER, false);
+
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+
+      this.STATES.FRONT[0] = [...tempLeft];
+      this.STATES.LEFT[0] = [...tempBack];
+      this.STATES.BACK[0] = [...tempRight];
+      this.STATES.RIGHT[0] = [...tempFront];
+    }
+  }
+
+  /**
+   * Rotates the front (F) layer clockwise or counterclockwise.
+   */
+  rotateF(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+    }
+  }
+
+  rotateR(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(false);
+    } else {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(false);
+    }
+  }
+
+  rotateL(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(true);
+    } else {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(true);
+    }
+  }
+
+  rotateD(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateF(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateF(false);
+      this.rotateX(false);
+    }
+  }
+
+  /**
+   * Rotates the (x) axis clockwise or counterclockwise.
+   */
+  rotateX(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempDown = structuredClone(this.STATES.DOWN);
+    const tempUpper = structuredClone(this.STATES.UPPER);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+
+    if (clockwise) {
+      // Rotate the RIGHT and LEFT layers
+      this.STATES.LEFT = this.#switchMatrix(tempLeft, false);
+      this.STATES.RIGHT = this.#switchMatrix(tempRight, true);
+
+      // Rotation X axis
+      this.STATES.FRONT = [...tempDown];
+      this.STATES.UPPER = [...tempFront];
+
+      // Special permutation
+      this.STATES.BACK = this.#specialFlip(tempUpper);
+      this.STATES.DOWN = this.#specialFlip(tempBack);
+    } else {
+      // Rotate the RIGHT and LEFT layers
+      this.STATES.LEFT = this.#switchMatrix(tempLeft, true);
+      this.STATES.RIGHT = this.#switchMatrix(tempRight, false);
+
+      // Rotation X axis
+      this.STATES.FRONT = [...tempUpper];
+      this.STATES.DOWN = [...tempFront];
+
+      // Special permutation
+      this.STATES.BACK = this.#specialFlip(tempDown);
+      this.STATES.UPPER = this.#specialFlip(tempBack);
+    }
+  }
+
+  /**
+   * Rotates the (y) axis clockwise or counterclockwise.
+   */
+  rotateY(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+
+    if (clockwise) {
+      this.STATES.UPPER = this.#switchMatrix(this.STATES.UPPER, true);
+      this.STATES.DOWN = this.#switchMatrix(this.STATES.DOWN, false);
+
+      // Rotation X axis
+      this.STATES.FRONT = [...tempRight];
+      this.STATES.RIGHT = [...tempBack];
+      this.STATES.LEFT = [...tempFront];
+      this.STATES.BACK = [...tempLeft];
+    } else {
+      this.STATES.UPPER = this.#switchMatrix(this.STATES.UPPER, false);
+      this.STATES.DOWN = this.#switchMatrix(this.STATES.DOWN, true);
+
+      // Rotation X axis
+      this.STATES.FRONT = [...tempLeft];
+      this.STATES.RIGHT = [...tempFront];
+      this.STATES.LEFT = [...tempBack];
+      this.STATES.BACK = [...tempRight];
+    }
+  }
+
+  /**
+   * Rotate the entire face in the direction set
+   */
+  #switchMatrix(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]],
+      ];
+    } else {
+      return [
+        [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
+        [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
+        [tempMatrix[0], tempMatrix[3], tempMatrix[6]],
+      ];
+    }
+  }
+
+  #specialFlip(matrix) {
+    return structuredClone(matrix)
+      .reverse()
+      .map((row) => [...row].reverse());
+  }
+
+  /**
+   * Logs the current state of the cube.
+   */
+  state() {
+    console.clear();
+    console.log({
+      ...this.STATES,
+    });
+    return {
+      ...this.STATES,
+    };
+  }
+
+  /**
+   * Indicates if the cube is solve or not in all layers.
+   */
+  isSolved() {
+    const temp = {
+      ...this.STATES,
+    };
+
+    const layersSolved = Object.keys(temp).map((layer) => {
+      const mixedMatrix = [
+        ...temp[layer][0],
+        ...temp[layer][1],
+        ...temp[layer][2],
+      ];
+
+      const centerColor = mixedMatrix[4];
+
+      return mixedMatrix.every((currentColor) => currentColor === centerColor);
+    });
+
+    return layersSolved.every((isLayerSolved) => isLayerSolved);
+  }
+}
+
+const COLOR = {
+  W: ["W", "W", "W", "W", "W", "W", "W", "W", "W"],
+  G: ["G", "G", "G", "G", "G", "G", "G", "G", "G"],
+  R: ["R", "R", "R", "R", "R", "R", "R", "R", "R"],
+  B: ["B", "B", "B", "B", "B", "B", "B", "B", "B"],
+  O: ["O", "O", "O", "O", "O", "O", "O", "O", "O"],
+  Y: ["Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"],
+};
+
+export { COLOR, CubeEngine };

package/dist/index.js

@@ -0,0 +1,284 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+
+// src/index.js
+var src_exports = {};
+__export(src_exports, {
+  COLOR: () => COLOR,
+  CubeEngine: () => CubeEngine
+});
+module.exports = __toCommonJS(src_exports);
+var _CubeEngine_instances, switchMatrix_fn, specialFlip_fn;
+var CubeEngine = class {
+  constructor() {
+    __privateAdd(this, _CubeEngine_instances);
+    // 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]]
+      ]
+    });
+  }
+  /**
+   * Rotates the top (U) layer clockwise or counterclockwise.
+   */
+  rotateU(clockwise = true) {
+    if (clockwise) {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, true);
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+      this.STATES.FRONT[0] = [...tempRight];
+      this.STATES.LEFT[0] = [...tempFront];
+      this.STATES.BACK[0] = [...tempLeft];
+      this.STATES.RIGHT[0] = [...tempBack];
+    } else {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, false);
+      const tempFront = [...this.STATES.FRONT[0]];
+      const tempRight = [...this.STATES.RIGHT[0]];
+      const tempLeft = [...this.STATES.LEFT[0]];
+      const tempBack = [...this.STATES.BACK[0]];
+      this.STATES.FRONT[0] = [...tempLeft];
+      this.STATES.LEFT[0] = [...tempBack];
+      this.STATES.BACK[0] = [...tempRight];
+      this.STATES.RIGHT[0] = [...tempFront];
+    }
+  }
+  /**
+   * Rotates the front (F) layer clockwise or counterclockwise.
+   */
+  rotateF(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+    }
+  }
+  rotateR(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(false);
+    } else {
+      this.rotateY(true);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(false);
+    }
+  }
+  rotateL(clockwise = true) {
+    if (clockwise) {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(true);
+      this.rotateX(false);
+      this.rotateY(true);
+    } else {
+      this.rotateY(false);
+      this.rotateX(true);
+      this.rotateU(false);
+      this.rotateX(false);
+      this.rotateY(true);
+    }
+  }
+  rotateD(clockwise = true) {
+    if (clockwise) {
+      this.rotateX(true);
+      this.rotateF(true);
+      this.rotateX(false);
+    } else {
+      this.rotateX(true);
+      this.rotateF(false);
+      this.rotateX(false);
+    }
+  }
+  /**
+   * Rotates the (x) axis clockwise or counterclockwise.
+   */
+  rotateX(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempDown = structuredClone(this.STATES.DOWN);
+    const tempUpper = structuredClone(this.STATES.UPPER);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    if (clockwise) {
+      this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, false);
+      this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, true);
+      this.STATES.FRONT = [...tempDown];
+      this.STATES.UPPER = [...tempFront];
+      this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempUpper);
+      this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
+    } else {
+      this.STATES.LEFT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempLeft, true);
+      this.STATES.RIGHT = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, tempRight, false);
+      this.STATES.FRONT = [...tempUpper];
+      this.STATES.DOWN = [...tempFront];
+      this.STATES.BACK = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempDown);
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, specialFlip_fn).call(this, tempBack);
+    }
+  }
+  /**
+   * Rotates the (y) axis clockwise or counterclockwise.
+   */
+  rotateY(clockwise = true) {
+    const tempFront = structuredClone(this.STATES.FRONT);
+    const tempRight = structuredClone(this.STATES.RIGHT);
+    const tempBack = structuredClone(this.STATES.BACK);
+    const tempLeft = structuredClone(this.STATES.LEFT);
+    if (clockwise) {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, true);
+      this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.DOWN, false);
+      this.STATES.FRONT = [...tempRight];
+      this.STATES.RIGHT = [...tempBack];
+      this.STATES.LEFT = [...tempFront];
+      this.STATES.BACK = [...tempLeft];
+    } else {
+      this.STATES.UPPER = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.UPPER, false);
+      this.STATES.DOWN = __privateMethod(this, _CubeEngine_instances, switchMatrix_fn).call(this, this.STATES.DOWN, true);
+      this.STATES.FRONT = [...tempLeft];
+      this.STATES.RIGHT = [...tempFront];
+      this.STATES.LEFT = [...tempBack];
+      this.STATES.BACK = [...tempRight];
+    }
+  }
+  /**
+   * Logs the current state of the cube.
+   */
+  state() {
+    console.clear();
+    console.log(__spreadValues({}, this.STATES));
+    return __spreadValues({}, this.STATES);
+  }
+  /**
+   * Indicates if the cube is solve or not in all layers.
+   */
+  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];
+      return mixedMatrix.every((currentColor) => currentColor === centerColor);
+    });
+    return layersSolved.every((isLayerSolved) => isLayerSolved);
+  }
+};
+_CubeEngine_instances = new WeakSet();
+/**
+ * Rotate the entire face in the direction set
+ */
+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]]
+    ];
+  } else {
+    return [
+      [tempMatrix[2], tempMatrix[5], tempMatrix[8]],
+      [tempMatrix[1], tempMatrix[4], tempMatrix[7]],
+      [tempMatrix[0], tempMatrix[3], tempMatrix[6]]
+    ];
+  }
+};
+specialFlip_fn = function(matrix) {
+  return structuredClone(matrix).reverse().map((row) => [...row].reverse());
+};
+var COLOR = {
+  W: ["W", "W", "W", "W", "W", "W", "W", "W", "W"],
+  G: ["G", "G", "G", "G", "G", "G", "G", "G", "G"],
+  R: ["R", "R", "R", "R", "R", "R", "R", "R", "R"],
+  B: ["B", "B", "B", "B", "B", "B", "B", "B", "B"],
+  O: ["O", "O", "O", "O", "O", "O", "O", "O", "O"],
+  Y: ["Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y"]
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COLOR,
+  CubeEngine
+});