@cubingcenter/scrambler 0.5.3 → 0.6.0

package/dist/puzzles/sq1/moves.js

@@ -0,0 +1,220 @@
+import { cloneSquare1State } from "./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).
+ */
+export 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).
+ */
+export function applyTopTurn(state, u) {
+    const normU = ((u % 12) + 12) % 12;
+    if (normU === 0)
+        return 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).
+ */
+export function applyBottomTurn(state, d) {
+    const normD = ((d % 12) + 12) % 12;
+    if (normD === 0)
+        return 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.
+ */
+export 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).
+ */
+export function applySlice(state) {
+    if (!isSliceable(state)) {
+        throw new Error("Square-1: cannot slice non-sliceable state (corner cuts across seam)");
+    }
+    const next = 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].
+ */
+export 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.
+ */
+export 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.
+ */
+export 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) /".
+ */
+export 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.
+ */
+export 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.
+ */
+export 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.
+ */
+export 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;
+}

package/dist/puzzles/sq1/random-state.d.ts

@@ -0,0 +1,6 @@
+import type { Square1RandomStateOptions, Square1State } from "./types.js";
+/**
+ * Samples an exact uniform random legal state for Square-1.
+ */
+export declare function generateRandomSquare1State(options?: Square1RandomStateOptions): Square1State;
+//# sourceMappingURL=random-state.d.ts.map

package/dist/puzzles/sq1/random-state.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"random-state.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/random-state.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAU1E;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,GAAE,yBAA8B,GACtC,YAAY,CAgDd"}

package/dist/puzzles/sq1/random-state.js

@@ -0,0 +1,49 @@
+import { createRandomSource } from "../../random/index.js";
+import { FullCube, Square1Searcher, INVERSE_SOLUTION, getSquare1SolverTablesSync } from "./solver/index.js";
+import { createSolvedSquare1State, isSolvedSquare1State } from "./state.js";
+import { applySquare1Algorithm } from "./moves.js";
+/**
+ * Samples an exact uniform random legal state for Square-1.
+ */
+export function generateRandomSquare1State(options = {}) {
+    const random = createRandomSource(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    const tables = getSquare1SolverTablesSync();
+    const searcher = new Square1Searcher(tables);
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const shapeIdx = tables.shapeIdx[random.nextInt(3678)];
+        const cube = new FullCube();
+        let corner = (0x01234567 << 1) | 0x11111111;
+        let edge = 0x01234567 << 1;
+        let n_corner = 8;
+        let n_edge = 8;
+        for (let i = 0; i < 24; i++) {
+            if (((shapeIdx >> i) & 1) === 0) {
+                // edge
+                const rnd = random.nextInt(n_edge) << 2;
+                cube.setPiece(23 - i, (edge >> rnd) & 0xf);
+                const m = (1 << rnd) - 1;
+                edge = (edge & m) + ((edge >> 4) & ~m);
+                n_edge--;
+            }
+            else {
+                // corner
+                const rnd = random.nextInt(n_corner) << 2;
+                cube.setPiece(23 - i, (corner >> rnd) & 0xf);
+                cube.setPiece(22 - i, (corner >> rnd) & 0xf);
+                const m = (1 << rnd) - 1;
+                corner = (corner & m) + ((corner >> 4) & ~m);
+                n_corner--;
+                i++;
+            }
+        }
+        cube.ml = random.nextInt(2);
+        const sol = searcher.solution(cube, INVERSE_SOLUTION);
+        const state = applySquare1Algorithm(createSolvedSquare1State(), sol.moves);
+        if (rejectTrivial && isSolvedSquare1State(state)) {
+            continue;
+        }
+        return state;
+    }
+    throw new Error("Unable to generate a non-trivial random Square-1 state.");
+}

package/dist/puzzles/sq1/scrambler.d.ts

@@ -0,0 +1,10 @@
+import type { ScrambleGenerator, ScrambleOptions, ScrambleResult } from "../../core/index.js";
+import type { Square1RandomStateOptions } from "./types.js";
+export declare const sq1ScrambleGenerator: ScrambleGenerator;
+export declare function generateSquare1Scramble(options?: ScrambleOptions & Square1RandomStateOptions & {
+    skipValidation?: boolean;
+}): Promise<ScrambleResult>;
+export declare function generateSquare1ScrambleSync(options?: ScrambleOptions & Square1RandomStateOptions & {
+    skipValidation?: boolean;
+}): ScrambleResult;
+//# sourceMappingURL=scrambler.d.ts.map

package/dist/puzzles/sq1/scrambler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scrambler.d.ts","sourceRoot":"","sources":["../../../src/puzzles/sq1/scrambler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EACjB,eAAe,EACf,cAAc,EACf,MAAM,qBAAqB,CAAC;AAoB7B,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,YAAY,CAAC;AAE5D,eAAO,MAAM,oBAAoB,EAAE,iBAalC,CAAC;AAEF,wBAAsB,uBAAuB,CAC3C,OAAO,GAAE,eAAe,GAAG,yBAAyB,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GACvF,OAAO,CAAC,cAAc,CAAC,CAKzB;AAED,wBAAgB,2BAA2B,CACzC,OAAO,GAAE,eAAe,GAAG,yBAAyB,GAAG;IAAE,cAAc,CAAC,EAAE,OAAO,CAAA;CAAO,GACvF,cAAc,CA2EhB"}

package/dist/puzzles/sq1/scrambler.js

@@ -0,0 +1,90 @@
+import { createRandomSource } from "../../random/index.js";
+import { Square1Searcher, INVERSE_SOLUTION, FullCube, areSquare1TablesLoaded, ensureSquare1TablesLoaded, getSquare1SolverTablesSync } from "./solver/index.js";
+import { createSolvedSquare1State, isSolvedSquare1State } from "./state.js";
+import { applySquare1Algorithm, invertSquare1Algorithm } from "./moves.js";
+import { toSquare1Facelets, formatSquare1Facelets } from "./facelets.js";
+export const sq1ScrambleGenerator = {
+    info: {
+        eventId: "sq1",
+        name: "Square-1",
+        puzzle: "square1",
+        quality: "random-state",
+        generator: "sq1-two-phase",
+        description: "Random-state Square-1 scramble generated by a two-phase reduction solver."
+    },
+    generate(options = {}) {
+        return generateSquare1Scramble(options);
+    }
+};
+export async function generateSquare1Scramble(options = {}) {
+    if (!areSquare1TablesLoaded()) {
+        await ensureSquare1TablesLoaded();
+    }
+    return generateSquare1ScrambleSync(options);
+}
+export function generateSquare1ScrambleSync(options = {}) {
+    const tables = getSquare1SolverTablesSync();
+    const searcher = new Square1Searcher(tables);
+    const random = createRandomSource(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    let scramble = "";
+    let moves = [];
+    let state = createSolvedSquare1State();
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const shapeIdx = tables.shapeIdx[random.nextInt(3678)];
+        const cube = new FullCube();
+        let corner = (0x01234567 << 1) | 0x11111111;
+        let edge = 0x01234567 << 1;
+        let n_corner = 8;
+        let n_edge = 8;
+        for (let idx = 0; idx < 24; idx++) {
+            if (((shapeIdx >> idx) & 1) === 0) {
+                const rnd = random.nextInt(n_edge) << 2;
+                cube.setPiece(23 - idx, (edge >> rnd) & 0xf);
+                const m = (1 << rnd) - 1;
+                edge = (edge & m) + ((edge >> 4) & ~m);
+                n_edge--;
+            }
+            else {
+                const rnd = random.nextInt(n_corner) << 2;
+                cube.setPiece(23 - idx, (corner >> rnd) & 0xf);
+                cube.setPiece(22 - idx, (corner >> rnd) & 0xf);
+                const m = (1 << rnd) - 1;
+                corner = (corner & m) + ((corner >> 4) & ~m);
+                n_corner--;
+                idx++;
+            }
+        }
+        cube.ml = random.nextInt(2);
+        const sol = searcher.solution(cube, INVERSE_SOLUTION);
+        moves = sol.moves;
+        scramble = sol.scramble;
+        state = applySquare1Algorithm(createSolvedSquare1State(), moves);
+        if (rejectTrivial && isSolvedSquare1State(state)) {
+            continue;
+        }
+        break;
+    }
+    const solutionMoves = invertSquare1Algorithm(moves);
+    const facelets = toSquare1Facelets(state);
+    const faceletString = formatSquare1Facelets(facelets);
+    const result = {
+        eventId: "sq1",
+        scramble,
+        moves,
+        quality: "random-state",
+        generator: "sq1-two-phase",
+        metadata: {
+            totalSlashes: moves.filter((m) => m === "/").length,
+            solutionDepth: solutionMoves.filter((m) => m === "/").length,
+            solutionMoves,
+            state,
+            facelets,
+            faceletString
+        }
+    };
+    if (options.seed !== undefined) {
+        result.seed = options.seed;
+    }
+    return result;
+}

package/dist/puzzles/sq1/solver/browser-loader.d.ts

@@ -0,0 +1,5 @@
+import type { Square1SolverTables } from "./tables.js";
+export declare function getCachedBrowserTables(): Square1SolverTables | undefined;
+export declare function clearCachedBrowserTables(): void;
+export declare function loadBrowserTables(baseUrl?: string): Promise<Square1SolverTables>;
+//# sourceMappingURL=browser-loader.d.ts.map

package/dist/puzzles/sq1/solver/browser-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser-loader.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/browser-loader.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AAMvD,wBAAgB,sBAAsB,IAAI,mBAAmB,GAAG,SAAS,CAExE;AAED,wBAAgB,wBAAwB,IAAI,IAAI,CAE/C;AAED,wBAAsB,iBAAiB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CA2CtF"}

package/dist/puzzles/sq1/solver/browser-loader.js

@@ -0,0 +1,92 @@
+import { SQ1_SOLVER_TABLE_METADATA } from "./table-metadata.js";
+import { fetchTableBuffer } from "../../shared/compressed-fetch.js";
+const TABLES_DIR = "puzzles/sq1/solver/generated";
+let cachedBrowserTables;
+export function getCachedBrowserTables() {
+    return cachedBrowserTables;
+}
+export function clearCachedBrowserTables() {
+    cachedBrowserTables = undefined;
+}
+export async function loadBrowserTables(baseUrl) {
+    if (cachedBrowserTables) {
+        return cachedBrowserTables;
+    }
+    const resolved = resolveBaseUrl(baseUrl);
+    const manifest = await fetchManifest(resolved);
+    const [shapeIdx, shapePrun, shapeTopMove, shapeBottomMove, shapeTwistMove, squareTwistMove, squareTopMove, squareBottomMove, squarePrun] = await Promise.all([
+        fetchInt32Table(resolved, manifest.files.shapeIdx, SQ1_SOLVER_TABLE_METADATA.shapeIdx.entries),
+        fetchInt8Table(resolved, manifest.files.shapePrun, SQ1_SOLVER_TABLE_METADATA.shapePrun.entries),
+        fetchInt32Table(resolved, manifest.files.shapeTopMove, SQ1_SOLVER_TABLE_METADATA.shapeTopMove.entries),
+        fetchInt32Table(resolved, manifest.files.shapeBottomMove, SQ1_SOLVER_TABLE_METADATA.shapeBottomMove.entries),
+        fetchInt32Table(resolved, manifest.files.shapeTwistMove, SQ1_SOLVER_TABLE_METADATA.shapeTwistMove.entries),
+        fetchUint16Table(resolved, manifest.files.squareTwistMove, SQ1_SOLVER_TABLE_METADATA.squareTwistMove.entries),
+        fetchUint16Table(resolved, manifest.files.squareTopMove, SQ1_SOLVER_TABLE_METADATA.squareTopMove.entries),
+        fetchUint16Table(resolved, manifest.files.squareBottomMove, SQ1_SOLVER_TABLE_METADATA.squareBottomMove.entries),
+        fetchInt8Table(resolved, manifest.files.squarePrun, SQ1_SOLVER_TABLE_METADATA.squarePrun.entries),
+    ]);
+    cachedBrowserTables = {
+        shapeIdx,
+        shapePrun,
+        shapeTopMove,
+        shapeBottomMove,
+        shapeTwistMove,
+        squareTwistMove,
+        squareTopMove,
+        squareBottomMove,
+        squarePrun
+    };
+    return cachedBrowserTables;
+}
+function resolveBaseUrl(provided) {
+    if (provided) {
+        return provided.replace(/\/$/, "");
+    }
+    if (typeof document !== "undefined") {
+        const script = document.currentScript;
+        if (script?.src) {
+            const base = new URL(".", script.src).href;
+            return base.replace(/\/$/, "");
+        }
+    }
+    return ".";
+}
+async function fetchManifest(baseUrl) {
+    const url = `${baseUrl}/${TABLES_DIR}/manifest.json`;
+    const response = await fetch(url);
+    if (!response.ok) {
+        throw new Error(`Failed to load Square-1 solver table manifest from ${url}: ${response.status} ${response.statusText}`);
+    }
+    return (await response.json());
+}
+async function fetchInt32Table(baseUrl, entry, expectedEntries) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries * 4) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Int32Array(expectedEntries);
+    const view = new DataView(buffer);
+    for (let i = 0; i < values.length; i++) {
+        values[i] = view.getInt32(i * 4, true);
+    }
+    return values;
+}
+async function fetchUint16Table(baseUrl, entry, expectedEntries) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries * 2) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    const values = new Uint16Array(expectedEntries);
+    const view = new DataView(buffer);
+    for (let i = 0; i < values.length; i++) {
+        values[i] = view.getUint16(i * 2, true);
+    }
+    return values;
+}
+async function fetchInt8Table(baseUrl, entry, expectedEntries) {
+    const buffer = await fetchTableBuffer(baseUrl, TABLES_DIR, entry.file, { compressed: entry.compressed !== false });
+    if (buffer.byteLength !== expectedEntries) {
+        throw new Error(`Invalid byte size for ${entry.file}`);
+    }
+    return new Int8Array(buffer);
+}

package/dist/puzzles/sq1/solver/full-cube.d.ts

@@ -0,0 +1,53 @@
+import type { Square1State } from "../types.js";
+/**
+ * Low-level bitwise representation of Square-1 state.
+ *
+ * Each layer is split into left and right 6-slot halves (24 bits per half, 4 bits per slot):
+ *  - `ul`: top left (slots 0..5)
+ *  - `ur`: top right (slots 6..11)
+ *  - `dl`: bottom right / left (slots 0..5 of bottom)
+ *  - `dr`: bottom left / right (slots 6..11 of bottom)
+ *  - `ml`: middle layer state (0 = solved, 1 = flipped)
+ *
+ * Piece encoding in 4-bit values:
+ *  - Corners: values with LSB 1 (1, 3, 5, 7, 9, 11, 13, 15) -> pieceId = (val >> 1) in [0..7]
+ *  - Edges: values with LSB 0 (0, 2, 4, 6, 8, 10, 12, 14) -> pieceId = (val >> 1) + 8 in [8..15]
+ */
+export declare class FullCube {
+    ul: number;
+    ur: number;
+    dl: number;
+    dr: number;
+    ml: number;
+    copy(c: FullCube): void;
+    isSolved(): boolean;
+    /**
+     * Applies move token:
+     *  - 0: slice /
+     *  - >0: top layer turn
+     *  - <0: bottom layer turn
+     */
+    doMove(move: number): void;
+    pieceAt(idx: number): number;
+    setPiece(idx: number, value: number): void;
+    getParity(): number;
+    getShapeIdx(shapeIdxTable: Int32Array): number;
+    getSquare(): {
+        edgeperm: number;
+        cornperm: number;
+        topEdgeFirst: boolean;
+        botEdgeFirst: boolean;
+        ml: number;
+    };
+}
+export declare function get8Perm(arr: Uint8Array): number;
+export declare function set8Perm(arr: Uint8Array, idx: number): void;
+/**
+ * Converts a FullCube instance to a high-level Square1State.
+ */
+export declare function fullCubeToState(cube: FullCube): Square1State;
+/**
+ * Converts a high-level Square1State to a FullCube.
+ */
+export declare function stateToFullCube(state: Square1State): FullCube;
+//# sourceMappingURL=full-cube.d.ts.map

package/dist/puzzles/sq1/solver/full-cube.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"full-cube.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/full-cube.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAe,YAAY,EAAgB,MAAM,aAAa,CAAC;AAG3E;;;;;;;;;;;;;GAaG;AACH,qBAAa,QAAQ;IACnB,EAAE,EAAE,MAAM,CAAY;IACtB,EAAE,EAAE,MAAM,CAAY;IACtB,EAAE,EAAE,MAAM,CAAY;IACtB,EAAE,EAAE,MAAM,CAAY;IACtB,EAAE,EAAE,MAAM,CAAK;IAEf,IAAI,CAAC,CAAC,EAAE,QAAQ,GAAG,IAAI;IAQvB,QAAQ,IAAI,OAAO;IAUnB;;;;;OAKG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IA6B1B,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAc5B,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAoB1C,SAAS,IAAI,MAAM;IAqBnB,WAAW,CAAC,aAAa,EAAE,UAAU,GAAG,MAAM;IAyB9C,SAAS,IAAI;QACX,QAAQ,EAAE,MAAM,CAAC;QACjB,QAAQ,EAAE,MAAM,CAAC;QACjB,YAAY,EAAE,OAAO,CAAC;QACtB,YAAY,EAAE,OAAO,CAAC;QACtB,EAAE,EAAE,MAAM,CAAC;KACZ;CAuBF;AAmBD,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,GAAG,MAAM,CAShD;AAED,wBAAgB,QAAQ,CAAC,GAAG,EAAE,UAAU,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,CAY3D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,QAAQ,GAAG,YAAY,CAkD5D;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,YAAY,GAAG,QAAQ,CAe7D"}