cubegin 0.0.1

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

@@ -0,0 +1,212 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { CLOCK_TURN_NAMES } from "./clock-parser2.mjs";
+//#region .build/vendor/scramble-puzzle/src/clock/clock-state.ts
+const MALFORMED_MOVE = "<malformed>";
+const CLOCK_MOVE_DELTAS = new Map([
+	["UR", [
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	]],
+	["DR", [
+		0,
+		0,
+		0,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		0
+	]],
+	["DL", [
+		0,
+		0,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		-1
+	]],
+	["UL", [
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	]],
+	["U", [
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0
+	]],
+	["R", [
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		0
+	]],
+	["D", [
+		0,
+		0,
+		0,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		-1
+	]],
+	["L", [
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		1,
+		1,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		0,
+		0,
+		-1
+	]],
+	["ALL", [
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		1,
+		-1,
+		0,
+		-1,
+		0,
+		0,
+		0,
+		-1,
+		0,
+		-1
+	]]
+]);
+const createClockState = (positions, rightSideUp) => {
+	if (positions.length !== 18) throw new RangeError(`clock state must contain 18 dial positions: ${positions.length}`);
+	return Object.freeze({
+		positions: Object.freeze([...positions]),
+		rightSideUp
+	});
+};
+const validateMove = (move) => {
+	if (typeof move !== "object" || move === null) throw new InvalidMoveError(MALFORMED_MOVE, "clock");
+	if (move.type === "rotation") return move;
+	if (move.type !== "turn" || !CLOCK_TURN_NAMES.includes(move.name) || move.direction !== "+" && move.direction !== "-" || !Number.isSafeInteger(move.amount) || move.amount < 0 || move.amount > 6 || move.direction === "-" && (move.amount === 0 || move.amount === 6)) throw new InvalidMoveError(MALFORMED_MOVE, "clock");
+	return move;
+};
+const moduloClock = (position) => (position % 12 + 12) % 12;
+const createSolvedClockState = () => createClockState(Array(18).fill(0), true);
+const applyClockMove = (state, move) => {
+	const validMove = validateMove(move);
+	if (validMove.type === "rotation") return createClockState([...state.positions.slice(9), ...state.positions.slice(0, 9)], !state.rightSideUp);
+	const deltas = CLOCK_MOVE_DELTAS.get(validMove.name);
+	if (deltas === void 0) throw new InvalidMoveError(MALFORMED_MOVE, "clock");
+	const signedAmount = validMove.direction === "+" ? validMove.amount : -validMove.amount;
+	return createClockState(state.positions.map((position, index) => moduloClock(position + signedAmount * (deltas[index] ?? 0))), state.rightSideUp);
+};
+const areClockStatesEqual = (a, b) => a.rightSideUp === b.rightSideUp && a.positions.every((position, index) => position === b.positions[index]);
+//#endregion
+export { applyClockMove, areClockStatesEqual, createSolvedClockState };

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

@@ -0,0 +1,9 @@
+import { WcaEventId } from "../events2.mjs";
+import { PuzzleDefinition } from "../puzzle-definition.mjs";
+import { CubeMove } from "./cube-move2.mjs";
+import { CubeState } from "./cube-state2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/cube/cube-definition.d.ts
+declare const createCubeDefinition: (size: number, eventIds: readonly WcaEventId[]) => PuzzleDefinition<CubeState, CubeMove>;
+//#endregion
+export { createCubeDefinition };

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm.mjs";
+import { parseCubeAlgorithm } from "./cube-parser.mjs";
+import { applyCubeMove, areCubeStatesEqual, createSolvedCubeState } from "./cube-state.mjs";
+//#region ../scramble-puzzle/src/cube/cube-definition.ts
+const createCubeDefinition = (size, eventIds) => {
+	const definition = {
+		id: `cube-${size}`,
+		eventIds,
+		createSolvedState: () => createSolvedCubeState(size),
+		parseAlgorithm: parseCubeAlgorithm,
+		applyMove: applyCubeMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areCubeStatesEqual(state, createSolvedCubeState(size))
+	};
+	return definition;
+};
+//#endregion
+export { createCubeDefinition };

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm2.mjs";
+import { parseCubeAlgorithm } from "./cube-parser2.mjs";
+import { applyCubeMove, areCubeStatesEqual, createSolvedCubeState } from "./cube-state2.mjs";
+//#region .build/vendor/scramble-puzzle/src/cube/cube-definition.ts
+const createCubeDefinition = (size, eventIds) => {
+	const definition = {
+		id: `cube-${size}`,
+		eventIds,
+		createSolvedState: () => createSolvedCubeState(size),
+		parseAlgorithm: parseCubeAlgorithm,
+		applyMove: applyCubeMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areCubeStatesEqual(state, createSolvedCubeState(size))
+	};
+	return definition;
+};
+//#endregion
+export { createCubeDefinition };

package/dist/scramble-puzzle/src/cube/cube-move.d.mts

@@ -0,0 +1,4 @@
+//#region ../scramble-puzzle/src/cube/cube-move.d.ts
+type CubeFace = 'R' | 'U' | 'F' | 'L' | 'D' | 'B';
+//#endregion
+export { CubeFace };

package/dist/scramble-puzzle/src/cube/cube-move2.d.mts

@@ -0,0 +1,17 @@
+//#region .build/vendor/scramble-puzzle/src/cube/cube-move.d.ts
+type CubeFace = 'R' | 'U' | 'F' | 'L' | 'D' | 'B';
+interface CubeLayerMove {
+  face: CubeFace;
+  amount: 1 | 2 | 3;
+  width: number;
+  isRotation: false;
+}
+interface CubeRotationMove {
+  face: CubeFace;
+  amount: 1 | 2 | 3;
+  width: number;
+  isRotation: true;
+}
+type CubeMove = CubeLayerMove | CubeRotationMove;
+//#endregion
+export { CubeFace, CubeLayerMove, CubeMove, CubeRotationMove };

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

@@ -0,0 +1,7 @@
+import { CubeMove } from "./cube-move2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/cube/cube-parser.d.ts
+declare const parseCubeMove: (token: string) => CubeMove;
+declare const parseCubeAlgorithm: (algorithm: string) => readonly CubeMove[];
+//#endregion
+export { parseCubeAlgorithm, parseCubeMove };

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

@@ -0,0 +1,60 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { splitAlgorithm } from "../algorithm.mjs";
+//#region ../scramble-puzzle/src/cube/cube-parser.ts
+const CUBE_MOVE_PATTERN = /^(?:(\d+)?([RUFLDB])w|([RUFLDB])|([xyz]))(2|')?$/;
+const parseAmount = (suffix) => {
+	if (suffix === "2") return 2;
+	if (suffix === "'") return 3;
+	return 1;
+};
+const parseCubeFace = (face) => {
+	switch (face) {
+		case "R":
+		case "U":
+		case "F":
+		case "L":
+		case "D":
+		case "B": return face;
+		default: return;
+	}
+};
+const parseRotationFace = (rotation) => {
+	switch (rotation) {
+		case "x": return "R";
+		case "y": return "U";
+		case "z": return "F";
+		default: return;
+	}
+};
+const parseWideMoveWidth = (token, prefixWidth) => {
+	if (prefixWidth === void 0) return 2;
+	const width = Number(prefixWidth);
+	if (prefixWidth.startsWith("0") || !Number.isSafeInteger(width) || width < 3) throw new InvalidMoveError(token, "cube");
+	return width;
+};
+const parseCubeMove = (token) => {
+	const match = token.match(CUBE_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "cube");
+	const [, prefixWidth, wideFace, face, rotation, suffix] = match;
+	if (rotation !== void 0) {
+		const rotationFace = parseRotationFace(rotation);
+		if (rotationFace === void 0) throw new InvalidMoveError(token, "cube");
+		return {
+			face: rotationFace,
+			amount: parseAmount(suffix),
+			width: Number.POSITIVE_INFINITY,
+			isRotation: true
+		};
+	}
+	const layerFace = parseCubeFace(wideFace ?? face);
+	if (layerFace === void 0) throw new InvalidMoveError(token, "cube");
+	return {
+		face: layerFace,
+		amount: parseAmount(suffix),
+		width: wideFace ? parseWideMoveWidth(token, prefixWidth) : 1,
+		isRotation: false
+	};
+};
+const parseCubeAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseCubeMove);
+//#endregion
+export { parseCubeAlgorithm, parseCubeMove };

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

@@ -0,0 +1,60 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { splitAlgorithm } from "../algorithm2.mjs";
+//#region .build/vendor/scramble-puzzle/src/cube/cube-parser.ts
+const CUBE_MOVE_PATTERN = /^(?:(\d+)?([RUFLDB])w|([RUFLDB])|([xyz]))(2|')?$/;
+const parseAmount = (suffix) => {
+	if (suffix === "2") return 2;
+	if (suffix === "'") return 3;
+	return 1;
+};
+const parseCubeFace = (face) => {
+	switch (face) {
+		case "R":
+		case "U":
+		case "F":
+		case "L":
+		case "D":
+		case "B": return face;
+		default: return;
+	}
+};
+const parseRotationFace = (rotation) => {
+	switch (rotation) {
+		case "x": return "R";
+		case "y": return "U";
+		case "z": return "F";
+		default: return;
+	}
+};
+const parseWideMoveWidth = (token, prefixWidth) => {
+	if (prefixWidth === void 0) return 2;
+	const width = Number(prefixWidth);
+	if (prefixWidth.startsWith("0") || !Number.isSafeInteger(width) || width < 3) throw new InvalidMoveError(token, "cube");
+	return width;
+};
+const parseCubeMove = (token) => {
+	const match = token.match(CUBE_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "cube");
+	const [, prefixWidth, wideFace, face, rotation, suffix] = match;
+	if (rotation !== void 0) {
+		const rotationFace = parseRotationFace(rotation);
+		if (rotationFace === void 0) throw new InvalidMoveError(token, "cube");
+		return {
+			face: rotationFace,
+			amount: parseAmount(suffix),
+			width: Number.POSITIVE_INFINITY,
+			isRotation: true
+		};
+	}
+	const layerFace = parseCubeFace(wideFace ?? face);
+	if (layerFace === void 0) throw new InvalidMoveError(token, "cube");
+	return {
+		face: layerFace,
+		amount: parseAmount(suffix),
+		width: wideFace ? parseWideMoveWidth(token, prefixWidth) : 1,
+		isRotation: false
+	};
+};
+const parseCubeAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseCubeMove);
+//#endregion
+export { parseCubeAlgorithm, parseCubeMove };

package/dist/scramble-puzzle/src/cube/cube-state.d.mts

@@ -0,0 +1,12 @@
+import { CubeFace } from "./cube-move.mjs";
+
+//#region ../scramble-puzzle/src/cube/cube-state.d.ts
+type CubeFacelet = CubeFace;
+type CubeFaceState = readonly (readonly CubeFacelet[])[];
+type CubeImage = readonly CubeFaceState[];
+interface CubeState {
+  readonly size: number;
+  readonly image: CubeImage;
+}
+//#endregion
+export { CubeFacelet, CubeState };

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

@@ -0,0 +1,187 @@
+import { InvalidMoveError } from "../errors.mjs";
+//#region ../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/cube/cube-state2.d.mts

@@ -0,0 +1,15 @@
+import { CubeFace, CubeMove } from "./cube-move2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/cube/cube-state.d.ts
+type CubeFacelet = CubeFace;
+type CubeFaceState = readonly (readonly CubeFacelet[])[];
+type CubeImage = readonly CubeFaceState[];
+interface CubeState {
+  readonly size: number;
+  readonly image: CubeImage;
+}
+declare const createSolvedCubeState: (size: number) => CubeState;
+declare const applyCubeMove: (state: CubeState, move: CubeMove) => CubeState;
+declare const areCubeStatesEqual: (a: CubeState, b: CubeState) => boolean;
+//#endregion
+export { CubeFaceState, CubeFacelet, CubeImage, CubeState, applyCubeMove, areCubeStatesEqual, createSolvedCubeState };