@cubingcenter/scrambler 0.5.3 → 0.6.0

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateRandomSquare1State = generateRandomSquare1State;
+const index_js_1 = require("../../random/index.js");
+const index_js_2 = require("./solver/index.js");
+const state_js_1 = require("./state.js");
+const moves_js_1 = require("./moves.js");
+/**
+ * Samples an exact uniform random legal state for Square-1.
+ */
+function generateRandomSquare1State(options = {}) {
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    const tables = (0, index_js_2.getSquare1SolverTablesSync)();
+    const searcher = new index_js_2.Square1Searcher(tables);
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const shapeIdx = tables.shapeIdx[random.nextInt(3678)];
+        const cube = new index_js_2.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, index_js_2.INVERSE_SOLUTION);
+        const state = (0, moves_js_1.applySquare1Algorithm)((0, state_js_1.createSolvedSquare1State)(), sol.moves);
+        if (rejectTrivial && (0, state_js_1.isSolvedSquare1State)(state)) {
+            continue;
+        }
+        return state;
+    }
+    throw new Error("Unable to generate a non-trivial random Square-1 state.");
+}

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

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sq1ScrambleGenerator = void 0;
+exports.generateSquare1Scramble = generateSquare1Scramble;
+exports.generateSquare1ScrambleSync = generateSquare1ScrambleSync;
+const index_js_1 = require("../../random/index.js");
+const index_js_2 = require("./solver/index.js");
+const state_js_1 = require("./state.js");
+const moves_js_1 = require("./moves.js");
+const facelets_js_1 = require("./facelets.js");
+exports.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);
+    }
+};
+async function generateSquare1Scramble(options = {}) {
+    if (!(0, index_js_2.areSquare1TablesLoaded)()) {
+        await (0, index_js_2.ensureSquare1TablesLoaded)();
+    }
+    return generateSquare1ScrambleSync(options);
+}
+function generateSquare1ScrambleSync(options = {}) {
+    const tables = (0, index_js_2.getSquare1SolverTablesSync)();
+    const searcher = new index_js_2.Square1Searcher(tables);
+    const random = (0, index_js_1.createRandomSource)(options.seed);
+    const rejectTrivial = options.rejectTrivial ?? true;
+    let scramble = "";
+    let moves = [];
+    let state = (0, state_js_1.createSolvedSquare1State)();
+    for (let attempt = 0; attempt < 100; attempt++) {
+        const shapeIdx = tables.shapeIdx[random.nextInt(3678)];
+        const cube = new index_js_2.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, index_js_2.INVERSE_SOLUTION);
+        moves = sol.moves;
+        scramble = sol.scramble;
+        state = (0, moves_js_1.applySquare1Algorithm)((0, state_js_1.createSolvedSquare1State)(), moves);
+        if (rejectTrivial && (0, state_js_1.isSolvedSquare1State)(state)) {
+            continue;
+        }
+        break;
+    }
+    const solutionMoves = (0, moves_js_1.invertSquare1Algorithm)(moves);
+    const facelets = (0, facelets_js_1.toSquare1Facelets)(state);
+    const faceletString = (0, facelets_js_1.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-cjs/puzzles/sq1/solver/browser-loader.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCachedBrowserTables = getCachedBrowserTables;
+exports.clearCachedBrowserTables = clearCachedBrowserTables;
+exports.loadBrowserTables = loadBrowserTables;
+const table_metadata_js_1 = require("./table-metadata.js");
+const compressed_fetch_js_1 = require("../../shared/compressed-fetch.js");
+const TABLES_DIR = "puzzles/sq1/solver/generated";
+let cachedBrowserTables;
+function getCachedBrowserTables() {
+    return cachedBrowserTables;
+}
+function clearCachedBrowserTables() {
+    cachedBrowserTables = undefined;
+}
+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, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeIdx.entries),
+        fetchInt8Table(resolved, manifest.files.shapePrun, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapePrun.entries),
+        fetchInt32Table(resolved, manifest.files.shapeTopMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeTopMove.entries),
+        fetchInt32Table(resolved, manifest.files.shapeBottomMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeBottomMove.entries),
+        fetchInt32Table(resolved, manifest.files.shapeTwistMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.shapeTwistMove.entries),
+        fetchUint16Table(resolved, manifest.files.squareTwistMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.squareTwistMove.entries),
+        fetchUint16Table(resolved, manifest.files.squareTopMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.squareTopMove.entries),
+        fetchUint16Table(resolved, manifest.files.squareBottomMove, table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA.squareBottomMove.entries),
+        fetchInt8Table(resolved, manifest.files.squarePrun, table_metadata_js_1.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 (0, compressed_fetch_js_1.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 (0, compressed_fetch_js_1.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 (0, compressed_fetch_js_1.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-cjs/puzzles/sq1/solver/full-cube.js

@@ -0,0 +1,289 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FullCube = void 0;
+exports.get8Perm = get8Perm;
+exports.set8Perm = set8Perm;
+exports.fullCubeToState = fullCubeToState;
+exports.stateToFullCube = stateToFullCube;
+const state_js_1 = require("../state.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]
+ */
+class FullCube {
+    ul = 0x011233;
+    ur = 0x455677;
+    dl = 0x998bba;
+    dr = 0xddcffe;
+    ml = 0;
+    copy(c) {
+        this.ul = c.ul;
+        this.ur = c.ur;
+        this.dl = c.dl;
+        this.dr = c.dr;
+        this.ml = c.ml;
+    }
+    isSolved() {
+        return (this.ul === 0x011233 &&
+            this.ur === 0x455677 &&
+            this.dl === 0x998bba &&
+            this.dr === 0xddcffe &&
+            this.ml === 0);
+    }
+    /**
+     * Applies move token:
+     *  - 0: slice /
+     *  - >0: top layer turn
+     *  - <0: bottom layer turn
+     */
+    doMove(move) {
+        let m = move << 2;
+        if (m > 24) {
+            m = 48 - m;
+            const temp = this.ul;
+            this.ul = ((this.ul >> m) | (this.ur << (24 - m))) & 0xffffff;
+            this.ur = ((this.ur >> m) | (temp << (24 - m))) & 0xffffff;
+        }
+        else if (m > 0) {
+            const temp = this.ul;
+            this.ul = ((this.ul << m) | (this.ur >> (24 - m))) & 0xffffff;
+            this.ur = ((this.ur << m) | (temp >> (24 - m))) & 0xffffff;
+        }
+        else if (m === 0) {
+            const temp = this.ur;
+            this.ur = this.dl;
+            this.dl = temp;
+            this.ml = 1 - this.ml;
+        }
+        else if (m >= -24) {
+            m = -m;
+            const temp = this.dl;
+            this.dl = ((this.dl << m) | (this.dr >> (24 - m))) & 0xffffff;
+            this.dr = ((this.dr << m) | (temp >> (24 - m))) & 0xffffff;
+        }
+        else if (m < -24) {
+            m = 48 + m;
+            const temp = this.dl;
+            this.dl = ((this.dl >> m) | (this.dr << (24 - m))) & 0xffffff;
+            this.dr = ((this.dr >> m) | (temp << (24 - m))) & 0xffffff;
+        }
+    }
+    pieceAt(idx) {
+        let ret;
+        if (idx < 6) {
+            ret = this.ul >> ((5 - idx) << 2);
+        }
+        else if (idx < 12) {
+            ret = this.ur >> ((11 - idx) << 2);
+        }
+        else if (idx < 18) {
+            ret = this.dl >> ((17 - idx) << 2);
+        }
+        else {
+            ret = this.dr >> ((23 - idx) << 2);
+        }
+        return ret & 0x0f;
+    }
+    setPiece(idx, value) {
+        const shift = idx < 6
+            ? (5 - idx) << 2
+            : idx < 12
+                ? (11 - idx) << 2
+                : idx < 18
+                    ? (17 - idx) << 2
+                    : (23 - idx) << 2;
+        if (idx < 6) {
+            this.ul = (this.ul & ~(0xf << shift)) | (value << shift);
+        }
+        else if (idx < 12) {
+            this.ur = (this.ur & ~(0xf << shift)) | (value << shift);
+        }
+        else if (idx < 18) {
+            this.dl = (this.dl & ~(0xf << shift)) | (value << shift);
+        }
+        else if (idx < 24) {
+            this.dr = (this.dr & ~(0xf << shift)) | (value << shift);
+        }
+    }
+    getParity() {
+        const arr = new Array(16);
+        let cnt = 0;
+        arr[0] = this.pieceAt(0);
+        for (let i = 1; i < 24; i++) {
+            const p = this.pieceAt(i);
+            if (p !== arr[cnt]) {
+                arr[++cnt] = p;
+            }
+        }
+        let p = 0;
+        for (let a = 0; a < 16; a++) {
+            for (let b = a + 1; b < 16; b++) {
+                if (arr[a] > arr[b]) {
+                    p ^= 1;
+                }
+            }
+        }
+        return p;
+    }
+    getShapeIdx(shapeIdxTable) {
+        let urx = this.ur & 0x111111;
+        urx |= urx >> 3;
+        urx |= urx >> 6;
+        urx = (urx & 0xf) | ((urx >> 12) & 0x30);
+        let ulx = this.ul & 0x111111;
+        ulx |= ulx >> 3;
+        ulx |= ulx >> 6;
+        ulx = (ulx & 0xf) | ((ulx >> 12) & 0x30);
+        let drx = this.dr & 0x111111;
+        drx |= drx >> 3;
+        drx |= drx >> 6;
+        drx = (drx & 0xf) | ((drx >> 12) & 0x30);
+        let dlx = this.dl & 0x111111;
+        dlx |= dlx >> 3;
+        dlx |= dlx >> 6;
+        dlx = (dlx & 0xf) | ((dlx >> 12) & 0x30);
+        const key = ((this.getParity() << 24) | (ulx << 18) | (urx << 12) | (dlx << 6) | drx) >>> 0;
+        return getShape2Idx(shapeIdxTable, key);
+    }
+    getSquare() {
+        const prm = new Uint8Array(8);
+        for (let a = 0; a < 8; a++) {
+            prm[a] = this.pieceAt(a * 3 + 1) >> 1;
+        }
+        const cornperm = get8Perm(prm);
+        const topEdgeFirst = this.pieceAt(0) === this.pieceAt(1);
+        let a = topEdgeFirst ? 2 : 0;
+        let b = 0;
+        for (; b < 4; a += 3, b++) {
+            prm[b] = this.pieceAt(a) >> 1;
+        }
+        const botEdgeFirst = this.pieceAt(12) === this.pieceAt(13);
+        a = botEdgeFirst ? 14 : 12;
+        for (; b < 8; a += 3, b++) {
+            prm[b] = this.pieceAt(a) >> 1;
+        }
+        const edgeperm = get8Perm(prm);
+        return { edgeperm, cornperm, topEdgeFirst, botEdgeFirst, ml: this.ml };
+    }
+}
+exports.FullCube = FullCube;
+function getShape2Idx(shapeIdxTable, shp) {
+    let low = 0;
+    let high = shapeIdxTable.length - 1;
+    const key = (shp & 0xffffff) >>> 0;
+    while (low <= high) {
+        const mid = (low + high) >>> 1;
+        const midVal = (shapeIdxTable[mid]) >>> 0;
+        if (midVal < key)
+            low = mid + 1;
+        else if (midVal > key)
+            high = mid - 1;
+        else
+            return (mid << 1) | (shp >>> 24);
+    }
+    return 0;
+}
+const fact = [1, 1, 2, 6, 24, 120, 720, 5040];
+function get8Perm(arr) {
+    let idx = 0;
+    let val = 0x76543210;
+    for (let i = 0; i < 7; i++) {
+        const v = arr[i] << 2;
+        idx = (8 - i) * idx + ((val >> v) & 7);
+        val -= 0x11111110 << v;
+    }
+    return idx;
+}
+function set8Perm(arr, idx) {
+    let val = 0x76543210;
+    for (let i = 0; i < 7; i++) {
+        const p = fact[7 - i];
+        const v = Math.floor(idx / p);
+        idx -= v * p;
+        const shift = v << 2;
+        arr[i] = (val >> shift) & 7;
+        const m = (1 << shift) - 1;
+        val = (val & m) + ((val >> 4) & ~m);
+    }
+    arr[7] = val & 7;
+}
+/**
+ * Converts a FullCube instance to a high-level Square1State.
+ */
+function fullCubeToState(cube) {
+    const solved = (0, state_js_1.createSolvedSquare1State)();
+    const allSlots = [...solved.top, ...solved.bottom];
+    const getSlotDef = (pieceId, isCorner, partIndex) => {
+        const def = allSlots.find((s) => s.pieceId === pieceId && s.partIndex === partIndex);
+        return def || { faceColor: (pieceId < 8 ? "U" : "D"), sideColor: "F" };
+    };
+    const top = Array.from({ length: 12 }, (_, i) => {
+        const raw = cube.pieceAt(i);
+        const isCorner = (raw & 1) === 1;
+        const pieceId = isCorner ? (raw >> 1) : ((raw >> 1) + 8);
+        let partIndex = 0;
+        if (isCorner) {
+            const prevRaw = cube.pieceAt((i - 1 + 12) % 12);
+            if (prevRaw === raw)
+                partIndex = 1;
+            else
+                partIndex = 0;
+        }
+        const def = getSlotDef(pieceId, isCorner, partIndex);
+        return {
+            pieceId,
+            isCorner,
+            partIndex,
+            faceColor: "U",
+            sideColor: def.sideColor
+        };
+    });
+    const bottom = Array.from({ length: 12 }, (_, i) => {
+        const raw = cube.pieceAt(12 + i);
+        const isCorner = (raw & 1) === 1;
+        const pieceId = isCorner ? (raw >> 1) : ((raw >> 1) + 8);
+        let partIndex = 0;
+        if (isCorner) {
+            const prevRaw = cube.pieceAt(12 + ((i - 1 + 12) % 12));
+            if (prevRaw === raw)
+                partIndex = 1;
+            else
+                partIndex = 0;
+        }
+        const def = getSlotDef(pieceId, isCorner, partIndex);
+        return {
+            pieceId,
+            isCorner,
+            partIndex,
+            faceColor: "D",
+            sideColor: def.sideColor
+        };
+    });
+    return { top, bottom, middle: cube.ml };
+}
+/**
+ * Converts a high-level Square1State to a FullCube.
+ */
+function stateToFullCube(state) {
+    const cube = new FullCube();
+    cube.ml = state.middle;
+    for (let i = 0; i < 12; i++) {
+        const s = state.top[i];
+        const raw = s.isCorner ? ((s.pieceId << 1) | 1) : ((s.pieceId - 8) << 1);
+        cube.setPiece(i, raw);
+        const sb = state.bottom[i];
+        const rawB = sb.isCorner ? ((sb.pieceId << 1) | 1) : ((sb.pieceId - 8) << 1);
+        cube.setPiece(12 + i, rawB);
+    }
+    return cube;
+}

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

@@ -0,0 +1,50 @@
+{
+  "version": 1,
+  "files": {
+    "shapeIdx": {
+      "file": "shape-idx.bin",
+      "entries": 3678,
+      "checksum": 3187990008
+    },
+    "shapePrun": {
+      "file": "shape-prun.bin",
+      "entries": 7356,
+      "checksum": 2116325776
+    },
+    "shapeTopMove": {
+      "file": "shape-top-move.bin",
+      "entries": 7356,
+      "checksum": 4112891337
+    },
+    "shapeBottomMove": {
+      "file": "shape-bottom-move.bin",
+      "entries": 7356,
+      "checksum": 161984121
+    },
+    "shapeTwistMove": {
+      "file": "shape-twist-move.bin",
+      "entries": 7356,
+      "checksum": 694153781
+    },
+    "squareTwistMove": {
+      "file": "square-twist-move.bin",
+      "entries": 40320,
+      "checksum": 4150758597
+    },
+    "squareTopMove": {
+      "file": "square-top-move.bin",
+      "entries": 40320,
+      "checksum": 1003750981
+    },
+    "squareBottomMove": {
+      "file": "square-bottom-move.bin",
+      "entries": 40320,
+      "checksum": 2028613829
+    },
+    "squarePrun": {
+      "file": "square-prun.bin",
+      "entries": 80640,
+      "checksum": 1475475221
+    }
+  }
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SQ1_SOLVER_TABLE_METADATA = exports.INVERSE_SOLUTION = exports.Square1Searcher = exports.setCachedSquare1Tables = exports.generateSquare1SolverTables = exports.getSquare1SolverTablesSync = exports.ensureSquare1TablesLoaded = exports.areSquare1TablesLoaded = exports.stateToFullCube = exports.fullCubeToState = exports.FullCube = void 0;
+var full_cube_js_1 = require("./full-cube.js");
+Object.defineProperty(exports, "FullCube", { enumerable: true, get: function () { return full_cube_js_1.FullCube; } });
+Object.defineProperty(exports, "fullCubeToState", { enumerable: true, get: function () { return full_cube_js_1.fullCubeToState; } });
+Object.defineProperty(exports, "stateToFullCube", { enumerable: true, get: function () { return full_cube_js_1.stateToFullCube; } });
+var tables_js_1 = require("./tables.js");
+Object.defineProperty(exports, "areSquare1TablesLoaded", { enumerable: true, get: function () { return tables_js_1.areSquare1TablesLoaded; } });
+Object.defineProperty(exports, "ensureSquare1TablesLoaded", { enumerable: true, get: function () { return tables_js_1.ensureSquare1TablesLoaded; } });
+Object.defineProperty(exports, "getSquare1SolverTablesSync", { enumerable: true, get: function () { return tables_js_1.getSquare1SolverTablesSync; } });
+Object.defineProperty(exports, "generateSquare1SolverTables", { enumerable: true, get: function () { return tables_js_1.generateSquare1SolverTables; } });
+Object.defineProperty(exports, "setCachedSquare1Tables", { enumerable: true, get: function () { return tables_js_1.setCachedSquare1Tables; } });
+var search_js_1 = require("./search.js");
+Object.defineProperty(exports, "Square1Searcher", { enumerable: true, get: function () { return search_js_1.Square1Searcher; } });
+Object.defineProperty(exports, "INVERSE_SOLUTION", { enumerable: true, get: function () { return search_js_1.INVERSE_SOLUTION; } });
+var table_metadata_js_1 = require("./table-metadata.js");
+Object.defineProperty(exports, "SQ1_SOLVER_TABLE_METADATA", { enumerable: true, get: function () { return table_metadata_js_1.SQ1_SOLVER_TABLE_METADATA; } });