@cubingcenter/scrambler 0.1.0

package/dist-cjs/puzzles/cube3/subset-state.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSubsetCube3State = generateSubsetCube3State;
+const state_js_1 = require("./state.js");
+// The indices for the U layer pieces are 0, 1, 2, 3.
+function generateSubsetCube3State(subset, random) {
+    const state = (0, state_js_1.createSolvedCube3State)();
+    if (subset === "pll") {
+        shuffleULayerPermutations(state, random);
+    }
+    else if (subset === "oll" || subset === "ll") {
+        shuffleULayerPermutations(state, random);
+        randomizeULayerOrientations(state, random, true, true);
+    }
+    else if (subset === "zbll") {
+        shuffleULayerPermutations(state, random);
+        randomizeULayerOrientations(state, random, true, false); // corners only
+    }
+    else if (subset === "lsll") {
+        shuffleLSLL(state, random);
+    }
+    else if (subset === "f2l") {
+        shuffleF2L(state, random);
+    }
+    else if (subset === "cross") {
+        shuffleFullCube(state, random);
+    }
+    else {
+        throw new Error(`Subset "${subset}" is not supported yet.`);
+    }
+    return state;
+}
+function shuffleULayerPermutations(state, random) {
+    const cornerPerm = [0, 1, 2, 3];
+    const edgePerm = [0, 1, 2, 3];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    for (let i = 0; i < 4; i++) {
+        state.corners.permutation[i] = cornerPerm[i];
+        state.edges.permutation[i] = edgePerm[i];
+    }
+}
+function randomizeULayerOrientations(state, random, corners, edges) {
+    if (corners) {
+        let sum = 0;
+        for (let i = 0; i < 3; i++) {
+            const o = random.nextInt(3);
+            state.corners.orientation[i] = o;
+            sum += o;
+        }
+        state.corners.orientation[3] = (3 - (sum % 3)) % 3;
+    }
+    if (edges) {
+        let sum = 0;
+        for (let i = 0; i < 3; i++) {
+            const o = random.nextInt(2);
+            state.edges.orientation[i] = o;
+            sum += o;
+        }
+        state.edges.orientation[3] = (2 - (sum % 2)) % 2;
+    }
+}
+function shuffle(array, random) {
+    for (let i = array.length - 1; i > 0; i--) {
+        const j = random.nextInt(i + 1);
+        swap(array, i, j);
+    }
+}
+function swap(array, i, j) {
+    const temp = array[i];
+    array[i] = array[j];
+    array[j] = temp;
+}
+function getParity(array) {
+    let inversions = 0;
+    for (let i = 0; i < array.length; i++) {
+        for (let j = i + 1; j < array.length; j++) {
+            if (array[i] > array[j]) {
+                inversions++;
+            }
+        }
+    }
+    return inversions % 2;
+}
+function shuffleLSLL(state, random) {
+    const cornerPerm = [0, 1, 2, 3, 4];
+    const edgePerm = [0, 1, 2, 3, 8];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    const cornerIndices = [0, 1, 2, 3, 4];
+    for (let i = 0; i < cornerIndices.length; i++) {
+        const idx = cornerIndices[i];
+        state.corners.permutation[idx] = cornerPerm[i];
+        state.corners.orientation[idx] = random.nextInt(3);
+    }
+    let cornerSum = 0;
+    for (let i = 0; i < 8; i++)
+        cornerSum += state.corners.orientation[i];
+    state.corners.orientation[4] = (state.corners.orientation[4] + (3 - (cornerSum % 3))) % 3;
+    const edgeIndices = [0, 1, 2, 3, 8];
+    for (let i = 0; i < edgeIndices.length; i++) {
+        const idx = edgeIndices[i];
+        state.edges.permutation[idx] = edgePerm[i];
+        state.edges.orientation[idx] = random.nextInt(2);
+    }
+    let edgeSum = 0;
+    for (let i = 0; i < 12; i++)
+        edgeSum += state.edges.orientation[i];
+    state.edges.orientation[8] = (state.edges.orientation[8] + (2 - (edgeSum % 2))) % 2;
+}
+function shuffleF2L(state, random) {
+    const cornerPerm = [0, 1, 2, 3, 4, 5, 6, 7];
+    const edgePerm = [0, 1, 2, 3, 8, 9, 10, 11];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    const edgeIndices = [0, 1, 2, 3, 8, 9, 10, 11];
+    for (let i = 0; i < 8; i++) {
+        state.corners.permutation[i] = cornerPerm[i];
+        state.corners.orientation[i] = random.nextInt(3);
+        const idx = edgeIndices[i];
+        state.edges.permutation[idx] = edgePerm[i];
+        state.edges.orientation[idx] = random.nextInt(2);
+    }
+    let cornerSum = 0;
+    for (let i = 0; i < 8; i++)
+        cornerSum += state.corners.orientation[i];
+    state.corners.orientation[0] = (state.corners.orientation[0] + (3 - (cornerSum % 3))) % 3;
+    let edgeSum = 0;
+    for (let i = 0; i < 12; i++)
+        edgeSum += state.edges.orientation[i];
+    state.edges.orientation[0] = (state.edges.orientation[0] + (2 - (edgeSum % 2))) % 2;
+}
+function shuffleFullCube(state, random) {
+    const cornerPerm = [0, 1, 2, 3, 4, 5, 6, 7];
+    const edgePerm = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
+    shuffle(cornerPerm, random);
+    shuffle(edgePerm, random);
+    if (getParity(cornerPerm) !== getParity(edgePerm)) {
+        swap(edgePerm, 0, 1);
+    }
+    for (let i = 0; i < 8; i++) {
+        state.corners.permutation[i] = cornerPerm[i];
+        state.corners.orientation[i] = random.nextInt(3);
+    }
+    for (let i = 0; i < 12; i++) {
+        state.edges.permutation[i] = edgePerm[i];
+        state.edges.orientation[i] = random.nextInt(2);
+    }
+    let cornerSum = 0;
+    for (let i = 0; i < 8; i++)
+        cornerSum += state.corners.orientation[i];
+    state.corners.orientation[0] = (state.corners.orientation[0] + (3 - (cornerSum % 3))) % 3;
+    let edgeSum = 0;
+    for (let i = 0; i < 12; i++)
+        edgeSum += state.edges.orientation[i];
+    state.edges.orientation[0] = (state.edges.orientation[0] + (2 - (edgeSum % 2))) % 2;
+}

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

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

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

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCube3State = validateCube3State;
+exports.isOneMoveFromSolvedCube3State = isOneMoveFromSolvedCube3State;
+exports.isAllowedRandomCube3State = isAllowedRandomCube3State;
+exports.permutationParity = permutationParity;
+const types_js_1 = require("./types.js");
+const moves_js_1 = require("./moves.js");
+const state_js_1 = require("./state.js");
+function validateCube3State(state) {
+    const errors = [
+        ...validatePermutation("corner", state.corners.permutation, types_js_1.CORNER_COUNT),
+        ...validatePermutation("edge", state.edges.permutation, types_js_1.EDGE_COUNT),
+        ...validateOrientations("corner", state.corners.orientation, types_js_1.CORNER_COUNT, 3),
+        ...validateOrientations("edge", state.edges.orientation, types_js_1.EDGE_COUNT, 2)
+    ];
+    if (errors.length === 0) {
+        const cornerOrientation = sum(state.corners.orientation) % 3;
+        const edgeOrientation = sum(state.edges.orientation) % 2;
+        const cornerParity = permutationParity(state.corners.permutation);
+        const edgeParity = permutationParity(state.edges.permutation);
+        if (cornerOrientation !== 0) {
+            errors.push("Corner orientation sum must be divisible by 3.");
+        }
+        if (edgeOrientation !== 0) {
+            errors.push("Edge orientation sum must be divisible by 2.");
+        }
+        if (cornerParity !== edgeParity) {
+            errors.push("Corner and edge permutation parity must match.");
+        }
+    }
+    return {
+        valid: errors.length === 0,
+        errors
+    };
+}
+function isOneMoveFromSolvedCube3State(state) {
+    const solved = (0, state_js_1.createSolvedCube3State)();
+    return types_js_1.CUBE3_MOVES.some((move) => (0, state_js_1.cube3StatesEqual)((0, moves_js_1.applyCube3Move)(solved, move), state));
+}
+function isAllowedRandomCube3State(state) {
+    return validateCube3State(state).valid &&
+        !(0, state_js_1.isSolvedCube3State)(state) &&
+        !isOneMoveFromSolvedCube3State(state);
+}
+function permutationParity(permutation) {
+    let inversions = 0;
+    for (let left = 0; left < permutation.length; left += 1) {
+        for (let right = left + 1; right < permutation.length; right += 1) {
+            if (permutation[left] > permutation[right]) {
+                inversions += 1;
+            }
+        }
+    }
+    return (inversions % 2);
+}
+function validatePermutation(label, permutation, length) {
+    const errors = [];
+    const seen = new Set();
+    if (permutation.length !== length) {
+        errors.push(`${label} permutation must contain ${length} values.`);
+    }
+    for (const value of permutation) {
+        if (!Number.isInteger(value) || value < 0 || value >= length) {
+            errors.push(`${label} permutation contains out-of-range value: ${value}.`);
+            continue;
+        }
+        if (seen.has(value)) {
+            errors.push(`${label} permutation contains duplicate value: ${value}.`);
+        }
+        seen.add(value);
+    }
+    return errors;
+}
+function validateOrientations(label, orientations, length, modulo) {
+    const errors = [];
+    if (orientations.length !== length) {
+        errors.push(`${label} orientation must contain ${length} values.`);
+    }
+    for (const value of orientations) {
+        if (!Number.isInteger(value) || value < 0 || value >= modulo) {
+            errors.push(`${label} orientation contains out-of-range value: ${value}.`);
+        }
+    }
+    return errors;
+}
+function sum(values) {
+    return values.reduce((total, value) => total + value, 0);
+}

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

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCube4Facelets = toCube4Facelets;
+exports.formatCube4Facelets = formatCube4Facelets;
+exports.getCube4FaceOrder = getCube4FaceOrder;
+const types_js_1 = require("./types.js");
+const FACE_ORDER = ["U", "R", "F", "D", "L", "B"];
+const FACE_LETTERS = FACE_ORDER;
+const CENTER_SLOTS = [5, 6, 9, 10];
+// ---------------------------------------------------------------------------
+// Corner piece sticker colors (by piece identity 0-7, same as 3x3)
+// ---------------------------------------------------------------------------
+const CORNER_PIECE_STICKERS = [
+    ["U", "R", "F"], // 0 = URF
+    ["U", "F", "L"], // 1 = UFL
+    ["U", "L", "B"], // 2 = ULB
+    ["U", "B", "R"], // 3 = UBR
+    ["D", "F", "R"], // 4 = DFR
+    ["D", "L", "F"], // 5 = DLF
+    ["D", "B", "L"], // 6 = DBL
+    ["D", "R", "B"], // 7 = DRB
+];
+const CORNER_POSITION_SLOTS = [
+    [["U", 15], ["R", 0], ["F", 3]], // 0 = URF
+    [["U", 12], ["F", 0], ["L", 3]], // 1 = UFL
+    [["U", 0], ["L", 0], ["B", 3]], // 2 = ULB
+    [["U", 3], ["B", 0], ["R", 3]], // 3 = UBR
+    [["D", 3], ["F", 15], ["R", 12]], // 4 = DFR
+    [["D", 0], ["L", 15], ["F", 12]], // 5 = DLF
+    [["D", 12], ["B", 15], ["L", 12]], // 6 = DBL
+    [["D", 15], ["R", 15], ["B", 12]], // 7 = DRB
+];
+// ---------------------------------------------------------------------------
+// Wing piece color pairs (by wing identity 0-23)
+// Wings 2k and 2k+1 share the same colors (they form a 3x3-edge pair).
+// ---------------------------------------------------------------------------
+const WING_PIECE_COLORS = [
+    ["U", "R"], ["U", "R"], //  0, 1  UR pair
+    ["U", "F"], ["U", "F"], //  2, 3  UF pair
+    ["U", "L"], ["U", "L"], //  4, 5  UL pair
+    ["U", "B"], ["U", "B"], //  6, 7  UB pair
+    ["D", "R"], ["D", "R"], //  8, 9  DR pair
+    ["D", "F"], ["D", "F"], // 10, 11 DF pair
+    ["D", "L"], ["D", "L"], // 12, 13 DL pair
+    ["D", "B"], ["D", "B"], // 14, 15 DB pair
+    ["F", "R"], ["F", "R"], // 16, 17 FR pair
+    ["F", "L"], ["F", "L"], // 18, 19 FL pair
+    ["B", "L"], ["B", "L"], // 20, 21 BL pair
+    ["B", "R"], ["B", "R"], // 22, 23 BR pair
+];
+const WING_POSITION_SLOTS = [
+    [["U", 11], ["R", 1]], //  0  URf
+    [["U", 7], ["R", 2]], //  1  URb
+    [["U", 14], ["F", 2]], //  2  UFr
+    [["U", 13], ["F", 1]], //  3  UFl
+    [["U", 8], ["L", 2]], //  4  ULf
+    [["U", 4], ["L", 1]], //  5  ULb
+    [["U", 1], ["B", 2]], //  6  UBl
+    [["U", 2], ["B", 1]], //  7  UBr
+    [["D", 7], ["R", 13]], //  8  DRf
+    [["D", 11], ["R", 14]], //  9  DRb
+    [["D", 2], ["F", 14]], // 10  DFr
+    [["D", 1], ["F", 13]], // 11  DFl
+    [["D", 4], ["L", 14]], // 12  DLf
+    [["D", 8], ["L", 13]], // 13  DLb
+    [["D", 13], ["B", 14]], // 14  DBl
+    [["D", 14], ["B", 13]], // 15  DBr
+    [["F", 7], ["R", 4]], // 16  FRu
+    [["F", 11], ["R", 8]], // 17  FRd
+    [["F", 4], ["L", 7]], // 18  FLu
+    [["F", 8], ["L", 11]], // 19  FLd
+    [["B", 7], ["L", 4]], // 20  BLu
+    [["B", 11], ["L", 8]], // 21  BLd
+    [["B", 4], ["R", 7]], // 22  BRu
+    [["B", 8], ["R", 11]], // 23  BRd
+];
+// ---------------------------------------------------------------------------
+// toCube4Facelets
+// ---------------------------------------------------------------------------
+function toCube4Facelets(state) {
+    const f = {
+        U: Array(16).fill("U"),
+        R: Array(16).fill("R"),
+        F: Array(16).fill("F"),
+        D: Array(16).fill("D"),
+        L: Array(16).fill("L"),
+        B: Array(16).fill("B"),
+    };
+    // Centers
+    for (let i = 0; i < types_js_1.CENTER_COUNT; i++) {
+        const face = FACE_LETTERS[Math.floor(i / 4)];
+        const slot = CENTER_SLOTS[i % 4];
+        f[face][slot] = FACE_LETTERS[state.centers[i]];
+    }
+    // Corners
+    for (let pos = 0; pos < types_js_1.CORNER_COUNT; pos++) {
+        const piece = state.cp[pos];
+        const ori = state.co[pos];
+        const slots = CORNER_POSITION_SLOTS[pos];
+        const stickers = CORNER_PIECE_STICKERS[piece];
+        for (let i = 0; i < slots.length; i++) {
+            const [face, idx] = slots[i];
+            f[face][idx] = stickers[(i - ori + stickers.length) % stickers.length];
+        }
+    }
+    // Wings: Recover orientation mathematically using XOR orbit parity!
+    // A wing is physically flipped if its chiral group (Left/Right) differs from the slot's chiral group.
+    const RIGHT_GROUP = new Set([1, 2, 4, 6, 8, 11, 13, 15, 16, 19, 20, 23]);
+    for (let pos = 0; pos < types_js_1.WING_COUNT; pos++) {
+        const piece = state.wp[pos];
+        const slots = WING_POSITION_SLOTS[pos];
+        const colors = WING_PIECE_COLORS[piece];
+        const [f0, i0] = slots[0];
+        const [f1, i1] = slots[1];
+        const wingIsRight = RIGHT_GROUP.has(piece);
+        const slotIsRight = RIGHT_GROUP.has(pos);
+        const isFlipped = wingIsRight !== slotIsRight;
+        if (isFlipped) {
+            f[f0][i0] = colors[1]; // Secondary color to primary slot sticker
+            f[f1][i1] = colors[0]; // Primary color to secondary slot sticker
+        }
+        else {
+            f[f0][i0] = colors[0]; // Primary color to primary slot sticker
+            f[f1][i1] = colors[1]; // Secondary color to secondary slot sticker
+        }
+    }
+    return f;
+}
+// ---------------------------------------------------------------------------
+// formatCube4Facelets
+// ---------------------------------------------------------------------------
+function formatCube4Facelets(facelets) {
+    return FACE_ORDER.map((face) => facelets[face].join("")).join("");
+}
+// ---------------------------------------------------------------------------
+// getCube4FaceOrder
+// ---------------------------------------------------------------------------
+function getCube4FaceOrder() {
+    return FACE_ORDER;
+}

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

@@ -0,0 +1,45 @@
+"use strict";
+// ---------------------------------------------------------------------------
+// cube4 barrel exports
+// ---------------------------------------------------------------------------
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getCube4FaceOrder = exports.formatCube4Facelets = exports.toCube4Facelets = exports.generateCube4Scramble = exports.cube4ScrambleGenerator = exports.FACE_MOVE_EFFECTS = exports.parseMove = exports.parseCube4Move = exports.parseCube4Algorithm = exports.formatCube4Algorithm = exports.invertCube4Algorithm = exports.invertCube4Move = exports.applyCube4Algorithm = exports.applyCube4Move = exports.areWingsPaired = exports.areCentersReduced = exports.isSolvedCube4State = exports.cube4StatesEqual = exports.cloneCube4State = exports.createSolvedCube4State = exports.CUBE4_OUTER_MOVES = exports.CUBE4_ALL_MOVES = exports.CUBE4_FACE_MOVES = exports.B = exports.L = exports.D = exports.F = exports.R = exports.U = exports.CENTERS_PER_FACE = exports.FACE_COUNT = exports.CENTER_COUNT = exports.WING_COUNT = exports.CORNER_COUNT = void 0;
+var types_js_1 = require("./types.js");
+Object.defineProperty(exports, "CORNER_COUNT", { enumerable: true, get: function () { return types_js_1.CORNER_COUNT; } });
+Object.defineProperty(exports, "WING_COUNT", { enumerable: true, get: function () { return types_js_1.WING_COUNT; } });
+Object.defineProperty(exports, "CENTER_COUNT", { enumerable: true, get: function () { return types_js_1.CENTER_COUNT; } });
+Object.defineProperty(exports, "FACE_COUNT", { enumerable: true, get: function () { return types_js_1.FACE_COUNT; } });
+Object.defineProperty(exports, "CENTERS_PER_FACE", { enumerable: true, get: function () { return types_js_1.CENTERS_PER_FACE; } });
+Object.defineProperty(exports, "U", { enumerable: true, get: function () { return types_js_1.U; } });
+Object.defineProperty(exports, "R", { enumerable: true, get: function () { return types_js_1.R; } });
+Object.defineProperty(exports, "F", { enumerable: true, get: function () { return types_js_1.F; } });
+Object.defineProperty(exports, "D", { enumerable: true, get: function () { return types_js_1.D; } });
+Object.defineProperty(exports, "L", { enumerable: true, get: function () { return types_js_1.L; } });
+Object.defineProperty(exports, "B", { enumerable: true, get: function () { return types_js_1.B; } });
+Object.defineProperty(exports, "CUBE4_FACE_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE4_FACE_MOVES; } });
+Object.defineProperty(exports, "CUBE4_ALL_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE4_ALL_MOVES; } });
+Object.defineProperty(exports, "CUBE4_OUTER_MOVES", { enumerable: true, get: function () { return types_js_1.CUBE4_OUTER_MOVES; } });
+var state_js_1 = require("./state.js");
+Object.defineProperty(exports, "createSolvedCube4State", { enumerable: true, get: function () { return state_js_1.createSolvedCube4State; } });
+Object.defineProperty(exports, "cloneCube4State", { enumerable: true, get: function () { return state_js_1.cloneCube4State; } });
+Object.defineProperty(exports, "cube4StatesEqual", { enumerable: true, get: function () { return state_js_1.cube4StatesEqual; } });
+Object.defineProperty(exports, "isSolvedCube4State", { enumerable: true, get: function () { return state_js_1.isSolvedCube4State; } });
+Object.defineProperty(exports, "areCentersReduced", { enumerable: true, get: function () { return state_js_1.areCentersReduced; } });
+Object.defineProperty(exports, "areWingsPaired", { enumerable: true, get: function () { return state_js_1.areWingsPaired; } });
+var moves_js_1 = require("./moves.js");
+Object.defineProperty(exports, "applyCube4Move", { enumerable: true, get: function () { return moves_js_1.applyCube4Move; } });
+Object.defineProperty(exports, "applyCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.applyCube4Algorithm; } });
+Object.defineProperty(exports, "invertCube4Move", { enumerable: true, get: function () { return moves_js_1.invertCube4Move; } });
+Object.defineProperty(exports, "invertCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.invertCube4Algorithm; } });
+Object.defineProperty(exports, "formatCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.formatCube4Algorithm; } });
+Object.defineProperty(exports, "parseCube4Algorithm", { enumerable: true, get: function () { return moves_js_1.parseCube4Algorithm; } });
+Object.defineProperty(exports, "parseCube4Move", { enumerable: true, get: function () { return moves_js_1.parseCube4Move; } });
+Object.defineProperty(exports, "parseMove", { enumerable: true, get: function () { return moves_js_1.parseMove; } });
+Object.defineProperty(exports, "FACE_MOVE_EFFECTS", { enumerable: true, get: function () { return moves_js_1.FACE_MOVE_EFFECTS; } });
+var scrambler_js_1 = require("./scrambler.js");
+Object.defineProperty(exports, "cube4ScrambleGenerator", { enumerable: true, get: function () { return scrambler_js_1.cube4ScrambleGenerator; } });
+Object.defineProperty(exports, "generateCube4Scramble", { enumerable: true, get: function () { return scrambler_js_1.generateCube4Scramble; } });
+var facelets_js_1 = require("./facelets.js");
+Object.defineProperty(exports, "toCube4Facelets", { enumerable: true, get: function () { return facelets_js_1.toCube4Facelets; } });
+Object.defineProperty(exports, "formatCube4Facelets", { enumerable: true, get: function () { return facelets_js_1.formatCube4Facelets; } });
+Object.defineProperty(exports, "getCube4FaceOrder", { enumerable: true, get: function () { return facelets_js_1.getCube4FaceOrder; } });