@cubingcenter/scrambler 0.1.0

package/dist-cjs/puzzles/cube3/solver/phase2.js

@@ -0,0 +1,279 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cube3Phase2SearchError = void 0;
+exports.solveCube3Phase2 = solveCube3Phase2;
+exports.solveCube3State = solveCube3State;
+exports.encodeCube3Phase2Coordinates = encodeCube3Phase2Coordinates;
+exports.isCube3Phase2Solved = isCube3Phase2Solved;
+exports.applyCube3Phase2Moves = applyCube3Phase2Moves;
+const moves_js_1 = require("../moves.js");
+const state_js_1 = require("../state.js");
+const coordinates_js_1 = require("./coordinates.js");
+const phase1_js_1 = require("./phase1.js");
+const tables_js_1 = require("./tables.js");
+const search_utils_js_1 = require("./search-utils.js");
+class Cube3Phase2SearchError extends Error {
+    visitedNodes;
+    constructor(message, visitedNodes) {
+        super(message);
+        this.name = "Cube3Phase2SearchError";
+        this.visitedNodes = visitedNodes;
+    }
+}
+exports.Cube3Phase2SearchError = Cube3Phase2SearchError;
+const PHASE2_VALID_MOVES = Array.from({ length: 7 }, (_, prevPlusOne) => Array.from({ length: 7 }, (_, prevPrevPlusOne) => {
+    const valid = [];
+    const prevFace = prevPlusOne - 1;
+    const prevPrevFace = prevPrevPlusOne - 1;
+    for (let moveIndex = 0; moveIndex < tables_js_1.CUBE3_PHASE2_MOVES.length; moveIndex += 1) {
+        const face = (0, search_utils_js_1.getMoveFaceByIndex)(moveIndex, tables_js_1.CUBE3_PHASE2_MOVES);
+        if (!(0, search_utils_js_1.shouldSkipCube3SearchMove)(face, prevFace, prevPrevFace)) {
+            valid.push(moveIndex);
+        }
+    }
+    return valid;
+}));
+async function solveCube3Phase2(state, options = {}) {
+    if ((0, state_js_1.isSolvedCube3State)(state)) {
+        const coordinates = encodeCube3Phase2Coordinates(state);
+        return {
+            moves: [],
+            depth: 0,
+            state,
+            coordinates,
+            visitedNodes: 0
+        };
+    }
+    const phase1Tables = await (0, tables_js_1.loadCube3Phase1Tables)();
+    if (!(0, phase1_js_1.isCube3Phase1Solved)(state, phase1Tables)) {
+        throw new Cube3Phase2SearchError("3x3 Phase 2 requires a state already in G1.", 0);
+    }
+    const tables = options.tables ?? await (0, tables_js_1.loadCube3Phase2Tables)();
+    const maxDepth = options.maxDepth ?? 18;
+    const start = encodeCube3Phase2Coordinates(state);
+    const deadline = options.timeoutMs === undefined ? undefined : performance.now() + options.timeoutMs;
+    const context = {
+        tables,
+        deadline,
+        visitedNodes: 0,
+        timedOut: false
+    };
+    const spRange = tables.moveTables.slicePermutation.range;
+    const cpspTable = tables.pruningTables.cornerPermutationSlicePermutation.values;
+    const epspTable = tables.pruningTables.udEdgePermutationSlicePermutation.values;
+    const combinedCPIndex = start.cornerPermutation * spRange + start.slicePermutation;
+    const combinedEPIndex = start.udEdgePermutation * spRange + start.slicePermutation;
+    const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
+    const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
+    const minDepth = cpDist > epDist ? cpDist : epDist;
+    const initialPreviousFace = options.previousFace ?? -1;
+    const initialPreviousPreviousFace = options.previousPreviousFace ?? -1;
+    for (let depth = minDepth; depth <= maxDepth; depth += 1) {
+        const path = [];
+        const solved = searchPhase2(start.cornerPermutation, start.udEdgePermutation, start.slicePermutation, initialPreviousFace, initialPreviousPreviousFace, depth, path, context);
+        if (solved) {
+            const nextState = applyCube3Phase2Moves(state, path);
+            const coordinates = encodeCube3Phase2Coordinates(nextState);
+            return {
+                moves: path,
+                depth: path.length,
+                state: nextState,
+                coordinates,
+                visitedNodes: context.visitedNodes
+            };
+        }
+        if (context.timedOut) {
+            throw new Cube3Phase2SearchError(`3x3 Phase 2 search timed out after ${options.timeoutMs}ms.`, context.visitedNodes);
+        }
+    }
+    throw new Cube3Phase2SearchError(`3x3 Phase 2 solution not found within depth ${maxDepth}.`, context.visitedNodes);
+}
+async function solveCube3State(state, options = {}) {
+    const phase1 = await (0, phase1_js_1.solveCube3Phase1)(state, options.phase1);
+    let previousFace = -1;
+    let previousPreviousFace = -1;
+    if (phase1.moves.length > 0) {
+        const lastMove = phase1.moves[phase1.moves.length - 1];
+        previousFace = (0, search_utils_js_1.getMoveFace)(lastMove);
+        if (phase1.moves.length > 1) {
+            const prevMove = phase1.moves[phase1.moves.length - 2];
+            previousPreviousFace = (0, search_utils_js_1.getMoveFace)(prevMove);
+        }
+    }
+    const phase2Options = {
+        ...options.phase2,
+        previousFace,
+        previousPreviousFace
+    };
+    const phase2 = await solveCube3Phase2(phase1.state, phase2Options);
+    const moves = [...phase1.moves, ...phase2.moves];
+    return {
+        phase1,
+        phase2,
+        moves,
+        depth: moves.length,
+        state: phase2.state,
+        visitedNodes: phase1.visitedNodes + phase2.visitedNodes
+    };
+}
+function encodeCube3Phase2Coordinates(state) {
+    return {
+        cornerPermutation: encodeCornerPermutationForPhase2(state),
+        udEdgePermutation: (0, coordinates_js_1.encodeUdEdgePermutation)(state),
+        slicePermutation: (0, coordinates_js_1.encodeSlicePermutation)(state)
+    };
+}
+function isCube3Phase2Solved(input) {
+    const coordinates = isCube3StateLike(input)
+        ? encodeCube3Phase2Coordinates(input)
+        : input;
+    return coordinates.cornerPermutation === 0 &&
+        coordinates.udEdgePermutation === 0 &&
+        coordinates.slicePermutation === 0;
+}
+function applyCube3Phase2Moves(state, moves) {
+    return (0, moves_js_1.applyCube3Algorithm)(state, moves);
+}
+const PHASE2_MOVE_FACES = tables_js_1.CUBE3_PHASE2_MOVES.map((move) => {
+    const char = move[0];
+    return char === "U" ? 0 : char === "D" ? 1 : char === "R" ? 2 : char === "L" ? 3 : char === "F" ? 4 : 5;
+});
+function searchPhase2(cornerPermutation, udEdgePermutation, slicePermutation, previousFace, previousPreviousFace, remainingDepth, path, context) {
+    context.visitedNodes += 1;
+    if (context.deadline !== undefined && (context.visitedNodes & 1023) === 0 && performance.now() > context.deadline) {
+        context.timedOut = true;
+        return false;
+    }
+    if (remainingDepth === 0) {
+        return cornerPermutation === 0 &&
+            udEdgePermutation === 0 &&
+            slicePermutation === 0;
+    }
+    const moveCount = context.tables.phase2Moves.length;
+    const validMoves = PHASE2_VALID_MOVES[previousFace + 1][previousPreviousFace + 1];
+    const cpTable = context.tables.moveTables.cornerPermutation.values;
+    const epTable = context.tables.moveTables.udEdgePermutation.values;
+    const spTable = context.tables.moveTables.slicePermutation.values;
+    const spRange = context.tables.moveTables.slicePermutation.range;
+    const cpspTable = context.tables.pruningTables.cornerPermutationSlicePermutation.values;
+    const epspTable = context.tables.pruningTables.udEdgePermutationSlicePermutation.values;
+    const cpOffset = cornerPermutation * moveCount;
+    const epOffset = udEdgePermutation * moveCount;
+    const spOffset = slicePermutation * moveCount;
+    for (let i = 0; i < validMoves.length; i += 1) {
+        const moveIndex = validMoves[i];
+        const nextCornerPermutation = cpTable[cpOffset + moveIndex];
+        const nextUdEdgePermutation = epTable[epOffset + moveIndex];
+        const nextSlicePermutation = spTable[spOffset + moveIndex];
+        const combinedCPIndex = nextCornerPermutation * spRange + nextSlicePermutation;
+        const combinedEPIndex = nextUdEdgePermutation * spRange + nextSlicePermutation;
+        const cpDist = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
+        const epDist = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
+        const nextLowerBound = cpDist > epDist ? cpDist : epDist;
+        if (nextLowerBound > remainingDepth - 1) {
+            continue;
+        }
+        const face = PHASE2_MOVE_FACES[moveIndex];
+        path.push(context.tables.phase2Moves[moveIndex]);
+        if (searchPhase2(nextCornerPermutation, nextUdEdgePermutation, nextSlicePermutation, face, previousFace, remainingDepth - 1, path, context)) {
+            return true;
+        }
+        path.pop();
+        if (context.timedOut) {
+            return false;
+        }
+    }
+    return false;
+}
+function phase2LowerBound(coordinates, tables) {
+    const combinedCPIndex = coordinates.cornerPermutation * tables.moveTables.slicePermutation.range +
+        coordinates.slicePermutation;
+    const combinedEPIndex = coordinates.udEdgePermutation * tables.moveTables.slicePermutation.range +
+        coordinates.slicePermutation;
+    const cpspTable = tables.pruningTables.cornerPermutationSlicePermutation.values;
+    const epspTable = tables.pruningTables.udEdgePermutationSlicePermutation.values;
+    const cp = (cpspTable[combinedCPIndex >> 1] >> ((combinedCPIndex & 1) << 2)) & 0x0f;
+    const ep = (epspTable[combinedEPIndex >> 1] >> ((combinedEPIndex & 1) << 2)) & 0x0f;
+    return cp > ep ? cp : ep;
+}
+function encodeCornerPermutationForPhase2(state) {
+    return (0, coordinates_js_1.encodePermutation)(state.corners.permutation);
+}
+function isCube3StateLike(input) {
+    return "corners" in input && "edges" in input;
+}
+const PHASE1_VALID_MOVES = Array.from({ length: 7 }, (_, prevPlusOne) => Array.from({ length: 7 }, (_, prevPrevPlusOne) => {
+    const valid = [];
+    const prevFace = prevPlusOne - 1;
+    const prevPrevFace = prevPrevPlusOne - 1;
+    for (let moveIndex = 0; moveIndex < tables_js_1.CUBE3_PHASE1_MOVES.length; moveIndex += 1) {
+        const face = (0, search_utils_js_1.getMoveFaceByIndex)(moveIndex, tables_js_1.CUBE3_PHASE1_MOVES);
+        if (!(0, search_utils_js_1.shouldSkipCube3SearchMove)(face, prevFace, prevPrevFace)) {
+            valid.push(moveIndex);
+        }
+    }
+    return valid;
+}));
+function searchPhase1Interleaved(cornerOrientation, edgeOrientation, udSlice, previousFace, previousPreviousFace, remainingDepth, path, context) {
+    context.visitedNodes += 1;
+    if (context.deadline !== undefined && (context.visitedNodes & 1023) === 0 && performance.now() > context.deadline) {
+        context.timedOut = true;
+        return false;
+    }
+    if (remainingDepth === 0) {
+        const g1State = applyCube3Phase2Moves(context.originalState, path);
+        const start2 = encodeCube3Phase2Coordinates(g1State);
+        const maxPhase2Depth = 6;
+        const phase2Context = {
+            tables: context.phase2Tables,
+            deadline: context.deadline,
+            visitedNodes: 0,
+            timedOut: false
+        };
+        for (let d2 = 0; d2 <= maxPhase2Depth; d2 += 1) {
+            const path2 = [];
+            const solved2 = searchPhase2(start2.cornerPermutation, start2.udEdgePermutation, start2.slicePermutation, -1, -1, d2, path2, phase2Context);
+            if (solved2) {
+                context.finalPhase1Moves = [...path];
+                context.finalPhase2Moves = path2;
+                context.visitedNodes += phase2Context.visitedNodes;
+                return true;
+            }
+        }
+        context.visitedNodes += phase2Context.visitedNodes;
+        return false;
+    }
+    const moveCount = context.phase1Tables.phase1Moves.length;
+    const validMoves = PHASE1_VALID_MOVES[previousFace + 1][previousPreviousFace + 1];
+    const coTable = context.phase1Tables.moveTables.cornerOrientation.values;
+    const eoTable = context.phase1Tables.moveTables.edgeOrientation.values;
+    const udTable = context.phase1Tables.moveTables.udSlice.values;
+    const coeoTable = context.phase1Tables.pruningTables.cornerOrientationEdgeOrientation.values;
+    const udPruningTable = context.phase1Tables.pruningTables.udSlice.values;
+    const coOffset = cornerOrientation * moveCount;
+    const eoOffset = edgeOrientation * moveCount;
+    const udOffset = udSlice * moveCount;
+    for (let i = 0; i < validMoves.length; i += 1) {
+        const moveIndex = validMoves[i];
+        const nextCornerOrientation = coTable[coOffset + moveIndex];
+        const nextEdgeOrientation = eoTable[eoOffset + moveIndex];
+        const nextUdSlice = udTable[udOffset + moveIndex];
+        const combinedIndex = (nextCornerOrientation << 11) + nextEdgeOrientation;
+        const coeo = (coeoTable[combinedIndex >> 1] >> ((combinedIndex & 1) << 2)) & 0x0f;
+        const udSliceDist = (udPruningTable[nextUdSlice >> 1] >> ((nextUdSlice & 1) << 2)) & 0x0f;
+        const nextLowerBound = coeo > udSliceDist ? coeo : udSliceDist;
+        if (nextLowerBound > remainingDepth - 1) {
+            continue;
+        }
+        const face = (0, search_utils_js_1.getMoveFaceByIndex)(moveIndex, context.phase1Tables.phase1Moves);
+        path.push(context.phase1Tables.phase1Moves[moveIndex]);
+        if (searchPhase1Interleaved(nextCornerOrientation, nextEdgeOrientation, nextUdSlice, face, previousFace, remainingDepth - 1, path, context)) {
+            return true;
+        }
+        path.pop();
+        if (context.timedOut) {
+            return false;
+        }
+    }
+    return false;
+}

package/dist-cjs/puzzles/cube3/solver/search-utils.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ARE_OPPOSITE_FACES = void 0;
+exports.getMoveFace = getMoveFace;
+exports.getMoveFaceByIndex = getMoveFaceByIndex;
+exports.areOppositeFaces = areOppositeFaces;
+exports.shouldSkipCube3SearchMove = shouldSkipCube3SearchMove;
+exports.lookupMoveTableByIndex = lookupMoveTableByIndex;
+// Face indices: U=0, D=1, R=2, L=3, F=4, B=5
+const FACE_INDEX_BY_CHAR = {
+    U: 0,
+    D: 1,
+    R: 2,
+    L: 3,
+    F: 4,
+    B: 5
+};
+function getMoveFace(move) {
+    return FACE_INDEX_BY_CHAR[move[0]];
+}
+function getMoveFaceByIndex(moveIndex, moves) {
+    return FACE_INDEX_BY_CHAR[moves[moveIndex][0]];
+}
+exports.ARE_OPPOSITE_FACES = [
+    false, true, false, false, false, false,
+    true, false, false, false, false, false,
+    false, false, false, true, false, false,
+    false, false, true, false, false, false,
+    false, false, false, false, false, true,
+    false, false, false, false, true, false
+];
+function areOppositeFaces(left, right) {
+    return exports.ARE_OPPOSITE_FACES[left * 6 + right];
+}
+function shouldSkipCube3SearchMove(face, previousFace, previousPreviousFace) {
+    if (previousFace === undefined || previousFace === -1) {
+        return false;
+    }
+    if (face === previousFace) {
+        return true;
+    }
+    if (previousPreviousFace === face && areOppositeFaces(face, previousFace)) {
+        return true;
+    }
+    return areOppositeFaces(face, previousFace) && face < previousFace;
+}
+function lookupMoveTableByIndex(values, coordinate, moveIndex, moveCount) {
+    return values[coordinate * moveCount + moveIndex];
+}

package/dist-cjs/puzzles/cube3/solver/table-metadata.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUBE3_SOLVER_TABLE_METADATA = void 0;
+exports.CUBE3_SOLVER_TABLE_METADATA = {
+    moveTables: {
+        cornerOrientation: { range: 2187, moves: 18, solvedCoordinate: 0, checksum: 404550471 },
+        edgeOrientation: { range: 2048, moves: 18, solvedCoordinate: 0, checksum: 2992539525 },
+        udSlice: { range: 495, moves: 18, solvedCoordinate: 494, checksum: 4272096359 },
+        cornerPermutation: { range: 40320, moves: 10, solvedCoordinate: 0, checksum: 3774927605 },
+        udEdgePermutation: { range: 40320, moves: 10, solvedCoordinate: 0, checksum: 400302421 },
+        slicePermutation: { range: 24, moves: 10, solvedCoordinate: 0, checksum: 3510358217 }
+    },
+    pruningTables: {
+        cornerOrientation: { range: 2187, moves: 18, checksum: 1708398310, maxDepth: 6 },
+        edgeOrientation: { range: 2048, moves: 18, checksum: 1305811170, maxDepth: 7 },
+        udSlice: { range: 495, moves: 18, checksum: 1205412689, maxDepth: 5 },
+        cornerOrientationEdgeOrientation: { range: 4478976, moves: 18, checksum: 3003139252, maxDepth: 9 },
+        cornerPermutation: { range: 40320, moves: 10, checksum: 2124468218, maxDepth: 13 },
+        udEdgePermutation: { range: 40320, moves: 10, checksum: 3536968007, maxDepth: 8 },
+        slicePermutation: { range: 24, moves: 10, checksum: 2803408469, maxDepth: 4 },
+        cornerPermutationSlicePermutation: { range: 967680, moves: 10, checksum: 4187188769, maxDepth: 14 },
+        udEdgePermutationSlicePermutation: { range: 967680, moves: 10, checksum: 2840452350, maxDepth: 12 }
+    }
+};

package/dist-cjs/puzzles/cube3/solver/tables.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUBE3_PHASE2_MOVES = exports.CUBE3_PHASE1_MOVES = void 0;
+exports.loadCube3SolverTables = loadCube3SolverTables;
+exports.loadCube3Phase1Tables = loadCube3Phase1Tables;
+exports.loadCube3Phase2Tables = loadCube3Phase2Tables;
+exports.generateCube3Phase1Tables = generateCube3Phase1Tables;
+exports.generateCube3SolverTables = generateCube3SolverTables;
+exports.generateCube3Phase2Tables = generateCube3Phase2Tables;
+exports.generateCube3MoveTable = generateCube3MoveTable;
+exports.generateCube3PruningTable = generateCube3PruningTable;
+exports.generateCube3CombinedPruningTable = generateCube3CombinedPruningTable;
+exports.lookupCube3MoveTable = lookupCube3MoveTable;
+exports.checksum = checksum;
+const types_js_1 = require("../types.js");
+const coordinates_js_1 = require("./coordinates.js");
+const state_js_1 = require("../state.js");
+const generated_assets_js_1 = require("./generated-assets.js");
+exports.CUBE3_PHASE1_MOVES = types_js_1.CUBE3_MOVES;
+exports.CUBE3_PHASE2_MOVES = [
+    "U",
+    "U2",
+    "U'",
+    "D",
+    "D2",
+    "D'",
+    "R2",
+    "L2",
+    "F2",
+    "B2"
+];
+let cachedTables;
+let cachedPhase1Tables;
+let cachedPhase2Tables;
+async function loadCube3SolverTables() {
+    cachedTables ??= await (0, generated_assets_js_1.loadGeneratedCube3SolverTables)();
+    return cachedTables;
+}
+async function loadCube3Phase1Tables() {
+    cachedPhase1Tables ??= await (0, generated_assets_js_1.loadGeneratedCube3Phase1Tables)();
+    return cachedPhase1Tables;
+}
+async function loadCube3Phase2Tables() {
+    cachedPhase2Tables ??= await (0, generated_assets_js_1.loadGeneratedCube3Phase2Tables)();
+    return cachedPhase2Tables;
+}
+function generateCube3Phase1Tables() {
+    const cornerOrientation = generateCube3MoveTable("cornerOrientation", coordinates_js_1.CUBE3_COORDINATE_RANGES.cornerOrientation, exports.CUBE3_PHASE1_MOVES);
+    const edgeOrientation = generateCube3MoveTable("edgeOrientation", coordinates_js_1.CUBE3_COORDINATE_RANGES.edgeOrientation, exports.CUBE3_PHASE1_MOVES);
+    const udSlice = generateCube3MoveTable("udSlice", coordinates_js_1.CUBE3_COORDINATE_RANGES.udSlice, exports.CUBE3_PHASE1_MOVES);
+    return {
+        phase1Moves: exports.CUBE3_PHASE1_MOVES,
+        moveTables: {
+            cornerOrientation,
+            edgeOrientation,
+            udSlice
+        },
+        pruningTables: {
+            cornerOrientation: generateCube3PruningTable(cornerOrientation),
+            edgeOrientation: generateCube3PruningTable(edgeOrientation),
+            udSlice: generateCube3PruningTable(udSlice),
+            cornerOrientationEdgeOrientation: generateCube3CombinedPruningTable(cornerOrientation, edgeOrientation)
+        }
+    };
+}
+function generateCube3SolverTables() {
+    const phase1Tables = generateCube3Phase1Tables();
+    const phase2Tables = generateCube3Phase2Tables();
+    return {
+        phase1Moves: exports.CUBE3_PHASE1_MOVES,
+        phase2Moves: exports.CUBE3_PHASE2_MOVES,
+        moveTables: {
+            cornerOrientation: phase1Tables.moveTables.cornerOrientation,
+            edgeOrientation: phase1Tables.moveTables.edgeOrientation,
+            udSlice: phase1Tables.moveTables.udSlice,
+            cornerPermutation: phase2Tables.moveTables.cornerPermutation,
+            udEdgePermutation: phase2Tables.moveTables.udEdgePermutation,
+            slicePermutation: phase2Tables.moveTables.slicePermutation
+        },
+        pruningTables: {
+            cornerOrientation: phase1Tables.pruningTables.cornerOrientation,
+            edgeOrientation: phase1Tables.pruningTables.edgeOrientation,
+            udSlice: phase1Tables.pruningTables.udSlice,
+            cornerOrientationEdgeOrientation: phase1Tables.pruningTables.cornerOrientationEdgeOrientation,
+            cornerPermutation: phase2Tables.pruningTables.cornerPermutation,
+            udEdgePermutation: phase2Tables.pruningTables.udEdgePermutation,
+            slicePermutation: phase2Tables.pruningTables.slicePermutation,
+            cornerPermutationSlicePermutation: phase2Tables.pruningTables.cornerPermutationSlicePermutation,
+            udEdgePermutationSlicePermutation: phase2Tables.pruningTables.udEdgePermutationSlicePermutation
+        }
+    };
+}
+function generateCube3Phase2Tables() {
+    const cornerPermutation = generateCube3MoveTable("cornerPermutation", coordinates_js_1.CUBE3_COORDINATE_RANGES.cornerPermutation, exports.CUBE3_PHASE2_MOVES);
+    const udEdgePermutation = generateCube3MoveTable("udEdgePermutation", coordinates_js_1.CUBE3_COORDINATE_RANGES.udEdgePermutation, exports.CUBE3_PHASE2_MOVES);
+    const slicePermutation = generateCube3MoveTable("slicePermutation", coordinates_js_1.CUBE3_COORDINATE_RANGES.slicePermutation, exports.CUBE3_PHASE2_MOVES);
+    return {
+        phase2Moves: exports.CUBE3_PHASE2_MOVES,
+        moveTables: {
+            cornerPermutation,
+            udEdgePermutation,
+            slicePermutation
+        },
+        pruningTables: {
+            cornerPermutation: generateCube3PruningTable(cornerPermutation),
+            udEdgePermutation: generateCube3PruningTable(udEdgePermutation),
+            slicePermutation: generateCube3PruningTable(slicePermutation),
+            cornerPermutationSlicePermutation: generateCube3CombinedPruningTable(cornerPermutation, slicePermutation),
+            udEdgePermutationSlicePermutation: generateCube3CombinedPruningTable(udEdgePermutation, slicePermutation)
+        }
+    };
+}
+function generateCube3MoveTable(coordinate, range, moves) {
+    const values = new Int32Array(range * moves.length);
+    for (let value = 0; value < range; value += 1) {
+        for (let moveIndex = 0; moveIndex < moves.length; moveIndex += 1) {
+            values[value * moves.length + moveIndex] = (0, coordinates_js_1.moveCoordinate)(coordinate, value, moves[moveIndex]);
+        }
+    }
+    return {
+        coordinate,
+        moves,
+        range,
+        solvedCoordinate: (0, coordinates_js_1.encodeCube3Coordinates)((0, state_js_1.createSolvedCube3State)())[coordinate],
+        values,
+        checksum: checksum(values)
+    };
+}
+function generateCube3PruningTable(moveTable) {
+    const values = new Uint8Array(moveTable.range);
+    values.fill(255);
+    values[moveTable.solvedCoordinate] = 0;
+    const queue = new Int32Array(moveTable.range);
+    let read = 0;
+    let write = 1;
+    queue[0] = moveTable.solvedCoordinate;
+    let maxDepth = 0;
+    while (read < write) {
+        const current = queue[read];
+        read += 1;
+        const nextDepth = values[current] + 1;
+        for (let moveIndex = 0; moveIndex < moveTable.moves.length; moveIndex += 1) {
+            const next = moveTable.values[current * moveTable.moves.length + moveIndex];
+            if (values[next] !== 255) {
+                continue;
+            }
+            values[next] = nextDepth;
+            maxDepth = Math.max(maxDepth, nextDepth);
+            queue[write] = next;
+            write += 1;
+        }
+    }
+    return {
+        coordinate: moveTable.coordinate,
+        moves: moveTable.moves,
+        range: moveTable.range,
+        values,
+        checksum: checksum(values),
+        maxDepth
+    };
+}
+function generateCube3CombinedPruningTable(tableA, tableB) {
+    const combinedRange = tableA.range * tableB.range;
+    const values = new Uint8Array(combinedRange);
+    values.fill(255);
+    const solvedCoordinate = tableA.solvedCoordinate * tableB.range + tableB.solvedCoordinate;
+    values[solvedCoordinate] = 0;
+    const queue = new Int32Array(combinedRange);
+    let read = 0;
+    let write = 1;
+    queue[0] = solvedCoordinate;
+    let maxDepth = 0;
+    while (read < write) {
+        const current = queue[read];
+        read += 1;
+        const nextDepth = values[current] + 1;
+        const currentA = Math.floor(current / tableB.range);
+        const currentB = current % tableB.range;
+        for (let moveIndex = 0; moveIndex < tableA.moves.length; moveIndex += 1) {
+            const nextA = tableA.values[currentA * tableA.moves.length + moveIndex];
+            const nextB = tableB.values[currentB * tableB.moves.length + moveIndex];
+            const next = nextA * tableB.range + nextB;
+            if (values[next] !== 255) {
+                continue;
+            }
+            values[next] = nextDepth;
+            maxDepth = Math.max(maxDepth, nextDepth);
+            queue[write] = next;
+            write += 1;
+        }
+    }
+    const combinedName = `${tableA.coordinate}${tableB.coordinate.charAt(0).toUpperCase() + tableB.coordinate.slice(1)}`;
+    return {
+        coordinate: combinedName,
+        moves: tableA.moves,
+        range: combinedRange,
+        values,
+        checksum: checksum(values),
+        maxDepth
+    };
+}
+function lookupCube3MoveTable(table, coordinate, move) {
+    const moveIndex = table.moves.indexOf(move);
+    if (moveIndex === -1) {
+        throw new RangeError(`Move ${move} is not part of ${table.coordinate} table.`);
+    }
+    return table.values[coordinate * table.moves.length + moveIndex];
+}
+function checksum(values) {
+    let hash = 0x811c9dc5;
+    for (let index = 0; index < values.length; index += 1) {
+        hash ^= values[index];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSolvedCube3State = createSolvedCube3State;
+exports.cloneCube3State = cloneCube3State;
+exports.cube3StatesEqual = cube3StatesEqual;
+exports.isSolvedCube3State = isSolvedCube3State;
+const types_js_1 = require("./types.js");
+function createSolvedCube3State() {
+    return {
+        corners: {
+            permutation: range(types_js_1.CORNER_COUNT),
+            orientation: Array(types_js_1.CORNER_COUNT).fill(0)
+        },
+        edges: {
+            permutation: range(types_js_1.EDGE_COUNT),
+            orientation: Array(types_js_1.EDGE_COUNT).fill(0)
+        }
+    };
+}
+function cloneCube3State(state) {
+    return {
+        corners: {
+            permutation: [...state.corners.permutation],
+            orientation: [...state.corners.orientation]
+        },
+        edges: {
+            permutation: [...state.edges.permutation],
+            orientation: [...state.edges.orientation]
+        }
+    };
+}
+function cube3StatesEqual(left, right) {
+    return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
+        arraysEqual(left.corners.orientation, right.corners.orientation) &&
+        arraysEqual(left.edges.permutation, right.edges.permutation) &&
+        arraysEqual(left.edges.orientation, right.edges.orientation));
+}
+function isSolvedCube3State(state) {
+    return cube3StatesEqual(state, createSolvedCube3State());
+}
+function range(length) {
+    return Array.from({ length }, (_, index) => index);
+}
+function arraysEqual(left, right) {
+    return left.length === right.length && left.every((value, index) => value === right[index]);
+}