@cubingcenter/scrambler 0.1.0

package/dist/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/puzzles/cube2/solver/generated-assets.d.ts

@@ -0,0 +1,6 @@
+export declare function loadGeneratedCube2SolverTables(): Promise<{
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    distances: Uint8Array;
+}>;
+//# sourceMappingURL=generated-assets.d.ts.map

package/dist/puzzles/cube2/solver/generated-assets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generated-assets.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/generated-assets.ts"],"names":[],"mappings":"AAYA,wBAAsB,8BAA8B,IAAI,OAAO,CAAC;IAC9D,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAAC,CAeD"}

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

@@ -0,0 +1,25 @@
+import { getCachedBrowserTables } from "./browser-loader.js";
+let cachedTables;
+function isBrowser() {
+    return typeof self !== "undefined";
+}
+export async function loadGeneratedCube2SolverTables() {
+    if (isBrowser()) {
+        const browserTables = 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 import(
+    /* webpackIgnore: true */
+    /* @vite-ignore */
+    "./node-loader.js");
+    return loader.readGeneratedCube2SolverTables();
+}

package/dist/puzzles/cube2/solver/index.d.ts

@@ -0,0 +1,3 @@
+export { solveCube2State } from "./search.js";
+export type { Cube2Solution } from "./search.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/puzzles/cube2/solver/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAC9C,YAAY,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC"}

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

@@ -0,0 +1 @@
+export { solveCube2State } from "./search.js";

package/dist/puzzles/cube2/solver/node-loader.d.ts

@@ -0,0 +1,6 @@
+export declare function readGeneratedCube2SolverTables(): {
+    permutationTable: Uint16Array;
+    orientationTable: Uint16Array;
+    distances: Uint8Array;
+};
+//# sourceMappingURL=node-loader.d.ts.map

package/dist/puzzles/cube2/solver/node-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/node-loader.ts"],"names":[],"mappings":"AAgBA,wBAAgB,8BAA8B,IAAI;IAChD,gBAAgB,EAAE,WAAW,CAAC;IAC9B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,SAAS,EAAE,UAAU,CAAC;CACvB,CAmBA"}

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

@@ -0,0 +1,83 @@
+import { existsSync, readFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { CUBE2_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+const GENERATED_DIRECTORY = "puzzles/cube2/solver/generated";
+export function readGeneratedCube2SolverTables() {
+    const assetDirectory = resolveGeneratedAssetDirectory();
+    const manifest = JSON.parse(readFileSync(path.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, CUBE2_SOLVER_TABLE_METADATA.permutationTable.checksum);
+    const orientationTable = readUint16Table(assetDirectory, manifest.files.orientationTable, CUBE2_SOLVER_TABLE_METADATA.orientationTable.checksum);
+    const distances = readUint8Table(assetDirectory, manifest.files.distances, CUBE2_SOLVER_TABLE_METADATA.distances.checksum);
+    return {
+        permutationTable,
+        orientationTable,
+        distances
+    };
+}
+function readUint16Table(assetDirectory, entry, expectedChecksum) {
+    const buffer = readFileSync(path.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 = readFileSync(path.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 && existsSync(path.join(envDirectory, "manifest.json"))) {
+        return envDirectory;
+    }
+    for (const candidate of getAssetDirectoryCandidates()) {
+        if (existsSync(path.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 = [
+        path.join(cwd, "src", GENERATED_DIRECTORY),
+        path.join(cwd, "dist", GENERATED_DIRECTORY),
+        path.join(cwd, "dist-cjs", GENERATED_DIRECTORY)
+    ];
+    try {
+        const requireFromCwd = createRequire(path.join(cwd, "package.json"));
+        const packageEntry = requireFromCwd.resolve("@cubingcenter/scrambler");
+        candidates.push(path.join(path.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/puzzles/cube2/solver/search.d.ts

@@ -0,0 +1,8 @@
+import type { Cube2Move, Cube2State } from "../types.js";
+export interface Cube2Solution {
+    moves: Cube2Move[];
+    depth: number;
+    state: Cube2State;
+}
+export declare function solveCube2State(state: Cube2State): Promise<Cube2Solution>;
+//# sourceMappingURL=search.d.ts.map

package/dist/puzzles/cube2/solver/search.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"search.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/search.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAczD,MAAM,WAAW,aAAa;IAC5B,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,KAAK,EAAE,MAAM,CAAC;IACd,KAAK,EAAE,UAAU,CAAC;CACnB;AAED,wBAAsB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAAC,aAAa,CAAC,CA6D/E"}

package/dist/puzzles/cube2/solver/search.js

@@ -0,0 +1,50 @@
+import { createSolvedCube2State } from "../state.js";
+import { encodeOrientation, encodePermutation, ensureTablesLoaded, PERMUTATION_TABLE, ORIENTATION_TABLE, DISTANCES, ORIENTATION_COUNT, BFS_MOVES, MOVE_COUNT } from "./tables.js";
+export async function solveCube2State(state) {
+    await 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 = PERMUTATION_TABLE;
+    const orientTable = ORIENTATION_TABLE;
+    const distances = DISTANCES;
+    let permIndex = encodePermutation(state.corners.permutation);
+    let orientIndex = encodeOrientation(state.corners.orientation);
+    const moves = [];
+    // High-performance branchless inlined lookup
+    const initialCombined = permIndex * ORIENTATION_COUNT + orientIndex;
+    let distance = (distances[initialCombined >> 1] >> ((initialCombined & 1) << 2)) & 0x0f;
+    if (distance === 0) {
+        return { moves, depth: 0, state: createSolvedCube2State() };
+    }
+    while (distance > 0) {
+        let foundNext = false;
+        const permOffset = permIndex * MOVE_COUNT;
+        const orientOffset = orientIndex * MOVE_COUNT;
+        const nextDistance = distance - 1;
+        for (let m = 0; m < BFS_MOVES.length; m++) {
+            const nextPerm = permTable[permOffset + m];
+            const nextOrient = orientTable[orientOffset + m];
+            // High-performance branchless inlined lookup
+            const combined = nextPerm * ORIENTATION_COUNT + nextOrient;
+            const nextDist = (distances[combined >> 1] >> ((combined & 1) << 2)) & 0x0f;
+            if (nextDist === nextDistance) {
+                moves.push(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: createSolvedCube2State()
+    };
+}

package/dist/puzzles/cube2/solver/table-metadata.d.ts

@@ -0,0 +1,16 @@
+export declare const CUBE2_SOLVER_TABLE_METADATA: {
+    readonly permutationTable: {
+        readonly entries: 45360;
+        readonly checksum: 1683412725;
+    };
+    readonly orientationTable: {
+        readonly entries: 6561;
+        readonly checksum: 1566738619;
+    };
+    readonly distances: {
+        readonly entries: 1837080;
+        readonly checksum: 2959532459;
+        readonly maxDepth: 11;
+    };
+};
+//# sourceMappingURL=table-metadata.d.ts.map

package/dist/puzzles/cube2/solver/table-metadata.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"table-metadata.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/table-metadata.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,2BAA2B;;;;;;;;;;;;;;CAc9B,CAAC"}

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

@@ -0,0 +1,15 @@
+export const CUBE2_SOLVER_TABLE_METADATA = {
+    permutationTable: {
+        entries: 45360,
+        checksum: 1683412725
+    },
+    orientationTable: {
+        entries: 6561,
+        checksum: 1566738619
+    },
+    distances: {
+        entries: 1837080,
+        checksum: 2959532459,
+        maxDepth: 11
+    }
+};

package/dist/puzzles/cube2/solver/tables.d.ts

@@ -0,0 +1,14 @@
+export declare const PERMUTATION_COUNT = 5040;
+export declare const ORIENTATION_COUNT = 729;
+export declare const MOVE_COUNT = 9;
+export declare function encodePermutation(permutation: readonly number[]): number;
+export declare function encodeOrientation(orientation: readonly number[]): number;
+export declare let PERMUTATION_TABLE: Uint16Array | null;
+export declare let ORIENTATION_TABLE: Uint16Array | null;
+export declare let DISTANCES: Uint8Array | null;
+export declare function ensureTablesLoaded(): Promise<void>;
+export declare function getDistance(permIndex: number, orientIndex: number): number;
+export declare function getPermutationTransition(move: number, permIndex: number): number;
+export declare function getOrientationTransition(move: number, orientIndex: number): number;
+export declare const BFS_MOVES: readonly string[];
+//# sourceMappingURL=tables.d.ts.map

package/dist/puzzles/cube2/solver/tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/cube2/solver/tables.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,iBAAiB,OAAO,CAAC;AACtC,eAAO,MAAM,iBAAiB,MAAM,CAAC;AACrC,eAAO,MAAM,UAAU,IAAI,CAAC;AAM5B,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAexE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAWxE;AAeD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,iBAAiB,EAAE,WAAW,GAAG,IAAW,CAAC;AACxD,eAAO,IAAI,SAAS,EAAE,UAAU,GAAG,IAAW,CAAC;AAE/C,wBAAsB,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC,CAUxD;AAMD,wBAAgB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAO1E;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAKhF;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKlF;AAED,eAAO,MAAM,SAAS,EAAE,SAAS,MAAM,EAItC,CAAC"}

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

@@ -0,0 +1,82 @@
+import { loadGeneratedCube2SolverTables } from "./generated-assets.js";
+export const PERMUTATION_COUNT = 5040;
+export const ORIENTATION_COUNT = 729;
+export const MOVE_COUNT = 9;
+// ---------------------------------------------------------------------------
+// Coordinate encoding / decoding
+// ---------------------------------------------------------------------------
+export 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;
+}
+export 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;
+export let PERMUTATION_TABLE = null;
+export let ORIENTATION_TABLE = null;
+export let DISTANCES = null;
+export async function ensureTablesLoaded() {
+    if (tablesLoaded) {
+        return;
+    }
+    const tables = await loadGeneratedCube2SolverTables();
+    PERMUTATION_TABLE = tables.permutationTable;
+    ORIENTATION_TABLE = tables.orientationTable;
+    DISTANCES = tables.distances;
+    tablesLoaded = true;
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+export function getDistance(permIndex, orientIndex) {
+    if (!DISTANCES) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    const combined = permIndex * ORIENTATION_COUNT + orientIndex;
+    const byteValue = DISTANCES[combined >> 1];
+    return (combined & 1) === 0 ? (byteValue & 0x0f) : (byteValue >> 4);
+}
+export function getPermutationTransition(move, permIndex) {
+    if (!PERMUTATION_TABLE) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return PERMUTATION_TABLE[permIndex * MOVE_COUNT + move];
+}
+export function getOrientationTransition(move, orientIndex) {
+    if (!ORIENTATION_TABLE) {
+        throw new Error("Cube2 solver tables not loaded. Call ensureTablesLoaded() first.");
+    }
+    return ORIENTATION_TABLE[orientIndex * MOVE_COUNT + move];
+}
+export const BFS_MOVES = [
+    "U", "U2", "U'",
+    "R", "R2", "R'",
+    "F", "F2", "F'"
+];

package/dist/puzzles/cube2/state.d.ts

@@ -0,0 +1,6 @@
+import type { Cube2State } from "./types.js";
+export declare function createSolvedCube2State(): Cube2State;
+export declare function cloneCube2State(state: Cube2State): Cube2State;
+export declare function cube2StatesEqual(left: Cube2State, right: Cube2State): boolean;
+export declare function isSolvedCube2State(state: Cube2State): boolean;
+//# sourceMappingURL=state.d.ts.map

package/dist/puzzles/cube2/state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAC;AAE7C,wBAAgB,sBAAsB,IAAI,UAAU,CAOnD;AAED,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,CAO7D;AAED,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,EAAE,UAAU,GAAG,OAAO,CAK7E;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAE7D"}

package/dist/puzzles/cube2/state.js

@@ -0,0 +1,30 @@
+import { CORNER_COUNT } from "./types.js";
+export function createSolvedCube2State() {
+    return {
+        corners: {
+            permutation: range(CORNER_COUNT),
+            orientation: Array(CORNER_COUNT).fill(0)
+        }
+    };
+}
+export function cloneCube2State(state) {
+    return {
+        corners: {
+            permutation: [...state.corners.permutation],
+            orientation: [...state.corners.orientation]
+        }
+    };
+}
+export function cube2StatesEqual(left, right) {
+    return (arraysEqual(left.corners.permutation, right.corners.permutation) &&
+        arraysEqual(left.corners.orientation, right.corners.orientation));
+}
+export 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/puzzles/cube2/types.d.ts

@@ -0,0 +1,23 @@
+export declare const CORNER_COUNT = 8;
+export type Cube2FaceMove = "U" | "D" | "R" | "L" | "F" | "B";
+export type Cube2Face = "U" | "R" | "F" | "D" | "L" | "B";
+export type Cube2Sticker = Cube2Face;
+export type Cube2MoveSuffix = "" | "2" | "'";
+export type Cube2Move = `${Cube2FaceMove}${Cube2MoveSuffix}`;
+export interface Cube2State {
+    corners: {
+        permutation: number[];
+        orientation: number[];
+    };
+}
+export interface Cube2ValidationResult {
+    valid: boolean;
+    errors: string[];
+}
+export interface Cube2RandomStateOptions {
+    seed?: string | number;
+    rejectTrivial?: boolean;
+}
+export type Cube2Facelets = Record<Cube2Face, Cube2Sticker[]>;
+export declare const CUBE2_MOVES: readonly Cube2Move[];
+//# sourceMappingURL=types.d.ts.map

package/dist/puzzles/cube2/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/types.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY,IAAI,CAAC;AAE9B,MAAM,MAAM,aAAa,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAC9D,MAAM,MAAM,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,CAAC;AAC1D,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC;AACrC,MAAM,MAAM,eAAe,GAAG,EAAE,GAAG,GAAG,GAAG,GAAG,CAAC;AAC7C,MAAM,MAAM,SAAS,GAAG,GAAG,aAAa,GAAG,eAAe,EAAE,CAAC;AAE7D,MAAM,WAAW,UAAU;IACzB,OAAO,EAAE;QACP,WAAW,EAAE,MAAM,EAAE,CAAC;QACtB,WAAW,EAAE,MAAM,EAAE,CAAC;KACvB,CAAC;CACH;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,EAAE,CAAC;CAClB;AAED,MAAM,WAAW,uBAAuB;IACtC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;IACvB,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED,MAAM,MAAM,aAAa,GAAG,MAAM,CAAC,SAAS,EAAE,YAAY,EAAE,CAAC,CAAC;AAE9D,eAAO,MAAM,WAAW,EAAE,SAAS,SAAS,EAmB3C,CAAC"}

package/dist/puzzles/cube2/types.js

@@ -0,0 +1,21 @@
+export const CORNER_COUNT = 8;
+export const CUBE2_MOVES = [
+    "U",
+    "U2",
+    "U'",
+    "D",
+    "D2",
+    "D'",
+    "R",
+    "R2",
+    "R'",
+    "L",
+    "L2",
+    "L'",
+    "F",
+    "F2",
+    "F'",
+    "B",
+    "B2",
+    "B'"
+];

package/dist/puzzles/cube2/validation.d.ts

@@ -0,0 +1,6 @@
+import type { Cube2State, Cube2ValidationResult } from "./types.js";
+export declare function validateCube2State(state: Cube2State): Cube2ValidationResult;
+export declare function isOneMoveFromSolvedCube2State(state: Cube2State): boolean;
+export declare function isAllowedRandomCube2State(state: Cube2State): boolean;
+export declare function permutationParity(permutation: readonly number[]): 0 | 1;
+//# sourceMappingURL=validation.d.ts.map

package/dist/puzzles/cube2/validation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube2/validation.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,UAAU,EAAE,qBAAqB,EAAE,MAAM,YAAY,CAAC;AAIpE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,UAAU,GAAG,qBAAqB,CAkB3E;AAED,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAGxE;AAED,wBAAgB,yBAAyB,CAAC,KAAK,EAAE,UAAU,GAAG,OAAO,CAIpE;AAED,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,SAAS,MAAM,EAAE,GAAG,CAAC,GAAG,CAAC,CAYvE"}

package/dist/puzzles/cube2/validation.js

@@ -0,0 +1,72 @@
+import { CUBE2_MOVES, CORNER_COUNT } from "./types.js";
+import { applyCube2Move } from "./moves.js";
+import { createSolvedCube2State, cube2StatesEqual, isSolvedCube2State } from "./state.js";
+export function validateCube2State(state) {
+    const errors = [
+        ...validatePermutation("corner", state.corners.permutation, CORNER_COUNT),
+        ...validateOrientations("corner", state.corners.orientation, 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
+    };
+}
+export function isOneMoveFromSolvedCube2State(state) {
+    const solved = createSolvedCube2State();
+    return CUBE2_MOVES.some((move) => cube2StatesEqual(applyCube2Move(solved, move), state));
+}
+export function isAllowedRandomCube2State(state) {
+    return validateCube2State(state).valid &&
+        !isSolvedCube2State(state) &&
+        !isOneMoveFromSolvedCube2State(state);
+}
+export 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/puzzles/cube3/facelets.d.ts

@@ -0,0 +1,5 @@
+import type { Cube3Face, Cube3Facelets, Cube3State } from "./types.js";
+export declare function toCube3Facelets(state: Cube3State): Cube3Facelets;
+export declare function formatCube3Facelets(facelets: Cube3Facelets): string;
+export declare function getCube3FaceOrder(): readonly Cube3Face[];
+//# sourceMappingURL=facelets.d.ts.map

package/dist/puzzles/cube3/facelets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"facelets.d.ts","sourceRoot":"","sources":["../../../src/puzzles/cube3/facelets.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,aAAa,EAAE,UAAU,EAAgB,MAAM,YAAY,CAAC;AA0DrF,wBAAgB,eAAe,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CA8BhE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,aAAa,GAAG,MAAM,CAEnE;AAED,wBAAgB,iBAAiB,IAAI,SAAS,SAAS,EAAE,CAExD"}