@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist-cjs/puzzles/fto/solver/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateFtoRandomState = exports.solveFtoFacelet = exports.isFtoSolverInitialized = exports.initFtoSolver = exports.solveFto = void 0;
+var engine_js_1 = require("./engine.js");
+Object.defineProperty(exports, "solveFto", { enumerable: true, get: function () { return engine_js_1.solveFto; } });
+Object.defineProperty(exports, "initFtoSolver", { enumerable: true, get: function () { return engine_js_1.initFtoSolver; } });
+Object.defineProperty(exports, "isFtoSolverInitialized", { enumerable: true, get: function () { return engine_js_1.isFtoSolverInitialized; } });
+Object.defineProperty(exports, "solveFtoFacelet", { enumerable: true, get: function () { return engine_js_1.solveFtoFacelet; } });
+Object.defineProperty(exports, "generateFtoRandomState", { enumerable: true, get: function () { return engine_js_1.generateFtoRandomState; } });

package/dist-cjs/puzzles/fto/state.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FtoCubie = void 0;
+exports.createSolvedFtoState = createSolvedFtoState;
+exports.cloneFtoState = cloneFtoState;
+exports.statesEqual = statesEqual;
+exports.isSolvedFtoState = isSolvedFtoState;
+class FtoCubie {
+    cp;
+    co;
+    ep;
+    uf;
+    rl;
+    constructor(cp, co, ep, uf, rl) {
+        this.cp = cp ? Array.from(cp) : [0, 1, 2, 3, 4, 5];
+        this.co = co ? Array.from(co) : [0, 0, 0, 0, 0, 0];
+        this.ep = ep ? Array.from(ep) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        this.uf = uf ? Array.from(uf) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+        this.rl = rl ? Array.from(rl) : [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    }
+    clone() {
+        return new FtoCubie(this.cp, this.co, this.ep, this.uf, this.rl);
+    }
+    isEqual(other) {
+        for (let i = 0; i < 6; i++) {
+            if (this.cp[i] !== other.cp[i] || this.co[i] !== other.co[i]) {
+                return false;
+            }
+        }
+        for (let i = 0; i < 12; i++) {
+            if (this.ep[i] !== other.ep[i] ||
+                this.uf[i] !== other.uf[i] ||
+                this.rl[i] !== other.rl[i]) {
+                return false;
+            }
+        }
+        return true;
+    }
+    static multiply(...args) {
+        const prod = new FtoCubie();
+        for (let k = args.length - 1; k >= 0; k--) {
+            const a = args[k];
+            for (let i = 0; i < 6; i++) {
+                prod.co[i] = a.co[prod.cp[i]] ^ prod.co[i];
+                prod.cp[i] = a.cp[prod.cp[i]];
+            }
+            for (let i = 0; i < 12; i++) {
+                prod.ep[i] = a.ep[prod.ep[i]];
+                prod.uf[i] = a.uf[prod.uf[i]];
+                prod.rl[i] = a.rl[prod.rl[i]];
+            }
+        }
+        return prod;
+    }
+}
+exports.FtoCubie = FtoCubie;
+function createSolvedFtoState() {
+    return new FtoCubie();
+}
+function cloneFtoState(state) {
+    return state.clone();
+}
+function statesEqual(a, b) {
+    return a.isEqual(b);
+}
+function isSolvedFtoState(state) {
+    const solved = new FtoCubie();
+    return state.isEqual(solved);
+}

package/dist-cjs/puzzles/fto/types.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FTO_CENTER_ORBIT_STATES = exports.FTO_EDGE_PERM_STATES = exports.FTO_CORNER_ORI_STATES = exports.FTO_CORNER_PERM_STATES = exports.FTO_CENTER_ORBIT_COUNT = exports.FTO_EDGE_COUNT = exports.FTO_CORNER_COUNT = exports.SCRAMBLE_LENGTH = exports.FTO_AXIS_MAP = exports.FTO_ALL_MOVES = exports.FTO_FACES = void 0;
+exports.FTO_FACES = [
+    "U",
+    "D",
+    "F",
+    "B",
+    "L",
+    "BR",
+    "R",
+    "BL"
+];
+exports.FTO_ALL_MOVES = [
+    "U",
+    "U'",
+    "D",
+    "D'",
+    "F",
+    "F'",
+    "B",
+    "B'",
+    "L",
+    "L'",
+    "R",
+    "R'",
+    "BL",
+    "BL'",
+    "BR",
+    "BR'"
+];
+exports.FTO_AXIS_MAP = {
+    U: 0,
+    D: 0,
+    F: 1,
+    B: 1,
+    L: 2,
+    BR: 2,
+    R: 3,
+    BL: 3
+};
+exports.SCRAMBLE_LENGTH = 30;
+exports.FTO_CORNER_COUNT = 6;
+exports.FTO_EDGE_COUNT = 12;
+exports.FTO_CENTER_ORBIT_COUNT = 12;
+exports.FTO_CORNER_PERM_STATES = 360; // 6! / 2
+exports.FTO_CORNER_ORI_STATES = 32; // 2^5
+exports.FTO_EDGE_PERM_STATES = 239500800; // 12! / 2
+exports.FTO_CENTER_ORBIT_STATES = 369600; // C(12,3) * C(9,3) * C(6,3)

package/dist-cjs/puzzles/fto/validation.js

@@ -0,0 +1,147 @@
+"use strict";
+/**
+ * Validation and reachability checking for FTO (Face-Turning Octahedron) states.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateFtoState = validateFtoState;
+exports.isTrivialFtoState = isTrivialFtoState;
+const types_js_1 = require("./types.js");
+const state_js_1 = require("./state.js");
+const moves_js_1 = require("./moves.js");
+const coordinates_js_1 = require("./coordinates.js");
+/**
+ * Validates the physical and group-theoretic reachability constraints of an FTO state:
+ *  - 6 corners with unique indices in 0..5 and even permutation parity (A_6)
+ *  - 6 corner orientations in {0, 1} with sum ≡ 0 (mod 2)
+ *  - 12 edges with unique indices in 0..11 and even permutation parity (A_12)
+ *  - 12 centers in orbit 1 (uf) with exactly 3 of each of the 4 colors (0..3)
+ *  - 12 centers in orbit 2 (rl) with exactly 3 of each of the 4 colors (0..3)
+ */
+function validateFtoState(state) {
+    const errors = [];
+    // 1. Validate corners (cp)
+    if (!Array.isArray(state.cp) || state.cp.length !== types_js_1.FTO_CORNER_COUNT) {
+        errors.push(`Corner permutation array (cp) must have length ${types_js_1.FTO_CORNER_COUNT}`);
+    }
+    else {
+        const cpSeen = new Uint8Array(types_js_1.FTO_CORNER_COUNT);
+        let validRange = true;
+        for (let i = 0; i < types_js_1.FTO_CORNER_COUNT; i++) {
+            const v = state.cp[i];
+            if (v < 0 || v >= types_js_1.FTO_CORNER_COUNT || cpSeen[v] > 0) {
+                validRange = false;
+                break;
+            }
+            cpSeen[v] = 1;
+        }
+        if (!validRange) {
+            errors.push("Corner permutation array (cp) must contain a valid permutation of 0..5");
+        }
+        else if ((0, coordinates_js_1.getPermutationParity)(state.cp)) {
+            errors.push("Corner permutation must have even parity (A_6)");
+        }
+    }
+    // 2. Validate corner orientations (co)
+    if (!Array.isArray(state.co) || state.co.length !== types_js_1.FTO_CORNER_COUNT) {
+        errors.push(`Corner orientation array (co) must have length ${types_js_1.FTO_CORNER_COUNT}`);
+    }
+    else {
+        let sum = 0;
+        let validValues = true;
+        for (let i = 0; i < types_js_1.FTO_CORNER_COUNT; i++) {
+            const o = state.co[i];
+            if (o !== 0 && o !== 1) {
+                validValues = false;
+                break;
+            }
+            sum += o;
+        }
+        if (!validValues) {
+            errors.push("Corner orientations must be 0 or 1");
+        }
+        else if ((sum & 1) !== 0) {
+            errors.push("Sum of corner orientations must be even (mod 2)");
+        }
+    }
+    // 3. Validate edges (ep)
+    if (!Array.isArray(state.ep) || state.ep.length !== types_js_1.FTO_EDGE_COUNT) {
+        errors.push(`Edge permutation array (ep) must have length ${types_js_1.FTO_EDGE_COUNT}`);
+    }
+    else {
+        const epSeen = new Uint8Array(types_js_1.FTO_EDGE_COUNT);
+        let validRange = true;
+        for (let i = 0; i < types_js_1.FTO_EDGE_COUNT; i++) {
+            const v = state.ep[i];
+            if (v < 0 || v >= types_js_1.FTO_EDGE_COUNT || epSeen[v] > 0) {
+                validRange = false;
+                break;
+            }
+            epSeen[v] = 1;
+        }
+        if (!validRange) {
+            errors.push("Edge permutation array (ep) must contain a valid permutation of 0..11");
+        }
+        else if ((0, coordinates_js_1.getPermutationParity)(state.ep)) {
+            errors.push("Edge permutation must have even parity (A_12)");
+        }
+    }
+    // 4. Validate center orbit 1 (uf)
+    if (!Array.isArray(state.uf) || state.uf.length !== 12) {
+        errors.push("Center orbit 1 (uf) must have length 12");
+    }
+    else {
+        const counts = [0, 0, 0, 0];
+        for (let i = 0; i < 12; i++) {
+            const color = Math.floor(state.uf[i] / 3);
+            if (color >= 0 && color < 4) {
+                counts[color]++;
+            }
+        }
+        if (!counts.every((c) => c === 3)) {
+            errors.push("Center orbit 1 (uf) must contain exactly 3 pieces of each of the 4 colors");
+        }
+    }
+    // 5. Validate center orbit 2 (rl)
+    if (!Array.isArray(state.rl) || state.rl.length !== 12) {
+        errors.push("Center orbit 2 (rl) must have length 12");
+    }
+    else {
+        const counts = [0, 0, 0, 0];
+        for (let i = 0; i < 12; i++) {
+            const color = Math.floor(state.rl[i] / 3);
+            if (color >= 0 && color < 4) {
+                counts[color]++;
+            }
+        }
+        if (!counts.every((c) => c === 3)) {
+            errors.push("Center orbit 2 (rl) must contain exactly 3 pieces of each of the 4 colors");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+let singleMoveStates = null;
+function getSingleMoveStates() {
+    if (!singleMoveStates) {
+        const solved = (0, state_js_1.createSolvedFtoState)();
+        singleMoveStates = types_js_1.FTO_ALL_MOVES.map((move) => (0, moves_js_1.applyFtoMove)(solved, move));
+    }
+    return singleMoveStates;
+}
+/**
+ * Checks if a state is trivial (solved or 1 move away from solved).
+ */
+function isTrivialFtoState(state) {
+    if ((0, state_js_1.isSolvedFtoState)(state)) {
+        return true;
+    }
+    const oneMoveStates = getSingleMoveStates();
+    for (let i = 0; i < oneMoveStates.length; i++) {
+        if (state.isEqual(oneMoveStates[i])) {
+            return true;
+        }
+    }
+    return false;
+}

package/dist-cjs/puzzles/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.skewb = exports.clock = exports.pyraminx = exports.cube7x7 = exports.cube6x6 = exports.cube5x5 = exports.megaminx = exports.cube4 = exports.cube3 = exports.cube2 = void 0;
+exports.sq1 = exports.fto = exports.skewb = exports.clock = exports.pyraminx = exports.cube7x7 = exports.cube6x6 = exports.cube5x5 = exports.megaminx = exports.cube4 = exports.cube3 = exports.cube2 = void 0;
 const index_js_1 = require("../core/index.js");
 const index_js_2 = require("./cube2/index.js");
 const index_js_3 = require("./cube3/index.js");
@@ -45,6 +45,8 @@ const index_js_8 = require("./cube7x7/index.js");
 const index_js_9 = require("./pyraminx/index.js");
 const index_js_10 = require("./clock/index.js");
 const index_js_11 = require("./skewb/index.js");
+const index_js_12 = require("./fto/index.js");
+const index_js_13 = require("./sq1/index.js");
 (0, index_js_1.registerScrambleGenerator)(index_js_2.cube2ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_3.cube3ScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_4.cube4ScrambleGenerator);
@@ -55,6 +57,8 @@ const index_js_11 = require("./skewb/index.js");
 (0, index_js_1.registerScrambleGenerator)(index_js_9.pyraminxScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_10.clockScrambleGenerator);
 (0, index_js_1.registerScrambleGenerator)(index_js_11.skewbScrambleGenerator);
+(0, index_js_1.registerScrambleGenerator)(index_js_12.ftoScrambleGenerator);
+(0, index_js_1.registerScrambleGenerator)(index_js_13.sq1ScrambleGenerator);
 exports.cube2 = __importStar(require("./cube2/index.js"));
 exports.cube3 = __importStar(require("./cube3/index.js"));
 exports.cube4 = __importStar(require("./cube4/index.js"));
@@ -65,3 +69,5 @@ exports.cube7x7 = __importStar(require("./cube7x7/index.js"));
 exports.pyraminx = __importStar(require("./pyraminx/index.js"));
 exports.clock = __importStar(require("./clock/index.js"));
 exports.skewb = __importStar(require("./skewb/index.js"));
+exports.fto = __importStar(require("./fto/index.js"));
+exports.sq1 = __importStar(require("./sq1/index.js"));

package/dist-cjs/puzzles/skewb/index.js

@@ -33,7 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.skewbScrambleGenerator = exports.generateSkewbScramble = exports.solver = exports.getStateFromIndex = exports.getStateIndex = exports.verifySkewbSolution = exports.verifySkewbScramble = exports.solveSkewbSync = exports.solveSkewbWithInfo = exports.solveSkewb = exports.toSkewbFacelets = exports.getSkewbFaceOrder = exports.formatSkewbFacelets = exports.createSolvedSkewbFacelets = exports.generateRandomSkewbState = exports.isOneMoveFromSolvedSkewbState = exports.isAllowedRandomSkewbState = exports.validateSkewbState = exports.permutationParity = exports.skewbStatesEqual = exports.isSolvedSkewbState = exports.createSolvedSkewbState = exports.cloneSkewbState = exports.parseSkewbMove = exports.parseSkewbAlgorithm = exports.invertSkewbMove = exports.invertSkewbAlgorithm = exports.formatSkewbAlgorithm = exports.applySkewbMove = exports.applySkewbAlgorithm = exports.SKEWB_FACES = exports.SKEWB_MOVES = void 0;
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.skewbScrambleGenerator = exports.generateSkewbScramble = exports.solver = exports.getStateFromIndex = exports.getStateIndex = exports.verifySkewbSolution = exports.verifySkewbScramble = exports.solveSkewbSync = exports.solveSkewbWithInfo = exports.solveSkewb = exports.toSkewbFacelets = exports.getSkewbFaceOrder = exports.formatSkewbFacelets = exports.createSolvedSkewbFacelets = exports.generateRandomSkewbStateSync = exports.generateRandomSkewbState = exports.isOneMoveFromSolvedSkewbState = exports.isAllowedRandomSkewbState = exports.validateSkewbState = exports.permutationParity = exports.skewbStatesEqual = exports.isSolvedSkewbState = exports.createSolvedSkewbState = exports.cloneSkewbState = exports.parseSkewbMove = exports.parseSkewbAlgorithm = exports.invertSkewbMove = exports.invertSkewbAlgorithm = exports.formatSkewbAlgorithm = exports.applySkewbMove = exports.applySkewbAlgorithm = exports.SKEWB_FACES = exports.SKEWB_MOVES = void 0;
 const index_js_1 = require("../../core/index.js");
 const scrambler_js_1 = require("./scrambler.js");
 (0, index_js_1.registerScrambleGenerator)(scrambler_js_1.skewbScrambleGenerator);
@@ -60,6 +60,7 @@ Object.defineProperty(exports, "isAllowedRandomSkewbState", { enumerable: true,
 Object.defineProperty(exports, "isOneMoveFromSolvedSkewbState", { enumerable: true, get: function () { return validation_js_1.isOneMoveFromSolvedSkewbState; } });
 var random_state_js_1 = require("./random-state.js");
 Object.defineProperty(exports, "generateRandomSkewbState", { enumerable: true, get: function () { return random_state_js_1.generateRandomSkewbState; } });
+Object.defineProperty(exports, "generateRandomSkewbStateSync", { enumerable: true, get: function () { return random_state_js_1.generateRandomSkewbStateSync; } });
 var facelets_js_1 = require("./facelets.js");
 Object.defineProperty(exports, "createSolvedSkewbFacelets", { enumerable: true, get: function () { return facelets_js_1.createSolvedSkewbFacelets; } });
 Object.defineProperty(exports, "formatSkewbFacelets", { enumerable: true, get: function () { return facelets_js_1.formatSkewbFacelets; } });

package/dist-cjs/puzzles/skewb/random-state.js

@@ -5,7 +5,10 @@ exports.generateRandomSkewbStateSync = generateRandomSkewbStateSync;
 const index_js_1 = require("../../random/index.js");
 const index_js_2 = require("./solver/index.js");
 async function generateRandomSkewbState(options = {}) {
-    await (0, index_js_2.ensureTablesLoaded)();
+    // Only pay the await/table-load cost when the tables are not already
+    // loaded: in the hot path this runs the sync body directly.
+    if (!(0, index_js_2.areSkewbTablesLoaded)())
+        await (0, index_js_2.ensureTablesLoaded)();
     return generateRandomSkewbStateSync(options);
 }
 // Synchronous variant for callers that have already ensured the tables are

package/dist-cjs/puzzles/sq1/facelets.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSquare1Facelets = toSquare1Facelets;
+exports.formatSquare1Facelets = formatSquare1Facelets;
+/**
+ * Converts a Square-1 state into a Square1Facelets structure.
+ * Extracting face colors and side rim colors for the 12 slots on top and bottom,
+ * and the middle layer state.
+ */
+function toSquare1Facelets(state) {
+    return {
+        top: state.top.map((s) => s.faceColor),
+        topSides: state.top.map((s) => s.sideColor),
+        bottom: state.bottom.map((s) => s.faceColor),
+        bottomSides: state.bottom.map((s) => s.sideColor),
+        middle: state.middle,
+        topSlots: state.top.map((s) => ({ ...s })),
+        bottomSlots: state.bottom.map((s) => ({ ...s })),
+    };
+}
+/**
+ * Formats Square1Facelets into a compact serialization string.
+ */
+function formatSquare1Facelets(facelets) {
+    const topStr = facelets.top.join("");
+    const topSidesStr = facelets.topSides.join("");
+    const botStr = facelets.bottom.join("");
+    const botSidesStr = facelets.bottomSides.join("");
+    return `${topStr}:${topSidesStr}/${botStr}:${botSidesStr}/${facelets.middle}`;
+}

package/dist-cjs/puzzles/sq1/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initializeScrambler = exports.getSupportedEvents = exports.getEventInfo = exports.generateScrambles = exports.generateScramble = exports.INVERSE_SOLUTION = exports.generateSquare1SolverTables = exports.getSquare1SolverTablesSync = exports.areSquare1TablesLoaded = exports.ensureSquare1TablesLoaded = exports.Square1Searcher = exports.stateToFullCube = exports.fullCubeToState = exports.FullCube = exports.generateSquare1ScrambleSync = exports.generateSquare1Scramble = exports.sq1ScrambleGenerator = exports.generateRandomSquare1State = exports.isTrivialSquare1State = exports.validateSquare1State = exports.formatSquare1Facelets = exports.toSquare1Facelets = exports.invertSquare1Algorithm = exports.invertSquare1Move = exports.applySquare1Algorithm = exports.applySquare1Move = exports.formatSquare1Algorithm = exports.parseSquare1Algorithm = exports.getValidTurns = exports.applySlice = exports.applyTurn = exports.applyBottomTurn = exports.applyTopTurn = exports.isSliceable = exports.isSolvedSquare1State = exports.statesEqual = exports.cloneSquare1State = exports.createSolvedSquare1State = void 0;
+const index_js_1 = require("../../core/index.js");
+const scrambler_js_1 = require("./scrambler.js");
+(0, index_js_1.registerScrambleGenerator)(scrambler_js_1.sq1ScrambleGenerator);
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "createSolvedSquare1State", { enumerable: true, get: function () { return state_js_1.createSolvedSquare1State; } });
+Object.defineProperty(exports, "cloneSquare1State", { enumerable: true, get: function () { return state_js_1.cloneSquare1State; } });
+Object.defineProperty(exports, "statesEqual", { enumerable: true, get: function () { return state_js_1.statesEqual; } });
+Object.defineProperty(exports, "isSolvedSquare1State", { enumerable: true, get: function () { return state_js_1.isSolvedSquare1State; } });
+var moves_js_1 = require("./moves.js");
+Object.defineProperty(exports, "isSliceable", { enumerable: true, get: function () { return moves_js_1.isSliceable; } });
+Object.defineProperty(exports, "applyTopTurn", { enumerable: true, get: function () { return moves_js_1.applyTopTurn; } });
+Object.defineProperty(exports, "applyBottomTurn", { enumerable: true, get: function () { return moves_js_1.applyBottomTurn; } });
+Object.defineProperty(exports, "applyTurn", { enumerable: true, get: function () { return moves_js_1.applyTurn; } });
+Object.defineProperty(exports, "applySlice", { enumerable: true, get: function () { return moves_js_1.applySlice; } });
+Object.defineProperty(exports, "getValidTurns", { enumerable: true, get: function () { return moves_js_1.getValidTurns; } });
+Object.defineProperty(exports, "parseSquare1Algorithm", { enumerable: true, get: function () { return moves_js_1.parseSquare1Algorithm; } });
+Object.defineProperty(exports, "formatSquare1Algorithm", { enumerable: true, get: function () { return moves_js_1.formatSquare1Algorithm; } });
+Object.defineProperty(exports, "applySquare1Move", { enumerable: true, get: function () { return moves_js_1.applySquare1Move; } });
+Object.defineProperty(exports, "applySquare1Algorithm", { enumerable: true, get: function () { return moves_js_1.applySquare1Algorithm; } });
+Object.defineProperty(exports, "invertSquare1Move", { enumerable: true, get: function () { return moves_js_1.invertSquare1Move; } });
+Object.defineProperty(exports, "invertSquare1Algorithm", { enumerable: true, get: function () { return moves_js_1.invertSquare1Algorithm; } });
+var facelets_js_1 = require("./facelets.js");
+Object.defineProperty(exports, "toSquare1Facelets", { enumerable: true, get: function () { return facelets_js_1.toSquare1Facelets; } });
+Object.defineProperty(exports, "formatSquare1Facelets", { enumerable: true, get: function () { return facelets_js_1.formatSquare1Facelets; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "validateSquare1State", { enumerable: true, get: function () { return validation_js_1.validateSquare1State; } });
+Object.defineProperty(exports, "isTrivialSquare1State", { enumerable: true, get: function () { return validation_js_1.isTrivialSquare1State; } });
+var random_state_js_1 = require("./random-state.js");
+Object.defineProperty(exports, "generateRandomSquare1State", { enumerable: true, get: function () { return random_state_js_1.generateRandomSquare1State; } });
+var scrambler_js_2 = require("./scrambler.js");
+Object.defineProperty(exports, "sq1ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_2.sq1ScrambleGenerator; } });
+Object.defineProperty(exports, "generateSquare1Scramble", { enumerable: true, get: function () { return scrambler_js_2.generateSquare1Scramble; } });
+Object.defineProperty(exports, "generateSquare1ScrambleSync", { enumerable: true, get: function () { return scrambler_js_2.generateSquare1ScrambleSync; } });
+var index_js_2 = require("./solver/index.js");
+Object.defineProperty(exports, "FullCube", { enumerable: true, get: function () { return index_js_2.FullCube; } });
+Object.defineProperty(exports, "fullCubeToState", { enumerable: true, get: function () { return index_js_2.fullCubeToState; } });
+Object.defineProperty(exports, "stateToFullCube", { enumerable: true, get: function () { return index_js_2.stateToFullCube; } });
+Object.defineProperty(exports, "Square1Searcher", { enumerable: true, get: function () { return index_js_2.Square1Searcher; } });
+Object.defineProperty(exports, "ensureSquare1TablesLoaded", { enumerable: true, get: function () { return index_js_2.ensureSquare1TablesLoaded; } });
+Object.defineProperty(exports, "areSquare1TablesLoaded", { enumerable: true, get: function () { return index_js_2.areSquare1TablesLoaded; } });
+Object.defineProperty(exports, "getSquare1SolverTablesSync", { enumerable: true, get: function () { return index_js_2.getSquare1SolverTablesSync; } });
+Object.defineProperty(exports, "generateSquare1SolverTables", { enumerable: true, get: function () { return index_js_2.generateSquare1SolverTables; } });
+Object.defineProperty(exports, "INVERSE_SOLUTION", { enumerable: true, get: function () { return index_js_2.INVERSE_SOLUTION; } });
+var index_js_3 = require("../../core/index.js");
+Object.defineProperty(exports, "generateScramble", { enumerable: true, get: function () { return index_js_3.generateScramble; } });
+Object.defineProperty(exports, "generateScrambles", { enumerable: true, get: function () { return index_js_3.generateScrambles; } });
+Object.defineProperty(exports, "getEventInfo", { enumerable: true, get: function () { return index_js_3.getEventInfo; } });
+Object.defineProperty(exports, "getSupportedEvents", { enumerable: true, get: function () { return index_js_3.getSupportedEvents; } });
+Object.defineProperty(exports, "initializeScrambler", { enumerable: true, get: function () { return index_js_3.initializeScrambler; } });

package/dist-cjs/puzzles/sq1/moves.js

@@ -0,0 +1,234 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSliceable = isSliceable;
+exports.applyTopTurn = applyTopTurn;
+exports.applyBottomTurn = applyBottomTurn;
+exports.applyTurn = applyTurn;
+exports.applySlice = applySlice;
+exports.getValidTurns = getValidTurns;
+exports.parseSquare1Algorithm = parseSquare1Algorithm;
+exports.formatSquare1Algorithm = formatSquare1Algorithm;
+exports.applySquare1Move = applySquare1Move;
+exports.applySquare1Algorithm = applySquare1Algorithm;
+exports.invertSquare1Move = invertSquare1Move;
+exports.invertSquare1Algorithm = invertSquare1Algorithm;
+const state_js_1 = require("./state.js");
+/**
+ * Checks whether the puzzle is in a state where a slice (/) turn is physically possible.
+ * Both top and bottom layers must have clean cuts at 11/0 (Back seam) and 5/6 (Front seam).
+ */
+function isSliceable(state) {
+    // Top layer seam at 11/0
+    if (state.top[11].isCorner && state.top[0].isCorner && state.top[11].pieceId === state.top[0].pieceId) {
+        return false;
+    }
+    // Top layer seam at 5/6
+    if (state.top[5].isCorner && state.top[6].isCorner && state.top[5].pieceId === state.top[6].pieceId) {
+        return false;
+    }
+    // Bottom layer seam at 11/0
+    if (state.bottom[11].isCorner && state.bottom[0].isCorner && state.bottom[11].pieceId === state.bottom[0].pieceId) {
+        return false;
+    }
+    // Bottom layer seam at 5/6
+    if (state.bottom[5].isCorner && state.bottom[6].isCorner && state.bottom[5].pieceId === state.bottom[6].pieceId) {
+        return false;
+    }
+    return true;
+}
+/**
+ * Applies a clockwise turn of the top layer by u * 30 degrees (u in range -5..6 or any integer).
+ */
+function applyTopTurn(state, u) {
+    const normU = ((u % 12) + 12) % 12;
+    if (normU === 0)
+        return (0, state_js_1.cloneSquare1State)(state);
+    const newTop = Array.from({ length: 12 }, (_, i) => ({
+        ...state.top[(i - normU + 12) % 12],
+    }));
+    return {
+        top: newTop,
+        bottom: state.bottom.map((s) => ({ ...s })),
+        middle: state.middle,
+    };
+}
+/**
+ * Applies a turn of the bottom layer by d * 30 degrees (d in range -5..6 or any integer).
+ */
+function applyBottomTurn(state, d) {
+    const normD = ((d % 12) + 12) % 12;
+    if (normD === 0)
+        return (0, state_js_1.cloneSquare1State)(state);
+    const newBottom = Array.from({ length: 12 }, (_, i) => ({
+        ...state.bottom[(i - normD + 12) % 12],
+    }));
+    return {
+        top: state.top.map((s) => ({ ...s })),
+        bottom: newBottom,
+        middle: state.middle,
+    };
+}
+/**
+ * Applies simultaneous top (u) and bottom (d) turns.
+ */
+function applyTurn(state, u, d) {
+    const normU = ((u % 12) + 12) % 12;
+    const normD = ((d % 12) + 12) % 12;
+    const newTop = normU === 0
+        ? state.top.map((s) => ({ ...s }))
+        : Array.from({ length: 12 }, (_, i) => ({ ...state.top[(i - normU + 12) % 12] }));
+    const newBottom = normD === 0
+        ? state.bottom.map((s) => ({ ...s }))
+        : Array.from({ length: 12 }, (_, i) => ({ ...state.bottom[(i - normD + 12) % 12] }));
+    return {
+        top: newTop,
+        bottom: newBottom,
+        middle: state.middle,
+    };
+}
+/**
+ * Applies a slice (/) move, swapping the right half of top (slots 6..11)
+ * with the right half of bottom (slots 0..5).
+ */
+function applySlice(state) {
+    if (!isSliceable(state)) {
+        throw new Error("Square-1: cannot slice non-sliceable state (corner cuts across seam)");
+    }
+    const next = (0, state_js_1.cloneSquare1State)(state);
+    for (let k = 0; k < 6; k++) {
+        const topSlot = 6 + k;
+        const bottomSlot = k;
+        const pieceFromBottom = { ...state.bottom[bottomSlot] };
+        const pieceFromTop = { ...state.top[topSlot] };
+        next.top[topSlot] = pieceFromBottom;
+        next.bottom[bottomSlot] = pieceFromTop;
+    }
+    next.middle = 1 - next.middle;
+    return next;
+}
+/**
+ * Returns all (u, d) turns from the current state that lead to a sliceable state.
+ * u and d are within range [-5, 6].
+ */
+function getValidTurns(state) {
+    const valid = [];
+    for (let u = -5; u <= 6; u++) {
+        for (let d = -5; d <= 6; d++) {
+            const turned = applyTurn(state, u, d);
+            if (isSliceable(turned)) {
+                valid.push([u, d]);
+            }
+        }
+    }
+    return valid;
+}
+/**
+ * Parses a Square-1 algorithm string into individual move tokens.
+ * Supported tokens: "/", "(u, d)", "(u, d) /", etc.
+ */
+function parseSquare1Algorithm(alg) {
+    if (!alg)
+        return [];
+    const trimmed = alg.trim();
+    if (!trimmed)
+        return [];
+    // Match (u, d) or /
+    const regex = /(\/\s*|\(\s*-?\d+\s*,\s*-?\d+\s*\)\s*)/g;
+    const tokens = [];
+    let match;
+    while ((match = regex.exec(trimmed)) !== null) {
+        const token = match[1].trim();
+        if (token) {
+            tokens.push(token);
+        }
+    }
+    if (tokens.length === 0) {
+        return trimmed.split(/\s+/);
+    }
+    return tokens;
+}
+/**
+ * Formats an array of Square-1 move tokens into standard WCA notation.
+ */
+function formatSquare1Algorithm(moves) {
+    return moves.join(" ").replace(/\s*\/\s*/g, " / ").replace(/\s+/g, " ").trim();
+}
+/**
+ * Applies a single move token to the Square-1 state.
+ * Token can be "/", "(u, d)", or "(u, d) /".
+ */
+function applySquare1Move(state, move) {
+    const clean = move.trim();
+    if (!clean)
+        return state;
+    if (clean === "/") {
+        return applySlice(state);
+    }
+    // Check if it's (u, d) or (u, d) /
+    const turnMatch = clean.match(/^\(\s*(-?\d+)\s*,\s*(-?\d+)\s*\)(\s*\/)?$/);
+    if (turnMatch) {
+        const u = parseInt(turnMatch[1], 10);
+        const d = parseInt(turnMatch[2], 10);
+        let s = applyTurn(state, u, d);
+        if (turnMatch[3]) {
+            s = applySlice(s);
+        }
+        return s;
+    }
+    throw new Error(`Square-1: unrecognized move '${move}'`);
+}
+/**
+ * Applies a full algorithm to a Square-1 state.
+ */
+function applySquare1Algorithm(state, alg) {
+    const moves = Array.isArray(alg) ? alg : parseSquare1Algorithm(alg);
+    let current = state;
+    for (const move of moves) {
+        current = applySquare1Move(current, move);
+    }
+    return current;
+}
+/**
+ * Inverts a single Square-1 move token.
+ */
+function invertSquare1Move(move) {
+    const clean = move.trim();
+    if (!clean || clean === "/")
+        return clean;
+    const turnMatch = clean.match(/^\(?\s*(-?\d+)\s*,\s*(-?\d+)\s*\)?(\s*\/)?$/);
+    if (turnMatch) {
+        const u = parseInt(turnMatch[1], 10);
+        const d = parseInt(turnMatch[2], 10);
+        const invU = u === 0 ? 0 : ((-u % 12) + 12) % 12 > 6 ? (((-u % 12) + 12) % 12) - 12 : ((-u % 12) + 12) % 12;
+        const invD = d === 0 ? 0 : ((-d % 12) + 12) % 12 > 6 ? (((-d % 12) + 12) % 12) - 12 : ((-d % 12) + 12) % 12;
+        return turnMatch[3] ? `/ (${invU}, ${invD})` : `(${invU}, ${invD})`;
+    }
+    return clean;
+}
+/**
+ * Inverts an entire Square-1 algorithm sequence.
+ */
+function invertSquare1Algorithm(alg) {
+    const moves = Array.isArray(alg) ? alg : parseSquare1Algorithm(alg);
+    const inverted = [];
+    for (let i = moves.length - 1; i >= 0; i--) {
+        const m = moves[i].trim();
+        if (m === "/") {
+            inverted.push("/");
+        }
+        else {
+            const turnMatch = m.match(/^\(?\s*(-?\d+)\s*,\s*(-?\d+)\s*\)?(\s*\/)?$/);
+            if (turnMatch) {
+                const u = parseInt(turnMatch[1], 10);
+                const d = parseInt(turnMatch[2], 10);
+                const invU = u === 0 ? 0 : ((-u % 12) + 12) % 12 > 6 ? (((-u % 12) + 12) % 12) - 12 : ((-u % 12) + 12) % 12;
+                const invD = d === 0 ? 0 : ((-d % 12) + 12) % 12 > 6 ? (((-d % 12) + 12) % 12) - 12 : ((-d % 12) + 12) % 12;
+                if (turnMatch[3]) {
+                    inverted.push("/");
+                }
+                inverted.push(`(${invU}, ${invD})`);
+            }
+        }
+    }
+    return inverted;
+}