@cubingcenter/scrambler 0.1.0

package/dist-cjs/puzzles/cube2/solver/generated/manifest.json

@@ -0,0 +1,21 @@
+{
+  "version": 1,
+  "files": {
+    "permutationTable": {
+      "file": "permutation-table.bin",
+      "entries": 45360,
+      "checksum": 1683412725
+    },
+    "orientationTable": {
+      "file": "orientation-table.bin",
+      "entries": 6561,
+      "checksum": 1566738619
+    },
+    "distances": {
+      "file": "distances.bin",
+      "entries": 1837080,
+      "checksum": 2959532459,
+      "maxDepth": 11
+    }
+  }
+}

package/dist-cjs/puzzles/cube2/solver/generated-assets.js

@@ -0,0 +1,61 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadGeneratedCube2SolverTables = loadGeneratedCube2SolverTables;
+const browser_loader_js_1 = require("./browser-loader.js");
+let cachedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+async function loadGeneratedCube2SolverTables() {
+    if (isBrowser()) {
+        const browserTables = (0, browser_loader_js_1.getCachedBrowserTables)();
+        if (browserTables) {
+            return browserTables;
+        }
+        throw new Error("2x2 solver tables are not loaded. " +
+            "In browser environments, call `initializeScrambler(baseUrl)` " +
+            "before generating scrambles.");
+    }
+    cachedTables ??= await loadNodeTables();
+    return cachedTables;
+}
+async function loadNodeTables() {
+    const loader = await Promise.resolve().then(() => __importStar(require(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./node-loader.js")));
+    return loader.readGeneratedCube2SolverTables();
+}

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

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveCube2State = void 0;
+var search_js_1 = require("./search.js");
+Object.defineProperty(exports, "solveCube2State", { enumerable: true, get: function () { return search_js_1.solveCube2State; } });

package/dist-cjs/puzzles/cube2/solver/node-loader.js

@@ -0,0 +1,89 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readGeneratedCube2SolverTables = readGeneratedCube2SolverTables;
+const node_fs_1 = require("node:fs");
+const node_module_1 = require("node:module");
+const node_path_1 = __importDefault(require("node:path"));
+const table_metadata_js_1 = require("./table-metadata.js");
+const GENERATED_DIRECTORY = "puzzles/cube2/solver/generated";
+function readGeneratedCube2SolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = JSON.parse((0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, "manifest.json"), "utf8"));
+    if (manifest.version !== 1) {
+        throw new Error(`Unsupported cube2 solver table manifest version: ${manifest.version}`);
+    }
+    const permutationTable = readUint16Table(assetDirectory, manifest.files.permutationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.permutationTable.checksum);
+    const orientationTable = readUint16Table(assetDirectory, manifest.files.orientationTable, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.orientationTable.checksum);
+    const distances = readUint8Table(assetDirectory, manifest.files.distances, table_metadata_js_1.CUBE2_SOLVER_TABLE_METADATA.distances.checksum);
+    return {
+        permutationTable,
+        orientationTable,
+        distances
+    };
+}
+function readUint16Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(entry.entries);
+    for (let index = 0; index < values.length; index += 1) {
+        values[index] = buffer.readUInt16LE(index * 2);
+    }
+    assertChecksum(entry.file, checksum(values), expectedChecksum);
+    return values;
+}
+function readUint8Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = (0, node_fs_1.readFileSync)(node_path_1.default.join(assetDirectory, entry.file));
+    if (buffer.length !== entry.entries) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint8Array(buffer);
+    assertChecksum(entry.file, checksum(values), expectedChecksum);
+    return values;
+}
+function resolveGeneratedAssetDirectory() {
+    const envDirectory = process.env.CUBINGCENTER_SCRAMBLER_TABLES_DIR;
+    if (envDirectory && (0, node_fs_1.existsSync)(node_path_1.default.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if ((0, node_fs_1.existsSync)(node_path_1.default.join(candidate, "manifest.json"))) {
+            return candidate;
+        }
+    }
+    throw new Error("Unable to find generated 2x2 solver tables. Run pnpm cube2:tables.");
+}
+function getAssetDirectoryCandidates() {
+    const cwd = process.cwd();
+    const candidates = [
+        node_path_1.default.join(cwd, "src", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist", GENERATED_DIRECTORY),
+        node_path_1.default.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = (0, node_module_1.createRequire)(node_path_1.default.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(node_path_1.default.join(node_path_1.default.dirname(packageEntry), GENERATED_DIRECTORY));
+    }
+    catch {
+        // Source-tree usage is covered by the cwd candidates.
+    }
+    return candidates;
+}
+function assertChecksum(file, actual, expected) {
+    if (actual !== expected) {
+        throw new Error(`Checksum mismatch for ${file}: expected ${expected}, received ${actual}.`);
+    }
+}
+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/cube2/solver/search.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solveCube2State = solveCube2State;
+const state_js_1 = require("../state.js");
+const tables_js_1 = require("./tables.js");
+async function solveCube2State(state) {
+    await (0, tables_js_1.ensureTablesLoaded)();
+    if (state.corners.permutation[6] !== 6 || state.corners.orientation[6] !== 0) {
+        throw new Error("The 2x2 solver requires the DBL corner (index 6) to be solved " +
+            "as the frame of reference. Please normalize the state before solving.");
+    }
+    const permTable = tables_js_1.PERMUTATION_TABLE;
+    const orientTable = tables_js_1.ORIENTATION_TABLE;
+    const distances = tables_js_1.DISTANCES;
+    let permIndex = (0, tables_js_1.encodePermutation)(state.corners.permutation);
+    let orientIndex = (0, tables_js_1.encodeOrientation)(state.corners.orientation);
+    const moves = [];
+    // High-performance branchless inlined lookup
+    const initialCombined = permIndex * tables_js_1.ORIENTATION_COUNT + orientIndex;
+    let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
+    if (distance === 0) {
+        return { moves, depth: 0, state: (0, state_js_1.createSolvedCube2State)() };
+    }
+    while (distance > 0) {
+        let foundNext = false;
+        const permOffset = permIndex * tables_js_1.MOVE_COUNT;
+        const orientOffset = orientIndex * tables_js_1.MOVE_COUNT;
+        const nextDistance = distance - 1;
+        for (let m = 0; m < tables_js_1.BFS_MOVES.length; m++) {
+            const nextPerm = permTable[permOffset + m];
+            const nextOrient = orientTable[orientOffset + m];
+            // High-performance branchless inlined lookup
+            const combined = nextPerm * tables_js_1.ORIENTATION_COUNT + nextOrient;
+            const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+            if (nextDist === nextDistance) {
+                moves.push(tables_js_1.BFS_MOVES[m]);
+                permIndex = nextPerm;
+                orientIndex = nextOrient;
+                distance = nextDistance;
+                foundNext = true;
+                break;
+            }
+        }
+        if (!foundNext) {
+            throw new Error("BFS distance table corrupted or unreachable state.");
+        }
+    }
+    return {
+        moves,
+        depth: moves.length,
+        state: (0, state_js_1.createSolvedCube2State)()
+    };
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUBE2_SOLVER_TABLE_METADATA = void 0;
+exports.CUBE2_SOLVER_TABLE_METADATA = {
+    permutationTable: {
+        entries: 45360,
+        checksum: 1683412725
+    },
+    orientationTable: {
+        entries: 6561,
+        checksum: 1566738619
+    },
+    distances: {
+        entries: 1837080,
+        checksum: 2959532459,
+        maxDepth: 11
+    }
+};

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

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BFS_MOVES = exports.DISTANCES = exports.ORIENTATION_TABLE = exports.PERMUTATION_TABLE = exports.MOVE_COUNT = exports.ORIENTATION_COUNT = exports.PERMUTATION_COUNT = void 0;
+exports.encodePermutation = encodePermutation;
+exports.encodeOrientation = encodeOrientation;
+exports.ensureTablesLoaded = ensureTablesLoaded;
+exports.getDistance = getDistance;
+exports.getPermutationTransition = getPermutationTransition;
+exports.getOrientationTransition = getOrientationTransition;
+const generated_assets_js_1 = require("./generated-assets.js");
+exports.PERMUTATION_COUNT = 5040;
+exports.ORIENTATION_COUNT = 729;
+exports.MOVE_COUNT = 9;
+// ---------------------------------------------------------------------------
+// Coordinate encoding / decoding
+// ---------------------------------------------------------------------------
+function encodePermutation(permutation) {
+    const perm7 = permutation.filter((_, i) => i !== 6);
+    const mapped = perm7.map((x) => (x > 6 ? x - 1 : x));
+    let index = 0;
+    const available = [0, 1, 2, 3, 4, 5, 6];
+    for (let position = 0; position < 7; position += 1) {
+        const value = mapped[position];
+        const selected = available.indexOf(value);
+        index += selected * factorialSmall(6 - position);
+        available.splice(selected, 1);
+    }
+    return index;
+}
+function encodeOrientation(orientation) {
+    const orient7 = orientation.filter((_, i) => i !== 6);
+    let index = 0;
+    let multiplier = 1;
+    for (let position = 5; position >= 0; position -= 1) {
+        index += orient7[position] * multiplier;
+        multiplier *= 3;
+    }
+    return index;
+}
+function factorialSmall(n) {
+    let result = 1;
+    for (let i = 2; i <= n; i += 1) {
+        result *= i;
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// Table loading
+// ---------------------------------------------------------------------------
+let tablesLoaded = false;
+exports.PERMUTATION_TABLE = null;
+exports.ORIENTATION_TABLE = null;
+exports.DISTANCES = null;
+async function ensureTablesLoaded() {
+    if (tablesLoaded) {
+        return;
+    }
+    const tables = await (0, generated_assets_js_1.loadGeneratedCube2SolverTables)();
+    exports.PERMUTATION_TABLE = tables.permutationTable;
+    exports.ORIENTATION_TABLE = tables.orientationTable;
+    exports.DISTANCES = tables.distances;
+    tablesLoaded = true;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+function getDistance(permIndex, orientIndex) {
+    if (!exports.DISTANCES) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    const combined = permIndex * exports.ORIENTATION_COUNT + orientIndex;
+    const byteValue = exports.DISTANCES[combined >> 1];
+    return (combined & 1) === 0 ? (byteValue & 0x0f) : (byteValue >> 4);
+}
+function getPermutationTransition(move, permIndex) {
+    if (!exports.PERMUTATION_TABLE) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return exports.PERMUTATION_TABLE[permIndex * exports.MOVE_COUNT + move];
+}
+function getOrientationTransition(move, orientIndex) {
+    if (!exports.ORIENTATION_TABLE) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return exports.ORIENTATION_TABLE[orientIndex * exports.MOVE_COUNT + move];
+}
+exports.BFS_MOVES = [
+    "U", "U2", "U'",
+    "R", "R2", "R'",
+    "F", "F2", "F'"
+];

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

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSolvedCube2State = createSolvedCube2State;
+exports.cloneCube2State = cloneCube2State;
+exports.cube2StatesEqual = cube2StatesEqual;
+exports.isSolvedCube2State = isSolvedCube2State;
+const types_js_1 = require("./types.js");
+function createSolvedCube2State() {
+    return {
+        corners: {
+            permutation: range(types_js_1.CORNER_COUNT),
+            orientation: Array(types_js_1.CORNER_COUNT).fill(0)
+        }
+    };
+}
+function cloneCube2State(state) {
+    return {
+        corners: {
+            permutation: [...state.corners.permutation],
+            orientation: [...state.corners.orientation]
+        }
+    };
+}
+function cube2StatesEqual(left, right) {
+    return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
+        arraysEqual(left.corners.orientation, right.corners.orientation));
+}
+function isSolvedCube2State(state) {
+    return cube2StatesEqual(state, createSolvedCube2State());
+}
+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]);
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CUBE2_MOVES = exports.CORNER_COUNT = void 0;
+exports.CORNER_COUNT = 8;
+exports.CUBE2_MOVES = [
+    "U",
+    "U2",
+    "U'",
+    "D",
+    "D2",
+    "D'",
+    "R",
+    "R2",
+    "R'",
+    "L",
+    "L2",
+    "L'",
+    "F",
+    "F2",
+    "F'",
+    "B",
+    "B2",
+    "B'"
+];

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

@@ -0,0 +1,78 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCube2State = validateCube2State;
+exports.isOneMoveFromSolvedCube2State = isOneMoveFromSolvedCube2State;
+exports.isAllowedRandomCube2State = isAllowedRandomCube2State;
+exports.permutationParity = permutationParity;
+const types_js_1 = require("./types.js");
+const moves_js_1 = require("./moves.js");
+const state_js_1 = require("./state.js");
+function validateCube2State(state) {
+    const errors = [
+        ...validatePermutation("corner", state.corners.permutation, types_js_1.CORNER_COUNT),
+        ...validateOrientations("corner", state.corners.orientation, types_js_1.CORNER_COUNT, 3)
+    ];
+    if (errors.length === 0) {
+        const cornerOrientation = sum(state.corners.orientation) % 3;
+        if (cornerOrientation !== 0) {
+            errors.push("Corner orientation sum must be divisible by 3.");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+function isOneMoveFromSolvedCube2State(state) {
+    const solved = (0, state_js_1.createSolvedCube2State)();
+    return types_js_1.CUBE2_MOVES.some((move) => (0, state_js_1.cube2StatesEqual)((0, moves_js_1.applyCube2Move)(solved, move), state));
+}
+function isAllowedRandomCube2State(state) {
+    return validateCube2State(state).valid &&
+        !(0, state_js_1.isSolvedCube2State)(state) &&
+        !isOneMoveFromSolvedCube2State(state);
+}
+function permutationParity(permutation) {
+    let inversions = 0;
+    for (let left = 0; left < permutation.length; left += 1) {
+        for (let right = left + 1; right < permutation.length; right += 1) {
+            if (permutation[left] > permutation[right]) {
+                inversions += 1;
+            }
+        }
+    }
+    return (inversions % 2);
+}
+function validatePermutation(label, permutation, length) {
+    const errors = [];
+    const seen = new Set();
+    if (permutation.length !== length) {
+        errors.push(`${label} permutation must contain ${length} values.`);
+    }
+    for (const value of permutation) {
+        if (!Number.isInteger(value) || value < 0 || value >= length) {
+            errors.push(`${label} permutation contains out-of-range value: ${value}.`);
+            continue;
+        }
+        if (seen.has(value)) {
+            errors.push(`${label} permutation contains duplicate value: ${value}.`);
+        }
+        seen.add(value);
+    }
+    return errors;
+}
+function validateOrientations(label, orientations, length, modulo) {
+    const errors = [];
+    if (orientations.length !== length) {
+        errors.push(`${label} orientation must contain ${length} values.`);
+    }
+    for (const value of orientations) {
+        if (!Number.isInteger(value) || value < 0 || value >= modulo) {
+            errors.push(`${label} orientation contains out-of-range value: ${value}.`);
+        }
+    }
+    return errors;
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}

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

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCube3Facelets = toCube3Facelets;
+exports.formatCube3Facelets = formatCube3Facelets;
+exports.getCube3FaceOrder = getCube3FaceOrder;
+const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const CORNER_PIECE_STICKERS = [
+    ["U", "R", "F"],
+    ["U", "F", "L"],
+    ["U", "L", "B"],
+    ["U", "B", "R"],
+    ["D", "F", "R"],
+    ["D", "L", "F"],
+    ["D", "B", "L"],
+    ["D", "R", "B"]
+];
+const CORNER_POSITION_SLOTS = [
+    [["U", 8], ["R", 0], ["F", 2]],
+    [["U", 6], ["F", 0], ["L", 2]],
+    [["U", 0], ["L", 0], ["B", 2]],
+    [["U", 2], ["B", 0], ["R", 2]],
+    [["D", 2], ["F", 8], ["R", 6]],
+    [["D", 0], ["L", 8], ["F", 6]],
+    [["D", 6], ["B", 8], ["L", 6]],
+    [["D", 8], ["R", 8], ["B", 6]]
+];
+const EDGE_PIECE_STICKERS = [
+    ["U", "R"],
+    ["U", "F"],
+    ["U", "L"],
+    ["U", "B"],
+    ["D", "R"],
+    ["D", "F"],
+    ["D", "L"],
+    ["D", "B"],
+    ["F", "R"],
+    ["F", "L"],
+    ["B", "L"],
+    ["B", "R"]
+];
+const EDGE_POSITION_SLOTS = [
+    [["U", 5], ["R", 1]],
+    [["U", 7], ["F", 1]],
+    [["U", 3], ["L", 1]],
+    [["U", 1], ["B", 1]],
+    [["D", 5], ["R", 7]],
+    [["D", 1], ["F", 7]],
+    [["D", 3], ["L", 7]],
+    [["D", 7], ["B", 7]],
+    [["F", 5], ["R", 3]],
+    [["F", 3], ["L", 5]],
+    [["B", 5], ["L", 3]],
+    [["B", 3], ["R", 5]]
+];
+function toCube3Facelets(state) {
+    const facelets = createEmptyFacelets();
+    for (const face of FACE_ORDER) {
+        facelets[face][4] = face;
+    }
+    for (let position = 0; position < CORNER_POSITION_SLOTS.length; position += 1) {
+        const piece = state.corners.permutation[position];
+        const orientation = state.corners.orientation[position];
+        placeOrientedStickers(facelets, CORNER_POSITION_SLOTS[position], CORNER_PIECE_STICKERS[piece], orientation);
+    }
+    for (let position = 0; position < EDGE_POSITION_SLOTS.length; position += 1) {
+        const piece = state.edges.permutation[position];
+        const orientation = state.edges.orientation[position];
+        placeOrientedStickers(facelets, EDGE_POSITION_SLOTS[position], EDGE_PIECE_STICKERS[piece], orientation);
+    }
+    return facelets;
+}
+function formatCube3Facelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+function getCube3FaceOrder() {
+    return FACE_ORDER;
+}
+function createEmptyFacelets() {
+    return {
+        U: Array(9).fill("U"),
+        R: Array(9).fill("R"),
+        F: Array(9).fill("F"),
+        D: Array(9).fill("D"),
+        L: Array(9).fill("L"),
+        B: Array(9).fill("B")
+    };
+}
+function placeOrientedStickers(facelets, slots, stickers, orientation) {
+    for (let index = 0; index < slots.length; index += 1) {
+        const [face, stickerIndex] = slots[index];
+        const sticker = stickers[(index - orientation + stickers.length) % stickers.length];
+        facelets[face][stickerIndex] = sticker;
+    }
+}

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

@@ -0,0 +1,68 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.solver = exports.toCube3Facelets = exports.getCube3FaceOrder = exports.formatCube3Facelets = exports.generateCube3Scramble = exports.cube3ScrambleGenerator = exports.generateRandomCube3State = exports.validateCube3State = exports.permutationParity = exports.isOneMoveFromSolvedCube3State = exports.isAllowedRandomCube3State = exports.isSolvedCube3State = exports.cube3StatesEqual = exports.createSolvedCube3State = exports.cloneCube3State = exports.parseCube3Move = exports.parseCube3Algorithm = exports.invertCube3Move = exports.invertCube3Algorithm = exports.formatCube3Algorithm = exports.applyCube3Move = exports.applyCube3Algorithm = exports.EDGE_COUNT = exports.CORNER_COUNT = exports.CUBE3_MOVES = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "CUBE3_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE3_MOVES; } });
+Object.defineProperty(exports, "CORNER_COUNT", { enumerable: true, get: function () { return types_js_1.CORNER_COUNT; } });
+Object.defineProperty(exports, "EDGE_COUNT", { enumerable: true, get: function () { return types_js_1.EDGE_COUNT; } });
+var moves_js_1 = require("./moves.js");
+Object.defineProperty(exports, "applyCube3Algorithm", { enumerable: true, get: function () { return moves_js_1.applyCube3Algorithm; } });
+Object.defineProperty(exports, "applyCube3Move", { enumerable: true, get: function () { return moves_js_1.applyCube3Move; } });
+Object.defineProperty(exports, "formatCube3Algorithm", { enumerable: true, get: function () { return moves_js_1.formatCube3Algorithm; } });
+Object.defineProperty(exports, "invertCube3Algorithm", { enumerable: true, get: function () { return moves_js_1.invertCube3Algorithm; } });
+Object.defineProperty(exports, "invertCube3Move", { enumerable: true, get: function () { return moves_js_1.invertCube3Move; } });
+Object.defineProperty(exports, "parseCube3Algorithm", { enumerable: true, get: function () { return moves_js_1.parseCube3Algorithm; } });
+Object.defineProperty(exports, "parseCube3Move", { enumerable: true, get: function () { return moves_js_1.parseCube3Move; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "cloneCube3State", { enumerable: true, get: function () { return state_js_1.cloneCube3State; } });
+Object.defineProperty(exports, "createSolvedCube3State", { enumerable: true, get: function () { return state_js_1.createSolvedCube3State; } });
+Object.defineProperty(exports, "cube3StatesEqual", { enumerable: true, get: function () { return state_js_1.cube3StatesEqual; } });
+Object.defineProperty(exports, "isSolvedCube3State", { enumerable: true, get: function () { return state_js_1.isSolvedCube3State; } });
+var validation_js_1 = require("./validation.js");
+Object.defineProperty(exports, "isAllowedRandomCube3State", { enumerable: true, get: function () { return validation_js_1.isAllowedRandomCube3State; } });
+Object.defineProperty(exports, "isOneMoveFromSolvedCube3State", { enumerable: true, get: function () { return validation_js_1.isOneMoveFromSolvedCube3State; } });
+Object.defineProperty(exports, "permutationParity", { enumerable: true, get: function () { return validation_js_1.permutationParity; } });
+Object.defineProperty(exports, "validateCube3State", { enumerable: true, get: function () { return validation_js_1.validateCube3State; } });
+var random_state_js_1 = require("./random-state.js");
+Object.defineProperty(exports, "generateRandomCube3State", { enumerable: true, get: function () { return random_state_js_1.generateRandomCube3State; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "cube3ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube3ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube3Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube3Scramble; } });
+var facelets_js_1 = require("./facelets.js");
+Object.defineProperty(exports, "formatCube3Facelets", { enumerable: true, get: function () { return facelets_js_1.formatCube3Facelets; } });
+Object.defineProperty(exports, "getCube3FaceOrder", { enumerable: true, get: function () { return facelets_js_1.getCube3FaceOrder; } });
+Object.defineProperty(exports, "toCube3Facelets", { enumerable: true, get: function () { return facelets_js_1.toCube3Facelets; } });
+exports.solver = __importStar(require("./solver/index.js"));