cubegin 0.0.1

package/NOTICE

@@ -0,0 +1,11 @@
+cubegin
+
+This package re-exports Cubegin TNoodle-compatible scramble packages:
+
+- @cubegin/scramble-core
+- @cubegin/scramble-image
+- @cubegin/scramble-puzzle
+
+Those packages port behavior from thewca/tnoodle-lib lib-scrambles v0.19.2,
+which is distributed under GPL-v3.0. Cubegin is not an official WCA scramble
+program.

package/README.md

@@ -0,0 +1,49 @@
+# cubegin
+
+Public Cubegin npm entrypoints for TNoodle-compatible scramble generation,
+scramble SVG rendering, and puzzle notation/state helpers.
+
+The package intentionally does not expose a root API. Import one of the
+published subpaths instead:
+
+```ts
+import { createDefaultScrambleGenerator } from 'cubegin/scramble-core';
+import { renderScrambleImage } from 'cubegin/scramble-image';
+import { WCA_EVENT_IDS } from 'cubegin/scramble-puzzle';
+```
+
+## Entrypoints
+
+- `cubegin/scramble-core` bundles the `@cubegin/scramble-core` implementation.
+- `cubegin/scramble-image` bundles the `@cubegin/scramble-image` implementation.
+- `cubegin/scramble-puzzle` bundles the `@cubegin/scramble-puzzle` implementation.
+
+The package root is reserved and not listed in `exports`.
+
+## Adding Entrypoints
+
+Add a `cubegin.publicSubpath` field to the source package:
+
+```json
+{
+  "cubegin": {
+    "publicSubpath": "scramble-core"
+  }
+}
+```
+
+`pnpm --filter cubegin build` scans those markers, syncs `exports`, vendors the
+source package into a temporary build tree, and emits module-split ESM under
+`dist`.
+
+## Development
+
+```bash
+pnpm --filter cubegin test
+pnpm --filter cubegin typecheck
+pnpm --filter cubegin build
+```
+
+## License
+
+GPL-3.0-only. See [`LICENSE`](./LICENSE) and [`NOTICE`](./NOTICE).

package/dist/scramble-core/src/batch.mjs

@@ -0,0 +1,18 @@
+//#region .build/vendor/scramble-core/src/batch.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const generateUniqueScrambleBatch = async (count, generate, options = {}) => {
+	if (!Number.isSafeInteger(count) || count < 0) throw new Error(`${ERROR_PREFIX}: batch count must be a non-negative safe integer`);
+	const maxAttempts = options.maxAttempts ?? Math.max(count * 10, 100);
+	const results = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (let attempts = 0; results.length < count && attempts < maxAttempts; attempts += 1) {
+		const scrambleResult = await generate();
+		if (seen.has(scrambleResult.scramble)) continue;
+		seen.add(scrambleResult.scramble);
+		results.push(scrambleResult);
+	}
+	if (results.length < count) throw new Error(`${ERROR_PREFIX}: generated ${results.length} unique scrambles after ${maxAttempts} attempts`);
+	return results;
+};
+//#endregion
+export { generateUniqueScrambleBatch };

package/dist/scramble-core/src/generator.d.mts

@@ -0,0 +1,35 @@
+import { WcaEventId } from "../../scramble-puzzle/src/events.mjs";
+import { RandomSource } from "./random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generator.d.ts
+interface GenerateOptions {
+  random?: RandomSource;
+  multiBlindCubeCount?: number;
+}
+interface ScrambleResult {
+  eventId: WcaEventId;
+  scramble: string;
+}
+type EventScrambleGenerator = (options: GenerateOptions & {
+  random: RandomSource;
+}) => ScrambleResult | Promise<ScrambleResult>;
+interface ScrambleGeneratorOptions {
+  random: RandomSource;
+  generators: Partial<Record<WcaEventId, EventScrambleGenerator>>;
+}
+interface DefaultScrambleGeneratorOptions {
+  random: RandomSource;
+}
+interface ScrambleGenerator {
+  generate(eventId: WcaEventId, options?: GenerateOptions): Promise<ScrambleResult>;
+  generateBatch(eventId: WcaEventId, count: number, options?: GenerateOptions): Promise<readonly ScrambleResult[]>;
+}
+declare const createScrambleGenerator: ({
+  random,
+  generators
+}: ScrambleGeneratorOptions) => ScrambleGenerator;
+declare const createDefaultScrambleGenerator: ({
+  random
+}: DefaultScrambleGeneratorOptions) => ScrambleGenerator;
+//#endregion
+export { DefaultScrambleGeneratorOptions, EventScrambleGenerator, GenerateOptions, ScrambleGenerator, ScrambleGeneratorOptions, ScrambleResult, createDefaultScrambleGenerator, createScrambleGenerator };

package/dist/scramble-core/src/generator.mjs

@@ -0,0 +1,136 @@
+import { generateUniqueScrambleBatch } from "./batch.mjs";
+import { generateClockScramble } from "./generators/clock.mjs";
+import { generateCubeRandomTurnScramble } from "./generators/cube-random-turns.mjs";
+import { generateFourByFourNoInspectionScramble, generateFourByFourScramble } from "./generators/four-by-four.mjs";
+import { generateMegaminxScramble } from "./generators/megaminx.mjs";
+import { generatePyraminxScramble } from "./generators/pyraminx.mjs";
+import { generateSkewbScramble } from "./generators/skewb.mjs";
+import { generateSquareOneScramble } from "./generators/square1.mjs";
+import { generateMultiBlindScramble, generateThreeByThreeFewestMovesScramble, generateThreeByThreeNoInspectionScramble, generateThreeByThreeScramble } from "./generators/three-by-three.mjs";
+import { generateTwoByTwoScramble } from "./generators/two-by-two.mjs";
+//#region .build/vendor/scramble-core/src/generator.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const createScrambleGenerator = ({ random, generators }) => {
+	const api = {
+		async generate(eventId, options = {}) {
+			const generator = generators[eventId];
+			if (!generator) throw new Error(`${ERROR_PREFIX}: event '${eventId}' has no generator`);
+			return await generator({
+				...options,
+				random: options.random ?? random
+			});
+		},
+		async generateBatch(eventId, count, options = {}) {
+			return generateUniqueScrambleBatch(count, () => api.generate(eventId, options));
+		}
+	};
+	return api;
+};
+const createDefaultScrambleGenerator = ({ random }) => createScrambleGenerator({
+	random,
+	generators: DEFAULT_GENERATORS
+});
+const DEFAULT_GENERATORS = {
+	333: ({ random }) => result("333", generateThreeByThreeScramble({ random })),
+	222: ({ random }) => result("222", generateTwoByTwoScramble({ random })),
+	444: ({ random }) => result("444", generateFourByFourScramble({ random })),
+	555: ({ random }) => result("555", generateCubeRandomTurnScramble({
+		random,
+		size: 5,
+		length: 60
+	})),
+	666: ({ random }) => result("666", generateCubeRandomTurnScramble({
+		random,
+		size: 6,
+		length: 80
+	})),
+	777: ({ random }) => result("777", generateCubeRandomTurnScramble({
+		random,
+		size: 7,
+		length: 100
+	})),
+	"333bld": ({ random }) => result("333bld", generateThreeByThreeNoInspectionScramble({ random })),
+	"333fm": ({ random }) => result("333fm", generateThreeByThreeFewestMovesScramble({ random })),
+	"333oh": ({ random }) => result("333oh", generateThreeByThreeScramble({ random })),
+	clock: ({ random }) => result("clock", generateClockScramble({ random })),
+	minx: ({ random }) => result("minx", generateMegaminxScramble({ random })),
+	pyram: ({ random }) => result("pyram", generatePyraminxScramble({ random })),
+	skewb: ({ random }) => result("skewb", generateSkewbScramble({ random })),
+	sq1: ({ random }) => result("sq1", generateSquareOneScramble({ random })),
+	"444bld": ({ random }) => result("444bld", generateFourByFourNoInspectionScramble({ random })),
+	"555bld": ({ random }) => result("555bld", generateFiveByFiveNoInspectionScramble(random)),
+	"333mbld": ({ random, multiBlindCubeCount }) => {
+		if (multiBlindCubeCount === void 0) throw new Error(`${ERROR_PREFIX}: event '333mbld' requires multiBlindCubeCount`);
+		return result("333mbld", generateMultiBlindScramble({
+			random,
+			cubeCount: multiBlindCubeCount
+		}));
+	}
+};
+const FIVE_BY_FIVE_NO_INSPECTION_ORIENTATION_SEQUENCES = [
+	[],
+	["3Uw"],
+	["3Uw2"],
+	["3Uw'"],
+	["3Rw"],
+	["3Rw", "3Uw"],
+	["3Rw", "3Uw2"],
+	["3Rw", "3Uw'"],
+	["3Rw2"],
+	["3Rw2", "3Uw"],
+	["3Rw2", "3Uw2"],
+	["3Rw2", "3Uw'"],
+	["3Rw'"],
+	["3Rw'", "3Uw"],
+	["3Rw'", "3Uw2"],
+	["3Rw'", "3Uw'"],
+	["3Fw"],
+	["3Fw", "3Uw"],
+	["3Fw", "3Uw2"],
+	["3Fw", "3Uw'"],
+	["3Fw'"],
+	["3Fw'", "3Uw"],
+	["3Fw'", "3Uw2"],
+	["3Fw'", "3Uw'"]
+];
+const generateFiveByFiveNoInspectionScramble = (random) => {
+	const orientation = chooseFiveByFiveOrientation(random);
+	return [...trimRedundantTail(generateCubeRandomTurnScramble({
+		random,
+		size: 5,
+		length: 60
+	}), orientation[0]), ...orientation].join(" ");
+};
+const chooseFiveByFiveOrientation = (random) => {
+	const index = random.nextInt(FIVE_BY_FIVE_NO_INSPECTION_ORIENTATION_SEQUENCES.length);
+	const orientation = FIVE_BY_FIVE_NO_INSPECTION_ORIENTATION_SEQUENCES[index];
+	if (orientation === void 0) throw new RangeError(`${ERROR_PREFIX}: random source returned ${index} for max ${FIVE_BY_FIVE_NO_INSPECTION_ORIENTATION_SEQUENCES.length}`);
+	return orientation;
+};
+const trimRedundantTail = (scramble, firstOrientationMove) => {
+	const moves = scramble.trim().length === 0 ? [] : scramble.trim().split(/\s+/);
+	const orientationAxis = firstOrientationMove === void 0 ? void 0 : axisForMove(firstOrientationMove);
+	while (moves.length > 0 && orientationAxis !== void 0 && axisForMove(moves.at(-1)) === orientationAxis) moves.pop();
+	return moves;
+};
+const axisForMove = (move) => {
+	const match = move.match(/(?:\d+)?([RUFLDB])w?|([xyz])/);
+	switch (match?.[1] ?? match?.[2]) {
+		case "R":
+		case "L":
+		case "x": return 0;
+		case "U":
+		case "D":
+		case "y": return 1;
+		case "F":
+		case "B":
+		case "z": return 2;
+		default: return;
+	}
+};
+const result = (eventId, scramble) => ({
+	eventId,
+	scramble
+});
+//#endregion
+export { createDefaultScrambleGenerator, createScrambleGenerator };

package/dist/scramble-core/src/generators/clock.d.mts

@@ -0,0 +1,11 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/clock.d.ts
+interface ClockScrambleOptions {
+  random: RandomSource;
+}
+declare const generateClockScramble: ({
+  random
+}: ClockScrambleOptions) => string;
+//#endregion
+export { ClockScrambleOptions, generateClockScramble };

package/dist/scramble-core/src/generators/clock.mjs

@@ -0,0 +1,32 @@
+//#region .build/vendor/scramble-core/src/generators/clock.ts
+const CLOCK_FIRST_SIDE_MOVES = [
+	"UR",
+	"DR",
+	"DL",
+	"UL",
+	"U",
+	"R",
+	"D",
+	"L",
+	"ALL"
+];
+const CLOCK_SECOND_SIDE_MOVES = [
+	"U",
+	"R",
+	"D",
+	"L",
+	"ALL"
+];
+const nextClockTurn = (move, random) => {
+	const turn = random.nextInt(12) - 5;
+	return `${move}${Math.abs(turn)}${turn >= 0 ? "+" : "-"}`;
+};
+const generateClockScramble = ({ random }) => {
+	return [
+		...CLOCK_FIRST_SIDE_MOVES.map((move) => nextClockTurn(move, random)),
+		"y2",
+		...CLOCK_SECOND_SIDE_MOVES.map((move) => nextClockTurn(move, random))
+	].join(" ");
+};
+//#endregion
+export { generateClockScramble };

package/dist/scramble-core/src/generators/cube-random-turns.d.mts

@@ -0,0 +1,11 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/cube-random-turns.d.ts
+interface CubeRandomTurnOptions {
+  size: number;
+  length: number;
+  random: RandomSource;
+}
+declare const generateCubeRandomTurnScramble: (options: CubeRandomTurnOptions) => string;
+//#endregion
+export { CubeRandomTurnOptions, generateCubeRandomTurnScramble };

package/dist/scramble-core/src/generators/cube-random-turns.mjs

@@ -0,0 +1,54 @@
+//#region .build/vendor/scramble-core/src/generators/cube-random-turns.ts
+const FACES = [
+	"R",
+	"U",
+	"F",
+	"L",
+	"D",
+	"B"
+];
+const SUFFIXES = [
+	"",
+	"2",
+	"'"
+];
+const SUPPORTED_SIZES = new Set([
+	5,
+	6,
+	7
+]);
+const FACE_CHOICES = FACES.map((face, index) => ({
+	face,
+	axis: index % 3
+}));
+const validateOptions = ({ size, length }) => {
+	if (!Number.isSafeInteger(size) || !SUPPORTED_SIZES.has(size)) throw new Error("@cubegin/scramble-core: cube random-turn size must be 5, 6, or 7");
+	if (!Number.isSafeInteger(length) || length < 0) throw new Error("@cubegin/scramble-core: cube random-turn length must be a non-negative safe integer");
+};
+const chooseFace = (previousAxis, random) => {
+	const allowedFaces = previousAxis === void 0 ? FACE_CHOICES : FACE_CHOICES.filter(({ axis }) => axis !== previousAxis);
+	return allowedFaces[random.nextInt(allowedFaces.length)];
+};
+const chooseWideFace = (face, size, random) => {
+	const maxWidth = Math.floor(size / 2);
+	const width = random.nextInt(maxWidth) + 1;
+	if (width === 1) return face;
+	if (width === 2) return `${face}w`;
+	return `${width}${face}w`;
+};
+const generateCubeRandomTurnScramble = (options) => {
+	validateOptions(options);
+	const { size, length, random } = options;
+	const moves = [];
+	let previousAxis;
+	while (moves.length < length) {
+		const { axis, face } = chooseFace(previousAxis, random);
+		previousAxis = axis;
+		const wideFace = chooseWideFace(face, size, random);
+		const suffix = SUFFIXES[random.nextInt(SUFFIXES.length)];
+		moves.push(`${wideFace}${suffix}`);
+	}
+	return moves.join(" ");
+};
+//#endregion
+export { generateCubeRandomTurnScramble };

package/dist/scramble-core/src/generators/four-by-four.d.mts

@@ -0,0 +1,14 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/four-by-four.d.ts
+interface FourByFourScrambleOptions {
+  random: RandomSource;
+}
+declare const generateFourByFourScramble: ({
+  random
+}: FourByFourScrambleOptions) => string;
+declare const generateFourByFourNoInspectionScramble: ({
+  random
+}: FourByFourScrambleOptions) => string;
+//#endregion
+export { FourByFourScrambleOptions, generateFourByFourNoInspectionScramble, generateFourByFourScramble };

package/dist/scramble-core/src/generators/four-by-four.mjs

@@ -0,0 +1,43 @@
+import { Search } from "../solvers/threephase/search.mjs";
+//#region .build/vendor/scramble-core/src/generators/four-by-four.ts
+const ORIENTATION_SEQUENCES = [
+	[],
+	["y"],
+	["y2"],
+	["y'"],
+	["x"],
+	["x", "y"],
+	["x", "y2"],
+	["x", "y'"],
+	["x2"],
+	["x2", "y"],
+	["x2", "y2"],
+	["x2", "y'"],
+	["x'"],
+	["x'", "y"],
+	["x'", "y2"],
+	["x'", "y'"],
+	["z"],
+	["z", "y"],
+	["z", "y2"],
+	["z", "y'"],
+	["z'"],
+	["z'", "y"],
+	["z'", "y2"],
+	["z'", "y'"]
+];
+const generateFourByFourScramble = ({ random }) => {
+	return new Search().randomState(random).trim();
+};
+const generateFourByFourNoInspectionScramble = ({ random }) => {
+	const orientation = chooseOrientation(random);
+	return [...generateFourByFourScramble({ random }).split(/\s+/), ...orientation].join(" ").trim();
+};
+const chooseOrientation = (random) => {
+	const index = random.nextInt(ORIENTATION_SEQUENCES.length);
+	const orientation = ORIENTATION_SEQUENCES[index];
+	if (orientation === void 0) throw new RangeError(`@cubegin/scramble-core: random source returned ${index} for max ${ORIENTATION_SEQUENCES.length}`);
+	return orientation;
+};
+//#endregion
+export { generateFourByFourNoInspectionScramble, generateFourByFourScramble };

package/dist/scramble-core/src/generators/megaminx.d.mts

@@ -0,0 +1,11 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/megaminx.d.ts
+interface MegaminxScrambleOptions {
+  random: RandomSource;
+}
+declare const generateMegaminxScramble: ({
+  random
+}: MegaminxScrambleOptions) => string;
+//#endregion
+export { MegaminxScrambleOptions, generateMegaminxScramble };

package/dist/scramble-core/src/generators/megaminx.mjs

@@ -0,0 +1,18 @@
+//#region .build/vendor/scramble-core/src/generators/megaminx.ts
+const generateMegaminxScramble = ({ random }) => {
+	const rows = [];
+	for (let row = 0; row < 7; row += 1) {
+		const moves = [];
+		let lastDirection = 0;
+		for (let column = 0; column < 10; column += 1) {
+			const side = column % 2 === 0 ? "R" : "D";
+			lastDirection = random.nextInt(2);
+			moves.push(`${side}${lastDirection === 0 ? "++" : "--"}`);
+		}
+		moves.push(lastDirection === 0 ? "U" : "U'");
+		rows.push(moves.join(" "));
+	}
+	return rows.join("\n");
+};
+//#endregion
+export { generateMegaminxScramble };

package/dist/scramble-core/src/generators/pyraminx.d.mts

@@ -0,0 +1,11 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/pyraminx.d.ts
+interface PyraminxScrambleOptions {
+  random: RandomSource;
+}
+declare const generatePyraminxScramble: ({
+  random
+}: PyraminxScrambleOptions) => string;
+//#endregion
+export { PyraminxScrambleOptions, generatePyraminxScramble };

package/dist/scramble-core/src/generators/pyraminx.mjs

@@ -0,0 +1,17 @@
+import { PyraminxSolver } from "../solvers/pyraminx-solver.mjs";
+//#region .build/vendor/scramble-core/src/generators/pyraminx.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const SCRAMBLE_LENGTH = 11;
+const WCA_MIN_SCRAMBLE_DISTANCE = 6;
+const MAX_WCA_ATTEMPTS = 100;
+const generatePyraminxScramble = ({ random }) => {
+	const solver = new PyraminxSolver();
+	for (let attempt = 0; attempt < MAX_WCA_ATTEMPTS; attempt += 1) {
+		const state = solver.randomState(random);
+		if (solver.solveIn(state, WCA_MIN_SCRAMBLE_DISTANCE - 1, true, random) !== null) continue;
+		return solver.generateExactly(state, SCRAMBLE_LENGTH, false, random);
+	}
+	throw new Error(`${ERROR_PREFIX}: could not generate a Pyraminx WCA scramble after ${MAX_WCA_ATTEMPTS} attempts`);
+};
+//#endregion
+export { generatePyraminxScramble };

package/dist/scramble-core/src/generators/skewb.d.mts

@@ -0,0 +1,11 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/skewb.d.ts
+interface SkewbScrambleOptions {
+  random: RandomSource;
+}
+declare const generateSkewbScramble: ({
+  random
+}: SkewbScrambleOptions) => string;
+//#endregion
+export { SkewbScrambleOptions, generateSkewbScramble };

package/dist/scramble-core/src/generators/skewb.mjs

@@ -0,0 +1,17 @@
+import { SkewbSolver } from "../solvers/skewb-solver.mjs";
+//#region .build/vendor/scramble-core/src/generators/skewb.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const SCRAMBLE_LENGTH = 11;
+const WCA_MIN_SCRAMBLE_DISTANCE = 7;
+const MAX_WCA_ATTEMPTS = 100;
+const generateSkewbScramble = ({ random }) => {
+	const solver = new SkewbSolver();
+	for (let attempt = 0; attempt < MAX_WCA_ATTEMPTS; attempt += 1) {
+		const state = solver.randomState(random);
+		if (solver.solveIn(state, WCA_MIN_SCRAMBLE_DISTANCE - 1, random) !== null) continue;
+		return solver.generateExactly(state, SCRAMBLE_LENGTH, random);
+	}
+	throw new Error(`${ERROR_PREFIX}: could not generate a Skewb WCA scramble after ${MAX_WCA_ATTEMPTS} attempts`);
+};
+//#endregion
+export { generateSkewbScramble };

package/dist/scramble-core/src/generators/square1.d.mts

@@ -0,0 +1,11 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/square1.d.ts
+interface SquareOneScrambleOptions {
+  random: RandomSource;
+}
+declare const generateSquareOneScramble: ({
+  random
+}: SquareOneScrambleOptions) => string;
+//#endregion
+export { SquareOneScrambleOptions, generateSquareOneScramble };

package/dist/scramble-core/src/generators/square1.mjs

@@ -0,0 +1,28 @@
+import { parseSquareOneAlgorithm } from "../../../scramble-puzzle/src/square1/square1-parser.mjs";
+import { applySquareOneMove, createSolvedSquareOneState } from "../../../scramble-puzzle/src/square1/square1-state.mjs";
+import "../../../scramble-puzzle/src/index.mjs";
+import { FullCube } from "../solvers/sq12phase/full-cube.mjs";
+import { Search, solveSquareOneStateIn } from "../solvers/sq12phase/search.mjs";
+//#region .build/vendor/scramble-core/src/generators/square1.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const WCA_MIN_SCRAMBLE_DISTANCE = 11;
+const MAX_WCA_ATTEMPTS = 100;
+const generateSquareOneScramble = ({ random }) => {
+	const search = new Search();
+	for (let attempt = 0; attempt < MAX_WCA_ATTEMPTS; attempt += 1) {
+		const randomState = FullCube.randomCube(random);
+		const solution = search.solution(randomState, 2);
+		if (solution === null) continue;
+		const scramble = solution.trim();
+		if (solveSquareOneStateIn(applyScrambleToSolvedState(scramble), WCA_MIN_SCRAMBLE_DISTANCE - 1) !== null) continue;
+		return scramble;
+	}
+	throw new Error(`${ERROR_PREFIX}: could not generate a Square-1 WCA scramble after ${MAX_WCA_ATTEMPTS} attempts`);
+};
+const applyScrambleToSolvedState = (scramble) => {
+	let state = createSolvedSquareOneState();
+	for (const move of parseSquareOneAlgorithm(scramble)) state = applySquareOneMove(state, move);
+	return state;
+};
+//#endregion
+export { generateSquareOneScramble };

package/dist/scramble-core/src/generators/three-by-three.d.mts

@@ -0,0 +1,25 @@
+import { RandomSource } from "../random-source.mjs";
+
+//#region .build/vendor/scramble-core/src/generators/three-by-three.d.ts
+interface ThreeByThreeScrambleOptions {
+  random: RandomSource;
+}
+interface MultiBlindScrambleOptions {
+  random: RandomSource;
+  cubeCount: number;
+}
+declare const generateThreeByThreeScramble: ({
+  random
+}: ThreeByThreeScrambleOptions) => string;
+declare const generateThreeByThreeNoInspectionScramble: ({
+  random
+}: ThreeByThreeScrambleOptions) => string;
+declare const generateThreeByThreeFewestMovesScramble: ({
+  random
+}: ThreeByThreeScrambleOptions) => string;
+declare const generateMultiBlindScramble: ({
+  random,
+  cubeCount
+}: MultiBlindScrambleOptions) => string;
+//#endregion
+export { MultiBlindScrambleOptions, ThreeByThreeScrambleOptions, generateMultiBlindScramble, generateThreeByThreeFewestMovesScramble, generateThreeByThreeNoInspectionScramble, generateThreeByThreeScramble };