cubegin 0.0.1

package/dist/scramble-puzzle/src/pyraminx/pyraminx-state2.d.mts

@@ -0,0 +1,14 @@
+import { PyraminxFace, PyraminxMove } from "./pyraminx-parser2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/pyraminx/pyraminx-state.d.ts
+type PyraminxFacelet = number;
+type PyraminxFaceState = readonly PyraminxFacelet[];
+type PyraminxImage = readonly PyraminxFaceState[];
+interface PyraminxState {
+  readonly image: PyraminxImage;
+}
+declare const createSolvedPyraminxState: () => PyraminxState;
+declare const applyPyraminxMove: (state: PyraminxState, move: PyraminxMove) => PyraminxState;
+declare const arePyraminxStatesEqual: (a: PyraminxState, b: PyraminxState) => boolean;
+//#endregion
+export { PyraminxFaceState, PyraminxFacelet, PyraminxImage, PyraminxState, applyPyraminxMove, arePyraminxStatesEqual, createSolvedPyraminxState };

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

@@ -0,0 +1,90 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { PYRAMINX_AXES, PYRAMINX_FACES } from "./pyraminx-parser2.mjs";
+//#region .build/vendor/scramble-puzzle/src/pyraminx/pyraminx-state.ts
+const STICKERS_PER_FACE = 9;
+const MALFORMED_MOVE = "<malformed>";
+const isPyraminxAxis = (face) => typeof face === "string" && PYRAMINX_AXES.includes(face);
+const isMoveAmount = (amount) => amount === 1 || amount === 2;
+const axisIndex = (face) => PYRAMINX_AXES.indexOf(face);
+const clonePyraminxImage = (image) => image.map((face) => [...face]);
+const freezePyraminxImage = (image) => {
+	const frozenFaces = image.map((face) => Object.freeze([...face]));
+	return Object.freeze(frozenFaces);
+};
+const createPyraminxState = (image) => {
+	if (image.length !== PYRAMINX_FACES.length || image.some((face) => face.length !== STICKERS_PER_FACE)) throw new RangeError("pyraminx state must contain 4 faces of 9 stickers");
+	for (const face of image) for (const sticker of face) if (!Number.isSafeInteger(sticker) || sticker < 0 || sticker >= PYRAMINX_FACES.length) throw new RangeError("pyraminx stickers must be integer face indexes from 0 to 3");
+	return Object.freeze({ image: freezePyraminxImage(image) });
+};
+const swapStickers = (image, firstFace, firstSticker, secondFace, secondSticker, thirdFace, thirdSticker) => {
+	const savedSticker = image[firstFace][firstSticker];
+	image[firstFace][firstSticker] = image[secondFace][secondSticker];
+	image[secondFace][secondSticker] = image[thirdFace][thirdSticker];
+	image[thirdFace][thirdSticker] = savedSticker;
+};
+const turnTipOnce = (image, side) => {
+	switch (side) {
+		case 0:
+			swapStickers(image, 0, 0, 3, 0, 2, 3);
+			break;
+		case 1:
+			swapStickers(image, 0, 6, 2, 6, 1, 0);
+			break;
+		case 2:
+			swapStickers(image, 0, 3, 1, 3, 3, 6);
+			break;
+		case 3:
+			swapStickers(image, 1, 6, 2, 0, 3, 3);
+			break;
+	}
+};
+const turnOnce = (image, side) => {
+	switch (side) {
+		case 0:
+			swapStickers(image, 0, 8, 3, 8, 2, 2);
+			swapStickers(image, 0, 1, 3, 1, 2, 4);
+			swapStickers(image, 0, 2, 3, 2, 2, 5);
+			break;
+		case 1:
+			swapStickers(image, 2, 8, 1, 2, 0, 8);
+			swapStickers(image, 2, 7, 1, 1, 0, 7);
+			swapStickers(image, 2, 5, 1, 8, 0, 5);
+			break;
+		case 2:
+			swapStickers(image, 3, 8, 0, 5, 1, 5);
+			swapStickers(image, 3, 7, 0, 4, 1, 4);
+			swapStickers(image, 3, 5, 0, 2, 1, 2);
+			break;
+		case 3:
+			swapStickers(image, 1, 8, 2, 2, 3, 5);
+			swapStickers(image, 1, 7, 2, 1, 3, 4);
+			swapStickers(image, 1, 5, 2, 8, 3, 2);
+			break;
+	}
+	turnTipOnce(image, side);
+};
+const applyRepeatedTurns = (image, amount, turn) => {
+	for (let index = 0; index < amount; index += 1) turn();
+};
+const validateMove = (move) => {
+	if (typeof move !== "object" || move === null) throw new InvalidMoveError(MALFORMED_MOVE, "pyraminx");
+	if ((move.type === "turn" || move.type === "tip") && isPyraminxAxis(move.face) && isMoveAmount(move.amount)) return move;
+	throw new InvalidMoveError(MALFORMED_MOVE, "pyraminx");
+};
+const createSolvedPyraminxState = () => createPyraminxState(PYRAMINX_FACES.map((_, face) => Array(STICKERS_PER_FACE).fill(face)));
+const applyPyraminxMove = (state, move) => {
+	const validMove = validateMove(move);
+	const nextImage = clonePyraminxImage(state.image);
+	const side = axisIndex(validMove.face);
+	applyRepeatedTurns(nextImage, validMove.amount, () => {
+		if (validMove.type === "tip") {
+			turnTipOnce(nextImage, side);
+			return;
+		}
+		turnOnce(nextImage, side);
+	});
+	return createPyraminxState(nextImage);
+};
+const arePyraminxStatesEqual = (a, b) => a.image.every((face, faceIndexValue) => face.every((sticker, stickerIndex) => sticker === b.image[faceIndexValue]?.[stickerIndex]));
+//#endregion
+export { applyPyraminxMove, arePyraminxStatesEqual, createSolvedPyraminxState };

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

@@ -0,0 +1,11 @@
+import { WcaEventId } from "./events2.mjs";
+import { PuzzleDefinition } from "./puzzle-definition.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/registry.d.ts
+type AnyPuzzleDefinition<State = unknown, Move = unknown> = PuzzleDefinition<State, Move>;
+interface PuzzleRegistry<Definition extends AnyPuzzleDefinition = never> {
+  getByEventId(eventId: WcaEventId): Definition;
+}
+declare const createPuzzleRegistry: <Definition extends AnyPuzzleDefinition>(definitions: readonly Definition[]) => PuzzleRegistry<Definition>;
+//#endregion
+export { AnyPuzzleDefinition, PuzzleRegistry, createPuzzleRegistry };

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

@@ -0,0 +1,13 @@
+import { UnregisteredPuzzleError } from "./errors2.mjs";
+//#region .build/vendor/scramble-puzzle/src/registry.ts
+const createPuzzleRegistry = (definitions) => {
+	const definitionsByEventId = /* @__PURE__ */ new Map();
+	for (const definition of definitions) for (const eventId of definition.eventIds) definitionsByEventId.set(eventId, definition);
+	return { getByEventId(eventId) {
+		const definition = definitionsByEventId.get(eventId);
+		if (definition === void 0) throw new UnregisteredPuzzleError(eventId);
+		return definition;
+	} };
+};
+//#endregion
+export { createPuzzleRegistry };

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

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

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm.mjs";
+import { parseSkewbAlgorithm } from "./skewb-parser.mjs";
+import { applySkewbMove, areSkewbStatesEqual, createSolvedSkewbState } from "./skewb-state.mjs";
+//#region ../scramble-puzzle/src/skewb/skewb-definition.ts
+const createSkewbDefinition = () => {
+	const definition = {
+		id: "skewb",
+		eventIds: ["skewb"],
+		createSolvedState: createSolvedSkewbState,
+		parseAlgorithm: parseSkewbAlgorithm,
+		applyMove: applySkewbMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areSkewbStatesEqual(state, createSolvedSkewbState())
+	};
+	return definition;
+};
+//#endregion
+export { createSkewbDefinition };

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm2.mjs";
+import { parseSkewbAlgorithm } from "./skewb-parser2.mjs";
+import { applySkewbMove, areSkewbStatesEqual, createSolvedSkewbState } from "./skewb-state2.mjs";
+//#region .build/vendor/scramble-puzzle/src/skewb/skewb-definition.ts
+const createSkewbDefinition = () => {
+	const definition = {
+		id: "skewb",
+		eventIds: ["skewb"],
+		createSolvedState: createSolvedSkewbState,
+		parseAlgorithm: parseSkewbAlgorithm,
+		applyMove: applySkewbMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areSkewbStatesEqual(state, createSolvedSkewbState())
+	};
+	return definition;
+};
+//#endregion
+export { createSkewbDefinition };

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

@@ -0,0 +1,5 @@
+//#region ../scramble-puzzle/src/skewb/skewb-parser.d.ts
+declare const SKEWB_FACES: readonly ["U", "R", "F", "D", "L", "B"];
+type SkewbFace = (typeof SKEWB_FACES)[number];
+//#endregion
+export { SkewbFace };

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

@@ -0,0 +1,33 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { splitAlgorithm } from "../algorithm.mjs";
+//#region ../scramble-puzzle/src/skewb/skewb-parser.ts
+const SKEWB_FACES = [
+	"U",
+	"R",
+	"F",
+	"D",
+	"L",
+	"B"
+];
+const SKEWB_AXES = [
+	"R",
+	"U",
+	"L",
+	"B"
+];
+const SKEWB_MOVE_PATTERN = /^([RULB])('?)$/;
+const SKEWB_AXIS_SET = new Set(SKEWB_AXES);
+const isSkewbAxis = (face) => SKEWB_AXIS_SET.has(face);
+const parseSkewbMove = (token) => {
+	const match = token.match(SKEWB_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "skewb");
+	const [, face, suffix] = match;
+	if (face === void 0 || !isSkewbAxis(face)) throw new InvalidMoveError(token, "skewb");
+	return {
+		face,
+		amount: suffix === "'" ? 2 : 1
+	};
+};
+const parseSkewbAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseSkewbMove);
+//#endregion
+export { SKEWB_AXES, SKEWB_FACES, parseSkewbAlgorithm, parseSkewbMove };

package/dist/scramble-puzzle/src/skewb/skewb-parser2.d.mts

@@ -0,0 +1,14 @@
+//#region .build/vendor/scramble-puzzle/src/skewb/skewb-parser.d.ts
+declare const SKEWB_FACES: readonly ["U", "R", "F", "D", "L", "B"];
+declare const SKEWB_AXES: readonly ["R", "U", "L", "B"];
+type SkewbFace = (typeof SKEWB_FACES)[number];
+type SkewbAxis = (typeof SKEWB_AXES)[number];
+type SkewbMoveAmount = 1 | 2;
+interface SkewbMove {
+  readonly face: SkewbAxis;
+  readonly amount: SkewbMoveAmount;
+}
+declare const parseSkewbMove: (token: string) => SkewbMove;
+declare const parseSkewbAlgorithm: (algorithm: string) => readonly SkewbMove[];
+//#endregion
+export { SKEWB_AXES, SKEWB_FACES, SkewbAxis, SkewbFace, SkewbMove, SkewbMoveAmount, parseSkewbAlgorithm, parseSkewbMove };

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

@@ -0,0 +1,33 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { splitAlgorithm } from "../algorithm2.mjs";
+//#region .build/vendor/scramble-puzzle/src/skewb/skewb-parser.ts
+const SKEWB_FACES = [
+	"U",
+	"R",
+	"F",
+	"D",
+	"L",
+	"B"
+];
+const SKEWB_AXES = [
+	"R",
+	"U",
+	"L",
+	"B"
+];
+const SKEWB_MOVE_PATTERN = /^([RULB])('?)$/;
+const SKEWB_AXIS_SET = new Set(SKEWB_AXES);
+const isSkewbAxis = (face) => SKEWB_AXIS_SET.has(face);
+const parseSkewbMove = (token) => {
+	const match = token.match(SKEWB_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "skewb");
+	const [, face, suffix] = match;
+	if (face === void 0 || !isSkewbAxis(face)) throw new InvalidMoveError(token, "skewb");
+	return {
+		face,
+		amount: suffix === "'" ? 2 : 1
+	};
+};
+const parseSkewbAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseSkewbMove);
+//#endregion
+export { SKEWB_AXES, SKEWB_FACES, parseSkewbAlgorithm, parseSkewbMove };

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

@@ -0,0 +1,11 @@
+import { SkewbFace } from "./skewb-parser.mjs";
+
+//#region ../scramble-puzzle/src/skewb/skewb-state.d.ts
+type SkewbFacelet = number;
+type SkewbFaceState = readonly SkewbFacelet[];
+type SkewbImage = readonly SkewbFaceState[];
+interface SkewbState {
+  readonly image: SkewbImage;
+}
+//#endregion
+export { SkewbState };

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

@@ -0,0 +1,75 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { SKEWB_AXES, SKEWB_FACES } from "./skewb-parser.mjs";
+//#region ../scramble-puzzle/src/skewb/skewb-state.ts
+const STICKERS_PER_FACE = 5;
+const MALFORMED_MOVE = "<malformed>";
+const isSkewbAxis = (face) => typeof face === "string" && SKEWB_AXES.includes(face);
+const isMoveAmount = (amount) => amount === 1 || amount === 2;
+const axisIndex = (face) => SKEWB_AXES.indexOf(face);
+const cloneSkewbImage = (image) => image.map((face) => [...face]);
+const freezeSkewbImage = (image) => {
+	const frozenFaces = image.map((face) => Object.freeze([...face]));
+	return Object.freeze(frozenFaces);
+};
+const createSkewbState = (image) => {
+	if (image.length !== SKEWB_FACES.length || image.some((face) => face.length !== STICKERS_PER_FACE)) throw new RangeError("skewb state must contain 6 faces of 5 stickers");
+	for (const face of image) for (const sticker of face) if (!Number.isSafeInteger(sticker) || sticker < 0 || sticker >= SKEWB_FACES.length) throw new RangeError("skewb stickers must be integer face indexes from 0 to 5");
+	return Object.freeze({ image: freezeSkewbImage(image) });
+};
+const swapStickers = (image, firstFace, firstSticker, secondFace, secondSticker, thirdFace, thirdSticker) => {
+	const savedSticker = image[firstFace][firstSticker];
+	image[firstFace][firstSticker] = image[secondFace][secondSticker];
+	image[secondFace][secondSticker] = image[thirdFace][thirdSticker];
+	image[thirdFace][thirdSticker] = savedSticker;
+};
+const turnOnce = (image, axis) => {
+	switch (axis) {
+		case 0:
+			swapStickers(image, 2, 0, 3, 0, 1, 0);
+			swapStickers(image, 2, 4, 3, 2, 1, 3);
+			swapStickers(image, 2, 2, 3, 1, 1, 4);
+			swapStickers(image, 2, 3, 3, 4, 1, 1);
+			swapStickers(image, 4, 4, 5, 3, 0, 4);
+			break;
+		case 1:
+			swapStickers(image, 0, 0, 1, 0, 5, 0);
+			swapStickers(image, 0, 2, 1, 2, 5, 1);
+			swapStickers(image, 0, 4, 1, 4, 5, 2);
+			swapStickers(image, 0, 1, 1, 1, 5, 3);
+			swapStickers(image, 4, 1, 2, 2, 3, 4);
+			break;
+		case 2:
+			swapStickers(image, 4, 0, 5, 0, 3, 0);
+			swapStickers(image, 4, 3, 5, 4, 3, 3);
+			swapStickers(image, 4, 1, 5, 3, 3, 1);
+			swapStickers(image, 4, 4, 5, 2, 3, 4);
+			swapStickers(image, 2, 3, 0, 1, 1, 4);
+			break;
+		case 3:
+			swapStickers(image, 1, 0, 3, 0, 5, 0);
+			swapStickers(image, 1, 4, 3, 4, 5, 3);
+			swapStickers(image, 1, 3, 3, 3, 5, 1);
+			swapStickers(image, 1, 2, 3, 2, 5, 4);
+			swapStickers(image, 0, 2, 2, 4, 4, 3);
+			break;
+	}
+};
+const applyRepeatedTurns = (image, amount, turn) => {
+	for (let index = 0; index < amount; index += 1) turn();
+};
+const validateMove = (move) => {
+	if (typeof move !== "object" || move === null) throw new InvalidMoveError(MALFORMED_MOVE, "skewb");
+	if (isSkewbAxis(move.face) && isMoveAmount(move.amount)) return move;
+	throw new InvalidMoveError(MALFORMED_MOVE, "skewb");
+};
+const createSolvedSkewbState = () => createSkewbState(SKEWB_FACES.map((_, face) => Array(STICKERS_PER_FACE).fill(face)));
+const applySkewbMove = (state, move) => {
+	const validMove = validateMove(move);
+	const nextImage = cloneSkewbImage(state.image);
+	const axis = axisIndex(validMove.face);
+	applyRepeatedTurns(nextImage, validMove.amount, () => turnOnce(nextImage, axis));
+	return createSkewbState(nextImage);
+};
+const areSkewbStatesEqual = (a, b) => a.image.every((face, faceIndexValue) => face.every((sticker, stickerIndex) => sticker === b.image[faceIndexValue]?.[stickerIndex]));
+//#endregion
+export { applySkewbMove, areSkewbStatesEqual, createSolvedSkewbState };

package/dist/scramble-puzzle/src/skewb/skewb-state2.d.mts

@@ -0,0 +1,14 @@
+import { SkewbFace, SkewbMove } from "./skewb-parser2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/skewb/skewb-state.d.ts
+type SkewbFacelet = number;
+type SkewbFaceState = readonly SkewbFacelet[];
+type SkewbImage = readonly SkewbFaceState[];
+interface SkewbState {
+  readonly image: SkewbImage;
+}
+declare const createSolvedSkewbState: () => SkewbState;
+declare const applySkewbMove: (state: SkewbState, move: SkewbMove) => SkewbState;
+declare const areSkewbStatesEqual: (a: SkewbState, b: SkewbState) => boolean;
+//#endregion
+export { SkewbFaceState, SkewbFacelet, SkewbImage, SkewbState, applySkewbMove, areSkewbStatesEqual, createSolvedSkewbState };

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

@@ -0,0 +1,75 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { SKEWB_AXES, SKEWB_FACES } from "./skewb-parser2.mjs";
+//#region .build/vendor/scramble-puzzle/src/skewb/skewb-state.ts
+const STICKERS_PER_FACE = 5;
+const MALFORMED_MOVE = "<malformed>";
+const isSkewbAxis = (face) => typeof face === "string" && SKEWB_AXES.includes(face);
+const isMoveAmount = (amount) => amount === 1 || amount === 2;
+const axisIndex = (face) => SKEWB_AXES.indexOf(face);
+const cloneSkewbImage = (image) => image.map((face) => [...face]);
+const freezeSkewbImage = (image) => {
+	const frozenFaces = image.map((face) => Object.freeze([...face]));
+	return Object.freeze(frozenFaces);
+};
+const createSkewbState = (image) => {
+	if (image.length !== SKEWB_FACES.length || image.some((face) => face.length !== STICKERS_PER_FACE)) throw new RangeError("skewb state must contain 6 faces of 5 stickers");
+	for (const face of image) for (const sticker of face) if (!Number.isSafeInteger(sticker) || sticker < 0 || sticker >= SKEWB_FACES.length) throw new RangeError("skewb stickers must be integer face indexes from 0 to 5");
+	return Object.freeze({ image: freezeSkewbImage(image) });
+};
+const swapStickers = (image, firstFace, firstSticker, secondFace, secondSticker, thirdFace, thirdSticker) => {
+	const savedSticker = image[firstFace][firstSticker];
+	image[firstFace][firstSticker] = image[secondFace][secondSticker];
+	image[secondFace][secondSticker] = image[thirdFace][thirdSticker];
+	image[thirdFace][thirdSticker] = savedSticker;
+};
+const turnOnce = (image, axis) => {
+	switch (axis) {
+		case 0:
+			swapStickers(image, 2, 0, 3, 0, 1, 0);
+			swapStickers(image, 2, 4, 3, 2, 1, 3);
+			swapStickers(image, 2, 2, 3, 1, 1, 4);
+			swapStickers(image, 2, 3, 3, 4, 1, 1);
+			swapStickers(image, 4, 4, 5, 3, 0, 4);
+			break;
+		case 1:
+			swapStickers(image, 0, 0, 1, 0, 5, 0);
+			swapStickers(image, 0, 2, 1, 2, 5, 1);
+			swapStickers(image, 0, 4, 1, 4, 5, 2);
+			swapStickers(image, 0, 1, 1, 1, 5, 3);
+			swapStickers(image, 4, 1, 2, 2, 3, 4);
+			break;
+		case 2:
+			swapStickers(image, 4, 0, 5, 0, 3, 0);
+			swapStickers(image, 4, 3, 5, 4, 3, 3);
+			swapStickers(image, 4, 1, 5, 3, 3, 1);
+			swapStickers(image, 4, 4, 5, 2, 3, 4);
+			swapStickers(image, 2, 3, 0, 1, 1, 4);
+			break;
+		case 3:
+			swapStickers(image, 1, 0, 3, 0, 5, 0);
+			swapStickers(image, 1, 4, 3, 4, 5, 3);
+			swapStickers(image, 1, 3, 3, 3, 5, 1);
+			swapStickers(image, 1, 2, 3, 2, 5, 4);
+			swapStickers(image, 0, 2, 2, 4, 4, 3);
+			break;
+	}
+};
+const applyRepeatedTurns = (image, amount, turn) => {
+	for (let index = 0; index < amount; index += 1) turn();
+};
+const validateMove = (move) => {
+	if (typeof move !== "object" || move === null) throw new InvalidMoveError(MALFORMED_MOVE, "skewb");
+	if (isSkewbAxis(move.face) && isMoveAmount(move.amount)) return move;
+	throw new InvalidMoveError(MALFORMED_MOVE, "skewb");
+};
+const createSolvedSkewbState = () => createSkewbState(SKEWB_FACES.map((_, face) => Array(STICKERS_PER_FACE).fill(face)));
+const applySkewbMove = (state, move) => {
+	const validMove = validateMove(move);
+	const nextImage = cloneSkewbImage(state.image);
+	const axis = axisIndex(validMove.face);
+	applyRepeatedTurns(nextImage, validMove.amount, () => turnOnce(nextImage, axis));
+	return createSkewbState(nextImage);
+};
+const areSkewbStatesEqual = (a, b) => a.image.every((face, faceIndexValue) => face.every((sticker, stickerIndex) => sticker === b.image[faceIndexValue]?.[stickerIndex]));
+//#endregion
+export { applySkewbMove, areSkewbStatesEqual, createSolvedSkewbState };

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

@@ -0,0 +1,8 @@
+import { PuzzleDefinition } from "../puzzle-definition.mjs";
+import { SquareOneMove } from "./square1-parser.mjs";
+import { SquareOneState } from "./square1-state2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/square1/square1-definition.d.ts
+declare const createSquareOneDefinition: () => PuzzleDefinition<SquareOneState, SquareOneMove>;
+//#endregion
+export { createSquareOneDefinition };

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm.mjs";
+import { parseSquareOneAlgorithm } from "./square1-parser.mjs";
+import { applySquareOneMove, areSquareOneStatesEqual, createSolvedSquareOneState } from "./square1-state.mjs";
+//#region ../scramble-puzzle/src/square1/square1-definition.ts
+const createSquareOneDefinition = () => {
+	const definition = {
+		id: "square1",
+		eventIds: ["sq1"],
+		createSolvedState: createSolvedSquareOneState,
+		parseAlgorithm: parseSquareOneAlgorithm,
+		applyMove: applySquareOneMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areSquareOneStatesEqual(state, createSolvedSquareOneState())
+	};
+	return definition;
+};
+//#endregion
+export { createSquareOneDefinition };

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm2.mjs";
+import { parseSquareOneAlgorithm } from "./square1-parser2.mjs";
+import { applySquareOneMove, areSquareOneStatesEqual, createSolvedSquareOneState } from "./square1-state2.mjs";
+//#region .build/vendor/scramble-puzzle/src/square1/square1-definition.ts
+const createSquareOneDefinition = () => {
+	const definition = {
+		id: "square1",
+		eventIds: ["sq1"],
+		createSolvedState: createSolvedSquareOneState,
+		parseAlgorithm: parseSquareOneAlgorithm,
+		applyMove: applySquareOneMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areSquareOneStatesEqual(state, createSolvedSquareOneState())
+	};
+	return definition;
+};
+//#endregion
+export { createSquareOneDefinition };

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

@@ -0,0 +1,17 @@
+//#region .build/vendor/scramble-puzzle/src/square1/square1-parser.d.ts
+type SquareOneTurn = -5 | -4 | -3 | -2 | -1 | 0 | 1 | 2 | 3 | 4 | 5 | 6;
+interface SquareOneTupleMove {
+  readonly type: 'tuple';
+  readonly top: SquareOneTurn;
+  readonly bottom: SquareOneTurn;
+}
+interface SquareOneSlashMove {
+  readonly type: 'slash';
+}
+type SquareOneMove = SquareOneTupleMove | SquareOneSlashMove;
+declare const parseSquareOneMove: (token: string) => SquareOneMove;
+declare const parseSquareOneAlgorithm: (algorithm: string) => readonly SquareOneMove[];
+declare const getSquareOneMoveCost: (move: SquareOneMove) => number;
+declare const getSquareOneSlashabilityMoveCost: (move: SquareOneMove) => number | undefined;
+//#endregion
+export { SquareOneMove, SquareOneSlashMove, SquareOneTupleMove, SquareOneTurn, getSquareOneMoveCost, getSquareOneSlashabilityMoveCost, parseSquareOneAlgorithm, parseSquareOneMove };

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

@@ -0,0 +1,43 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { splitAlgorithm } from "../algorithm.mjs";
+//#region ../scramble-puzzle/src/square1/square1-parser.ts
+const SQUARE_ONE_MOVE_PATTERN = /^\((-?\d+),(-?\d+)\)$/;
+const MIN_TURN = -5;
+const MAX_TURN = 6;
+const MALFORMED_MOVE = "<malformed>";
+const isSquareOneRecord = (move) => typeof move === "object" && move !== null;
+const isSquareOneTurn = (turn) => typeof turn === "number" && Number.isSafeInteger(turn) && turn >= MIN_TURN && turn <= MAX_TURN;
+const hasOnlyKeys = (move, expectedKeys) => Object.keys(move).length === expectedKeys.length && expectedKeys.every((key) => Object.hasOwn(move, key));
+const isSquareOneTupleMove = (move) => isSquareOneRecord(move) && move.type === "tuple";
+const isSquareOneSlashMove = (move) => isSquareOneRecord(move) && move.type === "slash" && hasOnlyKeys(move, ["type"]);
+const validateSquareOneMove = (move) => {
+	if (isSquareOneSlashMove(move)) return move;
+	if (isSquareOneTupleMove(move) && hasOnlyKeys(move, [
+		"type",
+		"top",
+		"bottom"
+	]) && isSquareOneTurn(move.top) && isSquareOneTurn(move.bottom) && (move.top !== 0 || move.bottom !== 0)) return move;
+	throw new InvalidMoveError(MALFORMED_MOVE, "square1");
+};
+const parseSquareOneMove = (token) => {
+	if (token === "/") return { type: "slash" };
+	const match = token.match(SQUARE_ONE_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "square1");
+	const [, topText, bottomText] = match;
+	const top = Number(topText);
+	const bottom = Number(bottomText);
+	if (!isSquareOneTurn(top) || !isSquareOneTurn(bottom) || top === 0 && bottom === 0) throw new InvalidMoveError(token, "square1");
+	return {
+		type: "tuple",
+		top,
+		bottom
+	};
+};
+const parseSquareOneAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseSquareOneMove);
+const getSquareOneSlashabilityMoveCost = (move) => {
+	const validMove = validateSquareOneMove(move);
+	if (validMove.type === "slash") return void 0;
+	return Math.abs(validMove.top) + Math.abs(validMove.bottom);
+};
+//#endregion
+export { getSquareOneSlashabilityMoveCost, parseSquareOneAlgorithm, parseSquareOneMove, validateSquareOneMove };

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

@@ -0,0 +1,47 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { splitAlgorithm } from "../algorithm2.mjs";
+//#region .build/vendor/scramble-puzzle/src/square1/square1-parser.ts
+const SQUARE_ONE_MOVE_PATTERN = /^\((-?\d+),(-?\d+)\)$/;
+const MIN_TURN = -5;
+const MAX_TURN = 6;
+const MALFORMED_MOVE = "<malformed>";
+const isSquareOneRecord = (move) => typeof move === "object" && move !== null;
+const isSquareOneTurn = (turn) => typeof turn === "number" && Number.isSafeInteger(turn) && turn >= MIN_TURN && turn <= MAX_TURN;
+const hasOnlyKeys = (move, expectedKeys) => Object.keys(move).length === expectedKeys.length && expectedKeys.every((key) => Object.hasOwn(move, key));
+const isSquareOneTupleMove = (move) => isSquareOneRecord(move) && move.type === "tuple";
+const isSquareOneSlashMove = (move) => isSquareOneRecord(move) && move.type === "slash" && hasOnlyKeys(move, ["type"]);
+const validateSquareOneMove = (move) => {
+	if (isSquareOneSlashMove(move)) return move;
+	if (isSquareOneTupleMove(move) && hasOnlyKeys(move, [
+		"type",
+		"top",
+		"bottom"
+	]) && isSquareOneTurn(move.top) && isSquareOneTurn(move.bottom) && (move.top !== 0 || move.bottom !== 0)) return move;
+	throw new InvalidMoveError(MALFORMED_MOVE, "square1");
+};
+const parseSquareOneMove = (token) => {
+	if (token === "/") return { type: "slash" };
+	const match = token.match(SQUARE_ONE_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "square1");
+	const [, topText, bottomText] = match;
+	const top = Number(topText);
+	const bottom = Number(bottomText);
+	if (!isSquareOneTurn(top) || !isSquareOneTurn(bottom) || top === 0 && bottom === 0) throw new InvalidMoveError(token, "square1");
+	return {
+		type: "tuple",
+		top,
+		bottom
+	};
+};
+const parseSquareOneAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseSquareOneMove);
+const getSquareOneMoveCost = (move) => {
+	validateSquareOneMove(move);
+	return 1;
+};
+const getSquareOneSlashabilityMoveCost = (move) => {
+	const validMove = validateSquareOneMove(move);
+	if (validMove.type === "slash") return void 0;
+	return Math.abs(validMove.top) + Math.abs(validMove.bottom);
+};
+//#endregion
+export { getSquareOneMoveCost, getSquareOneSlashabilityMoveCost, parseSquareOneAlgorithm, parseSquareOneMove, validateSquareOneMove };

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

@@ -0,0 +1,9 @@
+//#region ../scramble-puzzle/src/square1/square1-state.d.ts
+type SquareOnePiece = number;
+type SquareOnePieces = readonly SquareOnePiece[];
+interface SquareOneState {
+  readonly sliceSolved: boolean;
+  readonly pieces: SquareOnePieces;
+}
+//#endregion
+export { SquareOneState };