@cubingcenter/scrambler 0.5.3 → 0.6.0

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

@@ -0,0 +1,225 @@
+import { FullCube } from "./full-cube.js";
+import { getSquare1SolverTablesSync } from "./tables.js";
+export const INVERSE_SOLUTION = 0x2;
+export class Square1Searcher {
+    tables;
+    move = new Array(100);
+    c = new FullCube();
+    d = new FullCube();
+    length1 = 0;
+    movelen1 = 0;
+    maxlen2 = 0;
+    verbose = 0;
+    solString = "";
+    solMoves = [];
+    constructor(tables) {
+        this.tables = tables || getSquare1SolverTablesSync();
+    }
+    solution(c, verbose = 0) {
+        this.c.copy(c);
+        this.verbose = verbose;
+        this.solString = "";
+        this.solMoves = [];
+        const shape = c.getShapeIdx(this.tables.shapeIdx);
+        for (this.length1 = this.tables.shapePrun[shape]; this.length1 < 100; this.length1++) {
+            this.maxlen2 = Math.min(31 - this.length1, 17);
+            if (this.idaPhase1(shape, this.tables.shapePrun[shape], this.length1, 0, -1)) {
+                break;
+            }
+        }
+        return {
+            moves: this.solMoves,
+            scramble: this.solString,
+            depth: this.solMoves.length
+        };
+    }
+    idaPhase1(shape, prunvalue, maxl, depth, lm) {
+        if (prunvalue === 0 && maxl < 4) {
+            this.movelen1 = depth;
+            return maxl === 0 && this.initPhase2();
+        }
+        // try twist
+        if (lm !== 0) {
+            const shapex = this.tables.shapeTwistMove[shape];
+            const prun = this.tables.shapePrun[shapex];
+            if (prun < maxl) {
+                this.move[depth] = 0;
+                if (this.idaPhase1(shapex, prun, maxl - 1, depth + 1, 0)) {
+                    return true;
+                }
+            }
+        }
+        // try top layer
+        if (lm <= 0) {
+            let m = 0;
+            let shapex = shape;
+            while (true) {
+                const topVal = this.tables.shapeTopMove[shapex];
+                m += topVal & 0xf;
+                shapex = topVal >> 4;
+                if (m >= 12)
+                    break;
+                const prun = this.tables.shapePrun[shapex];
+                if (prun > maxl)
+                    break;
+                else if (prun < maxl) {
+                    this.move[depth] = m;
+                    if (this.idaPhase1(shapex, prun, maxl - 1, depth + 1, 1)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        // try bottom layer
+        if (lm <= 1) {
+            let m = 0;
+            let shapex = shape;
+            while (true) {
+                const botVal = this.tables.shapeBottomMove[shapex];
+                m += botVal & 0xf;
+                shapex = botVal >> 4;
+                if (m >= 6)
+                    break;
+                const prun = this.tables.shapePrun[shapex];
+                if (prun > maxl)
+                    break;
+                else if (prun < maxl) {
+                    this.move[depth] = -m;
+                    if (this.idaPhase1(shapex, prun, maxl - 1, depth + 1, 2)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    initPhase2() {
+        this.d.copy(this.c);
+        for (let i = 0; i < this.movelen1; i++) {
+            this.d.doMove(this.move[i]);
+        }
+        const sq = this.d.getSquare();
+        const prun = Math.max(this.tables.squarePrun[(sq.edgeperm << 1) | sq.ml], this.tables.squarePrun[(sq.cornperm << 1) | sq.ml]);
+        for (let i = prun; i < this.maxlen2; i++) {
+            if (this.idaPhase2(sq.edgeperm, sq.cornperm, sq.topEdgeFirst, sq.botEdgeFirst, sq.ml, i, this.movelen1, 0)) {
+                this.formatSolution(i + this.movelen1);
+                return true;
+            }
+        }
+        return false;
+    }
+    idaPhase2(edge, corner, topEdgeFirst, botEdgeFirst, ml, maxl, depth, lm) {
+        if (maxl === 0 && !topEdgeFirst && botEdgeFirst) {
+            return edge === 0 && corner === 0 && ml === 0;
+        }
+        // try twist
+        if (lm !== 0 && topEdgeFirst === botEdgeFirst) {
+            const edgex = this.tables.squareTwistMove[edge];
+            const cornerx = this.tables.squareTwistMove[corner];
+            if (this.tables.squarePrun[(edgex << 1) | (1 - ml)] < maxl &&
+                this.tables.squarePrun[(cornerx << 1) | (1 - ml)] < maxl) {
+                this.move[depth] = 0;
+                if (this.idaPhase2(edgex, cornerx, topEdgeFirst, botEdgeFirst, 1 - ml, maxl - 1, depth + 1, 0)) {
+                    return true;
+                }
+            }
+        }
+        // try top layer
+        if (lm <= 0) {
+            let topEdgeFirstx = !topEdgeFirst;
+            let edgex = topEdgeFirstx ? this.tables.squareTopMove[edge] : edge;
+            let cornerx = topEdgeFirstx ? corner : this.tables.squareTopMove[corner];
+            let m = topEdgeFirstx ? 1 : 2;
+            let prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+            let prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+            while (m < 12 && prun1 <= maxl && prun2 <= maxl) {
+                if (prun1 < maxl && prun2 < maxl) {
+                    this.move[depth] = m;
+                    if (this.idaPhase2(edgex, cornerx, topEdgeFirstx, botEdgeFirst, ml, maxl - 1, depth + 1, 1)) {
+                        return true;
+                    }
+                }
+                topEdgeFirstx = !topEdgeFirstx;
+                if (topEdgeFirstx) {
+                    edgex = this.tables.squareTopMove[edgex];
+                    prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+                    m += 1;
+                }
+                else {
+                    cornerx = this.tables.squareTopMove[cornerx];
+                    prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+                    m += 2;
+                }
+            }
+        }
+        // try bottom layer
+        if (lm <= 1) {
+            let botEdgeFirstx = !botEdgeFirst;
+            let edgex = botEdgeFirstx ? this.tables.squareBottomMove[edge] : edge;
+            let cornerx = botEdgeFirstx ? corner : this.tables.squareBottomMove[corner];
+            let m = botEdgeFirstx ? 1 : 2;
+            let prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+            let prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+            while (m < (maxl > 6 ? 6 : 12) && prun1 <= maxl && prun2 <= maxl) {
+                if (prun1 < maxl && prun2 < maxl) {
+                    this.move[depth] = -m;
+                    if (this.idaPhase2(edgex, cornerx, topEdgeFirst, botEdgeFirstx, ml, maxl - 1, depth + 1, 2)) {
+                        return true;
+                    }
+                }
+                botEdgeFirstx = !botEdgeFirstx;
+                if (botEdgeFirstx) {
+                    edgex = this.tables.squareBottomMove[edgex];
+                    prun1 = this.tables.squarePrun[(edgex << 1) | ml];
+                    m += 1;
+                }
+                else {
+                    cornerx = this.tables.squareBottomMove[cornerx];
+                    prun2 = this.tables.squarePrun[(cornerx << 1) | ml];
+                    m += 2;
+                }
+            }
+        }
+        return false;
+    }
+    formatSolution(len) {
+        const outputMoves = new Array(len);
+        if ((this.verbose & INVERSE_SOLUTION) !== 0) {
+            for (let i = len - 1; i >= 0; i--) {
+                const val = this.move[i];
+                outputMoves[len - 1 - i] = val > 0 ? 12 - val : val < 0 ? -12 - val : val;
+            }
+        }
+        else {
+            for (let i = 0; i < len; i++) {
+                outputMoves[i] = this.move[i];
+            }
+        }
+        const tokens = [];
+        let top = 0;
+        let bottom = 0;
+        for (let i = 0; i < len; i++) {
+            const val = outputMoves[i];
+            if (val > 0) {
+                top = val > 6 ? val - 12 : val;
+            }
+            else if (val < 0) {
+                bottom = -val > 6 ? -val - 12 : -val;
+            }
+            else {
+                tokens.push(`(${top}, ${bottom})`, "/");
+                top = 0;
+                bottom = 0;
+            }
+        }
+        if (top !== 0 || bottom !== 0) {
+            tokens.push(`(${top}, ${bottom})`);
+        }
+        // Clean up empty leading (0, 0)
+        if (tokens.length >= 2 && tokens[0] === "(0, 0)") {
+            tokens.shift();
+        }
+        this.solMoves = tokens;
+        this.solString = tokens.join(" ").replace(/\s*\/\s*/g, " / ").replace(/\s+/g, " ").trim();
+    }
+}

package/dist/puzzles/sq1/solver/shape.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shape tables and transitions for Square-1 (Phase 1).
+ */
+export declare function bitCount(n: number): number;
+export declare class ShapeState {
+    top: number;
+    bottom: number;
+    parity: number;
+    getIdx(shapeIdx: Int32Array): number;
+    setIdx(idx: number, shapeIdx: Int32Array): void;
+    topMove(): number;
+    bottomMove(): number;
+    twistMove(): void;
+}
+export declare function generateShapeTables(): {
+    shapeIdx: Int32Array;
+    shapePrun: Int8Array;
+    shapeTopMove: Int32Array;
+    shapeBottomMove: Int32Array;
+    shapeTwistMove: Int32Array;
+};
+//# sourceMappingURL=shape.d.ts.map

package/dist/puzzles/sq1/solver/shape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shape.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/shape.ts"],"names":[],"mappings":"AAAA;;GAEG;AAOH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,GAAG,MAAM,CAQ1C;AAED,qBAAa,UAAU;IACrB,GAAG,EAAE,MAAM,CAAK;IAChB,MAAM,EAAE,MAAM,CAAK;IACnB,MAAM,EAAE,MAAM,CAAK;IAEnB,MAAM,CAAC,QAAQ,EAAE,UAAU,GAAG,MAAM;IAcpC,MAAM,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,UAAU,GAAG,IAAI;IAO/C,OAAO,IAAI,MAAM;IAoBjB,UAAU,IAAI,MAAM;IAoBpB,SAAS,IAAI,IAAI;CASlB;AAED,wBAAgB,mBAAmB,IAAI;IACrC,QAAQ,EAAE,UAAU,CAAC;IACrB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,UAAU,CAAC;IACzB,eAAe,EAAE,UAAU,CAAC;IAC5B,cAAc,EAAE,UAAU,CAAC;CAC5B,CAuGA"}

package/dist/puzzles/sq1/solver/shape.js

@@ -0,0 +1,185 @@
+/**
+ * Shape tables and transitions for Square-1 (Phase 1).
+ */
+const halflayer = [
+    0x00, 0x03, 0x06, 0x0c, 0x0f, 0x18, 0x1b, 0x1e,
+    0x30, 0x33, 0x36, 0x3c, 0x3f
+];
+export function bitCount(n) {
+    let count = 0;
+    let v = n >>> 0;
+    while (v > 0) {
+        count += v & 1;
+        v >>>= 1;
+    }
+    return count;
+}
+export class ShapeState {
+    top = 0;
+    bottom = 0;
+    parity = 0;
+    getIdx(shapeIdx) {
+        const shp = ((this.top << 12) | this.bottom) >>> 0;
+        let low = 0;
+        let high = shapeIdx.length - 1;
+        while (low <= high) {
+            const mid = (low + high) >>> 1;
+            const midVal = shapeIdx[mid] >>> 0;
+            if (midVal < shp)
+                low = mid + 1;
+            else if (midVal > shp)
+                high = mid - 1;
+            else
+                return (mid << 1) | this.parity;
+        }
+        return 0;
+    }
+    setIdx(idx, shapeIdx) {
+        this.parity = idx & 1;
+        const val = shapeIdx[idx >> 1];
+        this.bottom = val & 0xfff;
+        this.top = (val >> 12) & 0xfff;
+    }
+    topMove() {
+        let move = 0;
+        let moveParity = 0;
+        do {
+            if ((this.top & 0x800) === 0) {
+                move += 1;
+                this.top = (this.top << 1) & 0xfff;
+            }
+            else {
+                move += 2;
+                this.top = ((this.top << 2) ^ 0x3003) & 0xfff;
+            }
+            moveParity = 1 - moveParity;
+        } while ((bitCount(this.top & 0x3f) & 1) !== 0);
+        if ((bitCount(this.top) & 2) === 0) {
+            this.parity ^= moveParity;
+        }
+        return move;
+    }
+    bottomMove() {
+        let move = 0;
+        let moveParity = 0;
+        do {
+            if ((this.bottom & 0x800) === 0) {
+                move += 1;
+                this.bottom = (this.bottom << 1) & 0xfff;
+            }
+            else {
+                move += 2;
+                this.bottom = ((this.bottom << 2) ^ 0x3003) & 0xfff;
+            }
+            moveParity = 1 - moveParity;
+        } while ((bitCount(this.bottom & 0x3f) & 1) !== 0);
+        if ((bitCount(this.bottom) & 2) === 0) {
+            this.parity ^= moveParity;
+        }
+        return move;
+    }
+    twistMove() {
+        const temp = this.top & 0x3f;
+        const p1 = bitCount(temp);
+        const p3 = bitCount(this.bottom & 0xfc0);
+        this.parity ^= 1 & ((p1 & p3) >> 1);
+        this.top = (this.top & 0xfc0) | ((this.bottom >> 6) & 0x3f);
+        this.bottom = (this.bottom & 0x3f) | (temp << 6);
+    }
+}
+export function generateShapeTables() {
+    const shapeIdx = new Int32Array(3678);
+    const shapePrun = new Int8Array(3678 * 2);
+    const shapeTopMove = new Int32Array(3678 * 2);
+    const shapeBottomMove = new Int32Array(3678 * 2);
+    const shapeTwistMove = new Int32Array(3678 * 2);
+    // 1. Build ShapeIdx
+    let count = 0;
+    for (let i = 0; i < 13 * 13 * 13 * 13; i++) {
+        const dr = halflayer[i % 13];
+        const dl = halflayer[Math.floor(i / 13) % 13];
+        const ur = halflayer[Math.floor(i / (13 * 13)) % 13];
+        const ul = halflayer[Math.floor(i / (13 * 13 * 13))];
+        const value = (ul << 18) | (ur << 12) | (dl << 6) | dr;
+        if (bitCount(value) === 16) {
+            shapeIdx[count++] = value;
+        }
+    }
+    // 2. Build Shape moves
+    const s = new ShapeState();
+    for (let i = 0; i < 3678 * 2; i++) {
+        s.setIdx(i, shapeIdx);
+        shapeTopMove[i] = s.topMove() | (s.getIdx(shapeIdx) << 4);
+        s.setIdx(i, shapeIdx);
+        shapeBottomMove[i] = s.bottomMove() | (s.getIdx(shapeIdx) << 4);
+        s.setIdx(i, shapeIdx);
+        s.twistMove();
+        shapeTwistMove[i] = s.getIdx(shapeIdx);
+    }
+    // 3. Build ShapePrun
+    shapePrun.fill(-1);
+    const getIdxForShape = (shp) => {
+        let low = 0;
+        let high = shapeIdx.length - 1;
+        const key = (shp & 0xffffff) >>> 0;
+        while (low <= high) {
+            const mid = (low + high) >>> 1;
+            const midVal = (shapeIdx[mid]) >>> 0;
+            if (midVal < key)
+                low = mid + 1;
+            else if (midVal > key)
+                high = mid - 1;
+            else
+                return (mid << 1) | (shp >>> 24);
+        }
+        return 0;
+    };
+    shapePrun[getIdxForShape(0x0db66db)] = 0;
+    shapePrun[getIdxForShape(0x1db6db6)] = 0;
+    shapePrun[getIdxForShape(0x16db6db)] = 0;
+    shapePrun[getIdxForShape(0x06dbdb6)] = 0;
+    let done = 4;
+    let done0 = 0;
+    let depth = -1;
+    while (done !== done0) {
+        done0 = done;
+        depth++;
+        for (let i = 0; i < 3678 * 2; i++) {
+            if (shapePrun[i] !== depth)
+                continue;
+            // twist
+            const idxTwist = shapeTwistMove[i];
+            if (shapePrun[idxTwist] === -1) {
+                done++;
+                shapePrun[idxTwist] = depth + 1;
+            }
+            // top moves
+            for (let m = 0, inc = 0, idx = i; m !== 12; m += inc) {
+                const topVal = shapeTopMove[idx];
+                inc = topVal & 0xf;
+                idx = topVal >> 4;
+                if (shapePrun[idx] === -1) {
+                    done++;
+                    shapePrun[idx] = depth + 1;
+                }
+            }
+            // bottom moves
+            for (let m = 0, inc = 0, idx = i; m !== 12; m += inc) {
+                const botVal = shapeBottomMove[idx];
+                inc = botVal & 0xf;
+                idx = botVal >> 4;
+                if (shapePrun[idx] === -1) {
+                    done++;
+                    shapePrun[idx] = depth + 1;
+                }
+            }
+        }
+    }
+    return {
+        shapeIdx,
+        shapePrun,
+        shapeTopMove,
+        shapeBottomMove,
+        shapeTwistMove
+    };
+}

package/dist/puzzles/sq1/solver/square.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Permutation tables and distance pruning for Square-1 in Cube/Cube shape (Phase 2).
+ */
+export declare function generateSquareTables(): {
+    squarePrun: Int8Array;
+    squareTwistMove: Uint16Array;
+    squareTopMove: Uint16Array;
+    squareBottomMove: Uint16Array;
+};
+//# sourceMappingURL=square.d.ts.map

package/dist/puzzles/sq1/solver/square.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"square.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/square.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,wBAAgB,oBAAoB,IAAI;IACtC,UAAU,EAAE,SAAS,CAAC;IACtB,eAAe,EAAE,WAAW,CAAC;IAC7B,aAAa,EAAE,WAAW,CAAC;IAC3B,gBAAgB,EAAE,WAAW,CAAC;CAC/B,CAkFA"}

package/dist/puzzles/sq1/solver/square.js

@@ -0,0 +1,90 @@
+/**
+ * Permutation tables and distance pruning for Square-1 in Cube/Cube shape (Phase 2).
+ */
+import { set8Perm, get8Perm } from "./full-cube.js";
+export function generateSquareTables() {
+    const squarePrun = new Int8Array(40320 * 2);
+    const squareTwistMove = new Uint16Array(40320);
+    const squareTopMove = new Uint16Array(40320);
+    const squareBottomMove = new Uint16Array(40320);
+    const pos = new Uint8Array(8);
+    for (let i = 0; i < 40320; i++) {
+        // twist
+        set8Perm(pos, i);
+        let temp = pos[2];
+        pos[2] = pos[4];
+        pos[4] = temp;
+        temp = pos[3];
+        pos[3] = pos[5];
+        pos[5] = temp;
+        squareTwistMove[i] = get8Perm(pos);
+        // top layer turn
+        set8Perm(pos, i);
+        temp = pos[0];
+        pos[0] = pos[1];
+        pos[1] = pos[2];
+        pos[2] = pos[3];
+        pos[3] = temp;
+        squareTopMove[i] = get8Perm(pos);
+        // bottom layer turn
+        set8Perm(pos, i);
+        temp = pos[4];
+        pos[4] = pos[5];
+        pos[5] = pos[6];
+        pos[6] = pos[7];
+        pos[7] = temp;
+        squareBottomMove[i] = get8Perm(pos);
+    }
+    squarePrun.fill(-1);
+    squarePrun[0] = 0;
+    let sqDepth = 0;
+    let sqDone = 1;
+    while (sqDone < 40320 * 2) {
+        const inv = sqDepth >= 11;
+        const find = inv ? -1 : sqDepth;
+        const check = inv ? sqDepth : -1;
+        sqDepth++;
+        OUTER: for (let i = 0; i < 40320 * 2; i++) {
+            if (squarePrun[i] !== find)
+                continue;
+            let perm = i >> 1;
+            const ml = i & 1;
+            // twist
+            const idx = (squareTwistMove[perm] << 1) | (1 - ml);
+            if (squarePrun[idx] === check) {
+                sqDone++;
+                squarePrun[inv ? i : idx] = sqDepth;
+                if (inv)
+                    continue OUTER;
+            }
+            // top layer turns
+            for (let m = 0; m < 4; m++) {
+                perm = squareTopMove[perm];
+                const idxTop = (perm << 1) | ml;
+                if (squarePrun[idxTop] === check) {
+                    sqDone++;
+                    squarePrun[inv ? i : idxTop] = sqDepth;
+                    if (inv)
+                        continue OUTER;
+                }
+            }
+            // bottom layer turns
+            for (let m = 0; m < 4; m++) {
+                perm = squareBottomMove[perm];
+                const idxBot = (perm << 1) | ml;
+                if (squarePrun[idxBot] === check) {
+                    sqDone++;
+                    squarePrun[inv ? i : idxBot] = sqDepth;
+                    if (inv)
+                        continue OUTER;
+                }
+            }
+        }
+    }
+    return {
+        squarePrun,
+        squareTwistMove,
+        squareTopMove,
+        squareBottomMove
+    };
+}

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

@@ -0,0 +1,48 @@
+export declare const SQ1_SOLVER_TABLE_METADATA: {
+    readonly shapeIdx: {
+        readonly entries: 3678;
+        readonly file: "shape-idx.bin";
+        readonly checksum: 3187990008;
+    };
+    readonly shapePrun: {
+        readonly entries: 7356;
+        readonly file: "shape-prun.bin";
+        readonly checksum: 2116325776;
+    };
+    readonly shapeTopMove: {
+        readonly entries: 7356;
+        readonly file: "shape-top-move.bin";
+        readonly checksum: 4112891337;
+    };
+    readonly shapeBottomMove: {
+        readonly entries: 7356;
+        readonly file: "shape-bottom-move.bin";
+        readonly checksum: 161984121;
+    };
+    readonly shapeTwistMove: {
+        readonly entries: 7356;
+        readonly file: "shape-twist-move.bin";
+        readonly checksum: 694153781;
+    };
+    readonly squareTwistMove: {
+        readonly entries: 40320;
+        readonly file: "square-twist-move.bin";
+        readonly checksum: 4150758597;
+    };
+    readonly squareTopMove: {
+        readonly entries: 40320;
+        readonly file: "square-top-move.bin";
+        readonly checksum: 1003750981;
+    };
+    readonly squareBottomMove: {
+        readonly entries: 40320;
+        readonly file: "square-bottom-move.bin";
+        readonly checksum: 2028613829;
+    };
+    readonly squarePrun: {
+        readonly entries: 80640;
+        readonly file: "square-prun.bin";
+        readonly checksum: 1475475221;
+    };
+};
+//# sourceMappingURL=table-metadata.d.ts.map

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

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

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

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

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

@@ -0,0 +1,17 @@
+export interface Square1SolverTables {
+    shapeIdx: Int32Array;
+    shapePrun: Int8Array;
+    shapeTopMove: Int32Array;
+    shapeBottomMove: Int32Array;
+    shapeTwistMove: Int32Array;
+    squareTwistMove: Uint16Array;
+    squareTopMove: Uint16Array;
+    squareBottomMove: Uint16Array;
+    squarePrun: Int8Array;
+}
+export declare function areSquare1TablesLoaded(): boolean;
+export declare function getSquare1SolverTablesSync(): Square1SolverTables;
+export declare function ensureSquare1TablesLoaded(baseUrl?: string): Promise<Square1SolverTables>;
+export declare function generateSquare1SolverTables(): Square1SolverTables;
+export declare function setCachedSquare1Tables(tables: Square1SolverTables): void;
+//# sourceMappingURL=tables.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"tables.d.ts","sourceRoot":"","sources":["../../../../src/puzzles/sq1/solver/tables.ts"],"names":[],"mappings":"AAGA,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,UAAU,CAAC;IACrB,SAAS,EAAE,SAAS,CAAC;IACrB,YAAY,EAAE,UAAU,CAAC;IACzB,eAAe,EAAE,UAAU,CAAC;IAC5B,cAAc,EAAE,UAAU,CAAC;IAC3B,eAAe,EAAE,WAAW,CAAC;IAC7B,aAAa,EAAE,WAAW,CAAC;IAC3B,gBAAgB,EAAE,WAAW,CAAC;IAC9B,UAAU,EAAE,SAAS,CAAC;CACvB;AAKD,wBAAgB,sBAAsB,IAAI,OAAO,CAEhD;AAED,wBAAgB,0BAA0B,IAAI,mBAAmB,CAgBhE;AAED,wBAAsB,yBAAyB,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAyB9F;AAED,wBAAgB,2BAA2B,IAAI,mBAAmB,CAejE;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,mBAAmB,GAAG,IAAI,CAExE"}