cubegin 0.0.1

package/dist/scramble-puzzle/src/cube/cube-state2.mjs

@@ -0,0 +1,187 @@
+import { InvalidMoveError } from "../errors2.mjs";
+//#region .build/vendor/scramble-puzzle/src/cube/cube-state.ts
+const CUBE_FACES = [
+	"R",
+	"U",
+	"F",
+	"L",
+	"D",
+	"B"
+];
+const faceIndex = (face) => CUBE_FACES.indexOf(face);
+const isCubeFace = (face) => typeof face === "string" && CUBE_FACES.includes(face);
+const isMoveAmount = (amount) => amount === 1 || amount === 2 || amount === 3;
+const oppositeFace = (face) => CUBE_FACES[(faceIndex(face) + 3) % CUBE_FACES.length];
+const cloneCubeImage = (image) => image.map((face) => face.map((row) => [...row]));
+const freezeCubeImage = (image) => {
+	const frozenFaces = image.map((face) => {
+		const frozenRows = face.map((row) => Object.freeze([...row]));
+		return Object.freeze(frozenRows);
+	});
+	return Object.freeze(frozenFaces);
+};
+const createCubeState = (size, image) => Object.freeze({
+	size,
+	image: freezeCubeImage(image)
+});
+const swap = (image, first, second, third, fourth, direction) => {
+	const [firstFace, firstRow, firstColumn] = first;
+	const [secondFace, secondRow, secondColumn] = second;
+	const [thirdFace, thirdRow, thirdColumn] = third;
+	const [fourthFace, fourthRow, fourthColumn] = fourth;
+	if (direction === 1) {
+		const firstSticker = image[firstFace][firstRow][firstColumn];
+		image[firstFace][firstRow][firstColumn] = image[secondFace][secondRow][secondColumn];
+		image[secondFace][secondRow][secondColumn] = image[thirdFace][thirdRow][thirdColumn];
+		image[thirdFace][thirdRow][thirdColumn] = image[fourthFace][fourthRow][fourthColumn];
+		image[fourthFace][fourthRow][fourthColumn] = firstSticker;
+	} else {
+		const fourthSticker = image[fourthFace][fourthRow][fourthColumn];
+		image[fourthFace][fourthRow][fourthColumn] = image[thirdFace][thirdRow][thirdColumn];
+		image[thirdFace][thirdRow][thirdColumn] = image[secondFace][secondRow][secondColumn];
+		image[secondFace][secondRow][secondColumn] = image[firstFace][firstRow][firstColumn];
+		image[firstFace][firstRow][firstColumn] = fourthSticker;
+	}
+};
+const rotateFace = (image, face, direction) => {
+	const size = image[0].length;
+	const facePosition = faceIndex(face);
+	const rowLimit = Math.floor((size + 1) / 2);
+	const columnLimit = Math.floor(size / 2);
+	for (let row = 0; row < rowLimit; row += 1) for (let column = 0; column < columnLimit; column += 1) {
+		const cycle = [
+			[
+				facePosition,
+				row,
+				column
+			],
+			[
+				facePosition,
+				column,
+				size - 1 - row
+			],
+			[
+				facePosition,
+				size - 1 - row,
+				size - 1 - column
+			],
+			[
+				facePosition,
+				size - 1 - column,
+				row
+			]
+		];
+		if (direction === 1) swap(image, cycle[0], cycle[1], cycle[2], cycle[3], 1);
+		else swap(image, cycle[0], cycle[1], cycle[2], cycle[3], 3);
+	}
+};
+const slice = (face, sliceIndex, image) => {
+	const size = image[0].length;
+	let sliceFace = face;
+	let stateSliceIndex = sliceIndex;
+	let direction = 1;
+	if (face !== "L" && face !== "D" && face !== "B") {
+		sliceFace = oppositeFace(face);
+		stateSliceIndex = size - 1 - sliceIndex;
+		direction = 3;
+	}
+	for (let position = 0; position < size; position += 1) if (sliceFace === "L") swap(image, [
+		faceIndex("U"),
+		position,
+		stateSliceIndex
+	], [
+		faceIndex("B"),
+		size - 1 - position,
+		size - 1 - stateSliceIndex
+	], [
+		faceIndex("D"),
+		position,
+		stateSliceIndex
+	], [
+		faceIndex("F"),
+		position,
+		stateSliceIndex
+	], direction);
+	else if (sliceFace === "D") swap(image, [
+		faceIndex("L"),
+		size - 1 - stateSliceIndex,
+		position
+	], [
+		faceIndex("B"),
+		size - 1 - stateSliceIndex,
+		position
+	], [
+		faceIndex("R"),
+		size - 1 - stateSliceIndex,
+		position
+	], [
+		faceIndex("F"),
+		size - 1 - stateSliceIndex,
+		position
+	], direction);
+	else swap(image, [
+		faceIndex("U"),
+		stateSliceIndex,
+		position
+	], [
+		faceIndex("R"),
+		position,
+		size - 1 - stateSliceIndex
+	], [
+		faceIndex("D"),
+		size - 1 - stateSliceIndex,
+		size - 1 - position
+	], [
+		faceIndex("L"),
+		size - 1 - position,
+		stateSliceIndex
+	], direction);
+	if (sliceIndex === 0) rotateFace(image, face, 3);
+	else if (sliceIndex === size - 1) rotateFace(image, oppositeFace(face), 1);
+};
+const moveSuffix = (amount) => {
+	if (amount === 2) return "2";
+	if (amount === 3) return "'";
+	return "";
+};
+const MALFORMED_MOVE = "<malformed>";
+const rotationName = (face) => {
+	if (face === "R") return "x";
+	if (face === "U") return "y";
+	if (face === "F") return "z";
+	return face;
+};
+const moveToString = (move) => {
+	if (move.isRotation) return `${rotationName(move.face)}${moveSuffix(move.amount)}`;
+	if (move.width === 1) return `${move.face}${moveSuffix(move.amount)}`;
+	if (move.width === 2) return `${move.face}w${moveSuffix(move.amount)}`;
+	return `${move.width}${move.face}w${moveSuffix(move.amount)}`;
+};
+const validateMove = (state, move) => {
+	if (typeof move !== "object" || move === null || !isCubeFace(move.face) || !isMoveAmount(move.amount) || typeof move.isRotation !== "boolean") throw new InvalidMoveError(MALFORMED_MOVE, "cube");
+	if (move.isRotation) {
+		if (move.width !== Number.POSITIVE_INFINITY || move.face !== "R" && move.face !== "U" && move.face !== "F") throw new InvalidMoveError(MALFORMED_MOVE, "cube");
+		return move;
+	}
+	if (!Number.isSafeInteger(move.width)) throw new InvalidMoveError(MALFORMED_MOVE, "cube");
+	if (move.width < 1 || move.width > state.size) throw new InvalidMoveError(moveToString(move), "cube");
+	return move;
+};
+const createSolvedCubeState = (size) => {
+	if (!Number.isSafeInteger(size) || size < 1) throw new RangeError(`cube size must be a positive integer: ${size}`);
+	return createCubeState(size, CUBE_FACES.map((face) => Array.from({ length: size }, () => Array(size).fill(face))));
+};
+const applyCubeMove = (state, move) => {
+	const validMove = validateMove(state, move);
+	const nextImage = cloneCubeImage(state.image);
+	const width = validMove.isRotation ? state.size : validMove.width;
+	for (let turn = 0; turn < validMove.amount; turn += 1) for (let sliceIndex = 0; sliceIndex < width; sliceIndex += 1) slice(validMove.face, sliceIndex, nextImage);
+	return createCubeState(state.size, nextImage);
+};
+const areCubeStatesEqual = (a, b) => {
+	if (a.size !== b.size) return false;
+	for (let face = 0; face < CUBE_FACES.length; face += 1) for (let row = 0; row < a.size; row += 1) for (let column = 0; column < a.size; column += 1) if (a.image[face][row][column] !== b.image[face][row][column]) return false;
+	return true;
+};
+//#endregion
+export { applyCubeMove, areCubeStatesEqual, createSolvedCubeState };

package/dist/scramble-puzzle/src/errors.d.mts

@@ -0,0 +1,15 @@
+//#region .build/vendor/scramble-puzzle/src/errors.d.ts
+declare class ScramblePuzzleError extends Error {
+  constructor(message: string, options?: ErrorOptions);
+}
+declare class InvalidMoveError extends ScramblePuzzleError {
+  constructor(move: string, puzzleId: string);
+}
+declare class InvalidScrambleError extends ScramblePuzzleError {
+  constructor(scramble: string, cause: unknown);
+}
+declare class UnregisteredPuzzleError extends ScramblePuzzleError {
+  constructor(eventId: string, options?: ErrorOptions);
+}
+//#endregion
+export { InvalidMoveError, InvalidScrambleError, ScramblePuzzleError, UnregisteredPuzzleError };

package/dist/scramble-puzzle/src/errors.mjs

@@ -0,0 +1,24 @@
+//#region ../scramble-puzzle/src/errors.ts
+const ERROR_PREFIX = "@cubegin/scramble-puzzle";
+const withPrefix = (message) => `${ERROR_PREFIX}: ${message}`;
+var ScramblePuzzleError = class extends Error {
+	constructor(message, options) {
+		super(withPrefix(message), options);
+		this.name = "ScramblePuzzleError";
+	}
+};
+var InvalidMoveError = class extends ScramblePuzzleError {
+	constructor(move, puzzleId) {
+		super(`move '${move}' is invalid for puzzle '${puzzleId}'`);
+		this.name = "InvalidMoveError";
+	}
+};
+var InvalidScrambleError = class extends ScramblePuzzleError {
+	constructor(scramble, cause) {
+		const causeMessage = cause instanceof Error ? cause.message : String(cause);
+		super(`scramble '${scramble}' is invalid: ${causeMessage}`, { cause });
+		this.name = "InvalidScrambleError";
+	}
+};
+//#endregion
+export { InvalidMoveError, InvalidScrambleError, ScramblePuzzleError };

package/dist/scramble-puzzle/src/errors2.mjs

@@ -0,0 +1,30 @@
+//#region .build/vendor/scramble-puzzle/src/errors.ts
+const ERROR_PREFIX = "@cubegin/scramble-puzzle";
+const withPrefix = (message) => `${ERROR_PREFIX}: ${message}`;
+var ScramblePuzzleError = class extends Error {
+	constructor(message, options) {
+		super(withPrefix(message), options);
+		this.name = "ScramblePuzzleError";
+	}
+};
+var InvalidMoveError = class extends ScramblePuzzleError {
+	constructor(move, puzzleId) {
+		super(`move '${move}' is invalid for puzzle '${puzzleId}'`);
+		this.name = "InvalidMoveError";
+	}
+};
+var InvalidScrambleError = class extends ScramblePuzzleError {
+	constructor(scramble, cause) {
+		const causeMessage = cause instanceof Error ? cause.message : String(cause);
+		super(`scramble '${scramble}' is invalid: ${causeMessage}`, { cause });
+		this.name = "InvalidScrambleError";
+	}
+};
+var UnregisteredPuzzleError = class extends ScramblePuzzleError {
+	constructor(eventId, options) {
+		super(`event '${eventId}' is not registered`, options);
+		this.name = "UnregisteredPuzzleError";
+	}
+};
+//#endregion
+export { InvalidMoveError, InvalidScrambleError, ScramblePuzzleError, UnregisteredPuzzleError };

package/dist/scramble-puzzle/src/events.d.mts

@@ -0,0 +1,5 @@
+//#region ../scramble-puzzle/src/events.d.ts
+declare const WCA_EVENT_IDS: readonly ["333", "222", "444", "555", "666", "777", "333bld", "333fm", "333oh", "clock", "minx", "pyram", "skewb", "sq1", "444bld", "555bld", "333mbld"];
+type WcaEventId = (typeof WCA_EVENT_IDS)[number];
+//#endregion
+export { WcaEventId };

package/dist/scramble-puzzle/src/events.mjs

@@ -0,0 +1,90 @@
+//#region ../scramble-puzzle/src/events.ts
+const WCA_EVENT_INFO = Object.freeze({
+	"333": {
+		id: "333",
+		label: "3x3x3 Cube",
+		puzzleId: "cube"
+	},
+	"222": {
+		id: "222",
+		label: "2x2x2 Cube",
+		puzzleId: "cube"
+	},
+	"444": {
+		id: "444",
+		label: "4x4x4 Cube",
+		puzzleId: "cube"
+	},
+	"555": {
+		id: "555",
+		label: "5x5x5 Cube",
+		puzzleId: "cube"
+	},
+	"666": {
+		id: "666",
+		label: "6x6x6 Cube",
+		puzzleId: "cube"
+	},
+	"777": {
+		id: "777",
+		label: "7x7x7 Cube",
+		puzzleId: "cube"
+	},
+	"333bld": {
+		id: "333bld",
+		label: "3x3 Blindfolded",
+		puzzleId: "cube"
+	},
+	"333fm": {
+		id: "333fm",
+		label: "3x3 Fewest Moves",
+		puzzleId: "cube"
+	},
+	"333oh": {
+		id: "333oh",
+		label: "3x3 One-Handed",
+		puzzleId: "cube"
+	},
+	clock: {
+		id: "clock",
+		label: "Clock",
+		puzzleId: "clock"
+	},
+	minx: {
+		id: "minx",
+		label: "Megaminx",
+		puzzleId: "megaminx"
+	},
+	pyram: {
+		id: "pyram",
+		label: "Pyraminx",
+		puzzleId: "pyraminx"
+	},
+	skewb: {
+		id: "skewb",
+		label: "Skewb",
+		puzzleId: "skewb"
+	},
+	sq1: {
+		id: "sq1",
+		label: "Square-1",
+		puzzleId: "square1"
+	},
+	"444bld": {
+		id: "444bld",
+		label: "4x4 Blindfolded",
+		puzzleId: "cube"
+	},
+	"555bld": {
+		id: "555bld",
+		label: "5x5 Blindfolded",
+		puzzleId: "cube"
+	},
+	"333mbld": {
+		id: "333mbld",
+		label: "3x3 Multi-Blind",
+		puzzleId: "cube"
+	}
+});
+//#endregion
+export { WCA_EVENT_INFO };

package/dist/scramble-puzzle/src/events2.d.mts

@@ -0,0 +1,98 @@
+//#region .build/vendor/scramble-puzzle/src/events.d.ts
+declare const WCA_EVENT_IDS: readonly ["333", "222", "444", "555", "666", "777", "333bld", "333fm", "333oh", "clock", "minx", "pyram", "skewb", "sq1", "444bld", "555bld", "333mbld"];
+type WcaEventId = (typeof WCA_EVENT_IDS)[number];
+type PuzzleId = 'cube' | 'clock' | 'megaminx' | 'pyraminx' | 'skewb' | 'square1';
+interface WcaEventInfo {
+  readonly id: WcaEventId;
+  readonly label: string;
+  readonly puzzleId: PuzzleId;
+}
+declare const WCA_EVENT_INFO: Readonly<{
+  '333': {
+    id: "333";
+    label: string;
+    puzzleId: "cube";
+  };
+  '222': {
+    id: "222";
+    label: string;
+    puzzleId: "cube";
+  };
+  '444': {
+    id: "444";
+    label: string;
+    puzzleId: "cube";
+  };
+  '555': {
+    id: "555";
+    label: string;
+    puzzleId: "cube";
+  };
+  '666': {
+    id: "666";
+    label: string;
+    puzzleId: "cube";
+  };
+  '777': {
+    id: "777";
+    label: string;
+    puzzleId: "cube";
+  };
+  '333bld': {
+    id: "333bld";
+    label: string;
+    puzzleId: "cube";
+  };
+  '333fm': {
+    id: "333fm";
+    label: string;
+    puzzleId: "cube";
+  };
+  '333oh': {
+    id: "333oh";
+    label: string;
+    puzzleId: "cube";
+  };
+  clock: {
+    id: "clock";
+    label: string;
+    puzzleId: "clock";
+  };
+  minx: {
+    id: "minx";
+    label: string;
+    puzzleId: "megaminx";
+  };
+  pyram: {
+    id: "pyram";
+    label: string;
+    puzzleId: "pyraminx";
+  };
+  skewb: {
+    id: "skewb";
+    label: string;
+    puzzleId: "skewb";
+  };
+  sq1: {
+    id: "sq1";
+    label: string;
+    puzzleId: "square1";
+  };
+  '444bld': {
+    id: "444bld";
+    label: string;
+    puzzleId: "cube";
+  };
+  '555bld': {
+    id: "555bld";
+    label: string;
+    puzzleId: "cube";
+  };
+  '333mbld': {
+    id: "333mbld";
+    label: string;
+    puzzleId: "cube";
+  };
+}>;
+//#endregion
+export { PuzzleId, WCA_EVENT_IDS, WCA_EVENT_INFO, WcaEventId, WcaEventInfo };

package/dist/scramble-puzzle/src/events2.mjs

@@ -0,0 +1,109 @@
+//#region .build/vendor/scramble-puzzle/src/events.ts
+const WCA_EVENT_IDS = [
+	"333",
+	"222",
+	"444",
+	"555",
+	"666",
+	"777",
+	"333bld",
+	"333fm",
+	"333oh",
+	"clock",
+	"minx",
+	"pyram",
+	"skewb",
+	"sq1",
+	"444bld",
+	"555bld",
+	"333mbld"
+];
+const WCA_EVENT_INFO = Object.freeze({
+	"333": {
+		id: "333",
+		label: "3x3x3 Cube",
+		puzzleId: "cube"
+	},
+	"222": {
+		id: "222",
+		label: "2x2x2 Cube",
+		puzzleId: "cube"
+	},
+	"444": {
+		id: "444",
+		label: "4x4x4 Cube",
+		puzzleId: "cube"
+	},
+	"555": {
+		id: "555",
+		label: "5x5x5 Cube",
+		puzzleId: "cube"
+	},
+	"666": {
+		id: "666",
+		label: "6x6x6 Cube",
+		puzzleId: "cube"
+	},
+	"777": {
+		id: "777",
+		label: "7x7x7 Cube",
+		puzzleId: "cube"
+	},
+	"333bld": {
+		id: "333bld",
+		label: "3x3 Blindfolded",
+		puzzleId: "cube"
+	},
+	"333fm": {
+		id: "333fm",
+		label: "3x3 Fewest Moves",
+		puzzleId: "cube"
+	},
+	"333oh": {
+		id: "333oh",
+		label: "3x3 One-Handed",
+		puzzleId: "cube"
+	},
+	clock: {
+		id: "clock",
+		label: "Clock",
+		puzzleId: "clock"
+	},
+	minx: {
+		id: "minx",
+		label: "Megaminx",
+		puzzleId: "megaminx"
+	},
+	pyram: {
+		id: "pyram",
+		label: "Pyraminx",
+		puzzleId: "pyraminx"
+	},
+	skewb: {
+		id: "skewb",
+		label: "Skewb",
+		puzzleId: "skewb"
+	},
+	sq1: {
+		id: "sq1",
+		label: "Square-1",
+		puzzleId: "square1"
+	},
+	"444bld": {
+		id: "444bld",
+		label: "4x4 Blindfolded",
+		puzzleId: "cube"
+	},
+	"555bld": {
+		id: "555bld",
+		label: "5x5 Blindfolded",
+		puzzleId: "cube"
+	},
+	"333mbld": {
+		id: "333mbld",
+		label: "3x3 Multi-Blind",
+		puzzleId: "cube"
+	}
+});
+//#endregion
+export { WCA_EVENT_IDS, WCA_EVENT_INFO };

package/dist/scramble-puzzle/src/index.mjs

@@ -0,0 +1,22 @@
+import "./events.mjs";
+import "./errors.mjs";
+import "./algorithm.mjs";
+import "./cube/cube-parser.mjs";
+import "./cube/cube-state.mjs";
+import "./cube/cube-definition.mjs";
+import "./clock/clock-parser.mjs";
+import "./clock/clock-state.mjs";
+import "./clock/clock-definition.mjs";
+import "./megaminx/megaminx-parser.mjs";
+import "./megaminx/megaminx-state.mjs";
+import "./megaminx/megaminx-definition.mjs";
+import "./pyraminx/pyraminx-parser.mjs";
+import "./pyraminx/pyraminx-state.mjs";
+import "./pyraminx/pyraminx-definition.mjs";
+import "./skewb/skewb-parser.mjs";
+import "./skewb/skewb-state.mjs";
+import "./skewb/skewb-definition.mjs";
+import "./square1/square1-parser.mjs";
+import "./square1/square1-state.mjs";
+import "./square1/square1-definition.mjs";
+export {};

package/dist/scramble-puzzle/src/megaminx/megaminx-definition.d.mts

@@ -0,0 +1,8 @@
+import { PuzzleDefinition } from "../puzzle-definition.mjs";
+import { MegaminxMove } from "./megaminx-parser2.mjs";
+import { MegaminxState } from "./megaminx-state2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/megaminx/megaminx-definition.d.ts
+declare const createMegaminxDefinition: () => PuzzleDefinition<MegaminxState, MegaminxMove>;
+//#endregion
+export { createMegaminxDefinition };

package/dist/scramble-puzzle/src/megaminx/megaminx-definition.mjs

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm.mjs";
+import { parseMegaminxAlgorithm } from "./megaminx-parser.mjs";
+import { applyMegaminxMove, areMegaminxStatesEqual, createSolvedMegaminxState } from "./megaminx-state.mjs";
+//#region ../scramble-puzzle/src/megaminx/megaminx-definition.ts
+const createMegaminxDefinition = () => {
+	const definition = {
+		id: "megaminx",
+		eventIds: ["minx"],
+		createSolvedState: createSolvedMegaminxState,
+		parseAlgorithm: parseMegaminxAlgorithm,
+		applyMove: applyMegaminxMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areMegaminxStatesEqual(state, createSolvedMegaminxState())
+	};
+	return definition;
+};
+//#endregion
+export { createMegaminxDefinition };

package/dist/scramble-puzzle/src/megaminx/megaminx-definition2.mjs

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm2.mjs";
+import { parseMegaminxAlgorithm } from "./megaminx-parser2.mjs";
+import { applyMegaminxMove, areMegaminxStatesEqual, createSolvedMegaminxState } from "./megaminx-state2.mjs";
+//#region .build/vendor/scramble-puzzle/src/megaminx/megaminx-definition.ts
+const createMegaminxDefinition = () => {
+	const definition = {
+		id: "megaminx",
+		eventIds: ["minx"],
+		createSolvedState: createSolvedMegaminxState,
+		parseAlgorithm: parseMegaminxAlgorithm,
+		applyMove: applyMegaminxMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areMegaminxStatesEqual(state, createSolvedMegaminxState())
+	};
+	return definition;
+};
+//#endregion
+export { createMegaminxDefinition };

package/dist/scramble-puzzle/src/megaminx/megaminx-parser.d.mts

@@ -0,0 +1,5 @@
+//#region ../scramble-puzzle/src/megaminx/megaminx-parser.d.ts
+declare const MEGAMINX_FACES: readonly ["U", "BL", "BR", "R", "F", "L", "D", "DR", "DBR", "B", "DBL", "DL"];
+type MegaminxFace = (typeof MEGAMINX_FACES)[number];
+//#endregion
+export { MegaminxFace };