cubegin 0.0.1

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

@@ -0,0 +1,57 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { splitAlgorithm } from "../algorithm.mjs";
+//#region ../scramble-puzzle/src/megaminx/megaminx-parser.ts
+const MEGAMINX_FACES = [
+	"U",
+	"BL",
+	"BR",
+	"R",
+	"F",
+	"L",
+	"D",
+	"DR",
+	"DBR",
+	"B",
+	"DBL",
+	"DL"
+];
+const FACE_MOVE_PATTERN = /^(U|BL|BR|R|F|L|D|DR|DBR|B|DBL|DL)(2'?|')?$/;
+const BIG_TURN_PATTERN = /^([RD])(\+\+?|--?)$/;
+const MEGAMINX_FACE_SET = new Set(MEGAMINX_FACES);
+const isMegaminxFace = (face) => MEGAMINX_FACE_SET.has(face);
+const parseFaceAmount = (suffix) => {
+	if (suffix === "2") return 2;
+	if (suffix === "2'") return 3;
+	if (suffix === "'") return 4;
+	return 1;
+};
+const parseBigTurnAmount = (suffix) => {
+	if (suffix === "+") return 1;
+	if (suffix === "++") return 2;
+	if (suffix === "--") return 3;
+	return 4;
+};
+const parseMegaminxMove = (token) => {
+	const bigTurnMatch = token.match(BIG_TURN_PATTERN);
+	if (bigTurnMatch) {
+		const [, name, suffix] = bigTurnMatch;
+		if (name !== "R" && name !== "D" || suffix === void 0) throw new InvalidMoveError(token, "megaminx");
+		return {
+			type: "big-turn",
+			name,
+			amount: parseBigTurnAmount(suffix)
+		};
+	}
+	const faceMatch = token.match(FACE_MOVE_PATTERN);
+	if (!faceMatch) throw new InvalidMoveError(token, "megaminx");
+	const [, face, suffix] = faceMatch;
+	if (face === void 0 || !isMegaminxFace(face)) throw new InvalidMoveError(token, "megaminx");
+	return {
+		type: "face",
+		face,
+		amount: parseFaceAmount(suffix)
+	};
+};
+const parseMegaminxAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseMegaminxMove);
+//#endregion
+export { MEGAMINX_FACES, parseMegaminxAlgorithm, parseMegaminxMove };

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

@@ -0,0 +1,20 @@
+//#region .build/vendor/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];
+type MegaminxMoveAmount = 1 | 2 | 3 | 4;
+type MegaminxBigTurnName = 'R' | 'D';
+interface MegaminxFaceMove {
+  readonly type: 'face';
+  readonly face: MegaminxFace;
+  readonly amount: MegaminxMoveAmount;
+}
+interface MegaminxBigTurnMove {
+  readonly type: 'big-turn';
+  readonly name: MegaminxBigTurnName;
+  readonly amount: MegaminxMoveAmount;
+}
+type MegaminxMove = MegaminxFaceMove | MegaminxBigTurnMove;
+declare const parseMegaminxMove: (token: string) => MegaminxMove;
+declare const parseMegaminxAlgorithm: (algorithm: string) => readonly MegaminxMove[];
+//#endregion
+export { MEGAMINX_FACES, MegaminxBigTurnMove, MegaminxBigTurnName, MegaminxFace, MegaminxFaceMove, MegaminxMove, MegaminxMoveAmount, parseMegaminxAlgorithm, parseMegaminxMove };

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

@@ -0,0 +1,57 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { splitAlgorithm } from "../algorithm2.mjs";
+//#region .build/vendor/scramble-puzzle/src/megaminx/megaminx-parser.ts
+const MEGAMINX_FACES = [
+	"U",
+	"BL",
+	"BR",
+	"R",
+	"F",
+	"L",
+	"D",
+	"DR",
+	"DBR",
+	"B",
+	"DBL",
+	"DL"
+];
+const FACE_MOVE_PATTERN = /^(U|BL|BR|R|F|L|D|DR|DBR|B|DBL|DL)(2'?|')?$/;
+const BIG_TURN_PATTERN = /^([RD])(\+\+?|--?)$/;
+const MEGAMINX_FACE_SET = new Set(MEGAMINX_FACES);
+const isMegaminxFace = (face) => MEGAMINX_FACE_SET.has(face);
+const parseFaceAmount = (suffix) => {
+	if (suffix === "2") return 2;
+	if (suffix === "2'") return 3;
+	if (suffix === "'") return 4;
+	return 1;
+};
+const parseBigTurnAmount = (suffix) => {
+	if (suffix === "+") return 1;
+	if (suffix === "++") return 2;
+	if (suffix === "--") return 3;
+	return 4;
+};
+const parseMegaminxMove = (token) => {
+	const bigTurnMatch = token.match(BIG_TURN_PATTERN);
+	if (bigTurnMatch) {
+		const [, name, suffix] = bigTurnMatch;
+		if (name !== "R" && name !== "D" || suffix === void 0) throw new InvalidMoveError(token, "megaminx");
+		return {
+			type: "big-turn",
+			name,
+			amount: parseBigTurnAmount(suffix)
+		};
+	}
+	const faceMatch = token.match(FACE_MOVE_PATTERN);
+	if (!faceMatch) throw new InvalidMoveError(token, "megaminx");
+	const [, face, suffix] = faceMatch;
+	if (face === void 0 || !isMegaminxFace(face)) throw new InvalidMoveError(token, "megaminx");
+	return {
+		type: "face",
+		face,
+		amount: parseFaceAmount(suffix)
+	};
+};
+const parseMegaminxAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseMegaminxMove);
+//#endregion
+export { MEGAMINX_FACES, parseMegaminxAlgorithm, parseMegaminxMove };

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

@@ -0,0 +1,9 @@
+//#region ../scramble-puzzle/src/megaminx/megaminx-state.d.ts
+type MegaminxFacelet = number;
+type MegaminxFaceState = readonly MegaminxFacelet[];
+type MegaminxImage = readonly MegaminxFaceState[];
+interface MegaminxState {
+  readonly image: MegaminxImage;
+}
+//#endregion
+export { MegaminxState };

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

@@ -0,0 +1,112 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { MEGAMINX_FACES } from "./megaminx-parser.mjs";
+//#region ../scramble-puzzle/src/megaminx/megaminx-state.ts
+const CENTER_INDEX = 10;
+const STICKERS_PER_FACE = 11;
+const MALFORMED_MOVE = "<malformed>";
+const faceIndex = (face) => MEGAMINX_FACES.indexOf(face);
+const isMoveAmount = (amount) => amount === 1 || amount === 2 || amount === 3 || amount === 4;
+const isMegaminxFace = (face) => typeof face === "string" && MEGAMINX_FACES.includes(face);
+const isBigTurnName = (name) => name === "R" || name === "D";
+const cloneMegaminxImage = (image) => image.map((face) => [...face]);
+const freezeMegaminxImage = (image) => {
+	const frozenFaces = image.map((face) => Object.freeze([...face]));
+	return Object.freeze(frozenFaces);
+};
+const createMegaminxState = (image) => {
+	if (image.length !== MEGAMINX_FACES.length || image.some((face) => face.length !== STICKERS_PER_FACE)) throw new RangeError("megaminx state must contain 12 faces of 11 stickers");
+	return Object.freeze({ image: freezeMegaminxImage(image) });
+};
+const cycleStickers = (image, first, second, third, fourth, fifth) => {
+	const [firstFace, firstSticker] = first;
+	const [secondFace, secondSticker] = second;
+	const [thirdFace, thirdSticker] = third;
+	const [fourthFace, fourthSticker] = fourth;
+	const [fifthFace, fifthSticker] = fifth;
+	const savedSticker = image[firstFace][firstSticker];
+	image[firstFace][firstSticker] = image[secondFace][secondSticker];
+	image[secondFace][secondSticker] = image[thirdFace][thirdSticker];
+	image[thirdFace][thirdSticker] = image[fourthFace][fourthSticker];
+	image[fourthFace][fourthSticker] = image[fifthFace][fifthSticker];
+	image[fifthFace][fifthSticker] = savedSticker;
+};
+const swapOnSide = (image, base, firstFace, firstSticker, secondFace, secondSticker, thirdFace, thirdSticker, fourthFace, fourthSticker, fifthFace, fifthSticker) => {
+	for (let index = 0; index < 3; index += 1) cycleStickers(image, [(firstFace + base) % 12, (firstSticker + index) % 10], [(secondFace + base) % 12, (secondSticker + index) % 10], [(thirdFace + base) % 12, (thirdSticker + index) % 10], [(fourthFace + base) % 12, (fourthSticker + index) % 10], [(fifthFace + base) % 12, (fifthSticker + index) % 10]);
+};
+const swapOnFace = (image, face, first, second, third, fourth, fifth) => {
+	cycleStickers(image, [face, first], [face, second], [face, third], [face, fourth], [face, fifth]);
+};
+const rotateFaceOnce = (image, face) => {
+	const position = faceIndex(face);
+	swapOnFace(image, position, 0, 8, 6, 4, 2);
+	swapOnFace(image, position, 1, 9, 7, 5, 3);
+};
+const turnFaceOnce = (image, face) => {
+	const position = faceIndex(face);
+	const base = position >= 6 ? 6 : 0;
+	switch (position % 6) {
+		case 0:
+			swapOnSide(image, base, 1, 6, 5, 4, 4, 2, 3, 0, 2, 8);
+			break;
+		case 1:
+			swapOnSide(image, base, 0, 0, 2, 0, 9, 6, 10, 6, 5, 2);
+			break;
+		case 2:
+			swapOnSide(image, base, 0, 2, 3, 2, 8, 4, 9, 4, 1, 4);
+			break;
+		case 3:
+			swapOnSide(image, base, 0, 4, 4, 4, 7, 2, 8, 2, 2, 6);
+			break;
+		case 4:
+			swapOnSide(image, base, 0, 6, 5, 6, 11, 0, 7, 0, 3, 8);
+			break;
+		case 5:
+			swapOnSide(image, base, 0, 8, 1, 8, 10, 8, 11, 8, 4, 0);
+			break;
+	}
+	rotateFaceOnce(image, face);
+};
+const applyRepeatedTurns = (image, amount, turn) => {
+	for (let index = 0; index < amount; index += 1) turn();
+};
+const cycleCenters = (image, firstFace, secondFace, thirdFace, fourthFace, fifthFace) => {
+	cycleStickers(image, [firstFace, CENTER_INDEX], [secondFace, CENTER_INDEX], [thirdFace, CENTER_INDEX], [fourthFace, CENTER_INDEX], [fifthFace, CENTER_INDEX]);
+};
+const swapWholeFace = (image, firstFace, firstSticker, secondFace, secondSticker, thirdFace, thirdSticker, fourthFace, fourthSticker, fifthFace, fifthSticker) => {
+	for (let index = 0; index < 10; index += 1) cycleStickers(image, [firstFace, (firstSticker + index) % 10], [secondFace, (secondSticker + index) % 10], [thirdFace, (thirdSticker + index) % 10], [fourthFace, (fourthSticker + index) % 10], [fifthFace, (fifthSticker + index) % 10]);
+	cycleCenters(image, firstFace, secondFace, thirdFace, fourthFace, fifthFace);
+};
+const bigTurnOnce = (image, face) => {
+	if (face === "DBR") {
+		for (let index = 0; index < 7; index += 1) cycleStickers(image, [0, (1 + index) % 10], [4, (3 + index) % 10], [11, (1 + index) % 10], [10, (1 + index) % 10], [1, (1 + index) % 10]);
+		cycleCenters(image, 0, 4, 11, 10, 1);
+		swapWholeFace(image, 2, 0, 3, 0, 7, 0, 6, 8, 9, 8);
+		rotateFaceOnce(image, "DBR");
+		return;
+	}
+	for (let index = 0; index < 7; index += 1) cycleStickers(image, [1, (9 + index) % 10], [2, (1 + index) % 10], [3, (3 + index) % 10], [4, (5 + index) % 10], [5, (7 + index) % 10]);
+	cycleCenters(image, 1, 2, 3, 4, 5);
+	swapWholeFace(image, 11, 0, 10, 8, 9, 6, 8, 4, 7, 2);
+	rotateFaceOnce(image, "D");
+};
+const bigTurnFace = (name) => name === "R" ? "DBR" : "D";
+const validateMove = (move) => {
+	if (typeof move !== "object" || move === null) throw new InvalidMoveError(MALFORMED_MOVE, "megaminx");
+	if (move.type === "face") {
+		if (!isMegaminxFace(move.face) || !isMoveAmount(move.amount)) throw new InvalidMoveError(MALFORMED_MOVE, "megaminx");
+		return move;
+	}
+	if (move.type === "big-turn" && isBigTurnName(move.name) && isMoveAmount(move.amount)) return move;
+	throw new InvalidMoveError(MALFORMED_MOVE, "megaminx");
+};
+const createSolvedMegaminxState = () => createMegaminxState(MEGAMINX_FACES.map((_, face) => Array(STICKERS_PER_FACE).fill(face)));
+const applyMegaminxMove = (state, move) => {
+	const validMove = validateMove(move);
+	const nextImage = cloneMegaminxImage(state.image);
+	if (validMove.type === "face") applyRepeatedTurns(nextImage, validMove.amount, () => turnFaceOnce(nextImage, validMove.face));
+	else applyRepeatedTurns(nextImage, validMove.amount, () => bigTurnOnce(nextImage, bigTurnFace(validMove.name)));
+	return createMegaminxState(nextImage);
+};
+const areMegaminxStatesEqual = (a, b) => a.image.every((face, faceIndexValue) => face.every((sticker, stickerIndex) => sticker === b.image[faceIndexValue]?.[stickerIndex]));
+//#endregion
+export { applyMegaminxMove, areMegaminxStatesEqual, createSolvedMegaminxState };

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

@@ -0,0 +1,14 @@
+import { MegaminxMove } from "./megaminx-parser2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/megaminx/megaminx-state.d.ts
+type MegaminxFacelet = number;
+type MegaminxFaceState = readonly MegaminxFacelet[];
+type MegaminxImage = readonly MegaminxFaceState[];
+interface MegaminxState {
+  readonly image: MegaminxImage;
+}
+declare const createSolvedMegaminxState: () => MegaminxState;
+declare const applyMegaminxMove: (state: MegaminxState, move: MegaminxMove) => MegaminxState;
+declare const areMegaminxStatesEqual: (a: MegaminxState, b: MegaminxState) => boolean;
+//#endregion
+export { MegaminxFaceState, MegaminxFacelet, MegaminxImage, MegaminxState, applyMegaminxMove, areMegaminxStatesEqual, createSolvedMegaminxState };

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

@@ -0,0 +1,112 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { MEGAMINX_FACES } from "./megaminx-parser2.mjs";
+//#region .build/vendor/scramble-puzzle/src/megaminx/megaminx-state.ts
+const CENTER_INDEX = 10;
+const STICKERS_PER_FACE = 11;
+const MALFORMED_MOVE = "<malformed>";
+const faceIndex = (face) => MEGAMINX_FACES.indexOf(face);
+const isMoveAmount = (amount) => amount === 1 || amount === 2 || amount === 3 || amount === 4;
+const isMegaminxFace = (face) => typeof face === "string" && MEGAMINX_FACES.includes(face);
+const isBigTurnName = (name) => name === "R" || name === "D";
+const cloneMegaminxImage = (image) => image.map((face) => [...face]);
+const freezeMegaminxImage = (image) => {
+	const frozenFaces = image.map((face) => Object.freeze([...face]));
+	return Object.freeze(frozenFaces);
+};
+const createMegaminxState = (image) => {
+	if (image.length !== MEGAMINX_FACES.length || image.some((face) => face.length !== STICKERS_PER_FACE)) throw new RangeError("megaminx state must contain 12 faces of 11 stickers");
+	return Object.freeze({ image: freezeMegaminxImage(image) });
+};
+const cycleStickers = (image, first, second, third, fourth, fifth) => {
+	const [firstFace, firstSticker] = first;
+	const [secondFace, secondSticker] = second;
+	const [thirdFace, thirdSticker] = third;
+	const [fourthFace, fourthSticker] = fourth;
+	const [fifthFace, fifthSticker] = fifth;
+	const savedSticker = image[firstFace][firstSticker];
+	image[firstFace][firstSticker] = image[secondFace][secondSticker];
+	image[secondFace][secondSticker] = image[thirdFace][thirdSticker];
+	image[thirdFace][thirdSticker] = image[fourthFace][fourthSticker];
+	image[fourthFace][fourthSticker] = image[fifthFace][fifthSticker];
+	image[fifthFace][fifthSticker] = savedSticker;
+};
+const swapOnSide = (image, base, firstFace, firstSticker, secondFace, secondSticker, thirdFace, thirdSticker, fourthFace, fourthSticker, fifthFace, fifthSticker) => {
+	for (let index = 0; index < 3; index += 1) cycleStickers(image, [(firstFace + base) % 12, (firstSticker + index) % 10], [(secondFace + base) % 12, (secondSticker + index) % 10], [(thirdFace + base) % 12, (thirdSticker + index) % 10], [(fourthFace + base) % 12, (fourthSticker + index) % 10], [(fifthFace + base) % 12, (fifthSticker + index) % 10]);
+};
+const swapOnFace = (image, face, first, second, third, fourth, fifth) => {
+	cycleStickers(image, [face, first], [face, second], [face, third], [face, fourth], [face, fifth]);
+};
+const rotateFaceOnce = (image, face) => {
+	const position = faceIndex(face);
+	swapOnFace(image, position, 0, 8, 6, 4, 2);
+	swapOnFace(image, position, 1, 9, 7, 5, 3);
+};
+const turnFaceOnce = (image, face) => {
+	const position = faceIndex(face);
+	const base = position >= 6 ? 6 : 0;
+	switch (position % 6) {
+		case 0:
+			swapOnSide(image, base, 1, 6, 5, 4, 4, 2, 3, 0, 2, 8);
+			break;
+		case 1:
+			swapOnSide(image, base, 0, 0, 2, 0, 9, 6, 10, 6, 5, 2);
+			break;
+		case 2:
+			swapOnSide(image, base, 0, 2, 3, 2, 8, 4, 9, 4, 1, 4);
+			break;
+		case 3:
+			swapOnSide(image, base, 0, 4, 4, 4, 7, 2, 8, 2, 2, 6);
+			break;
+		case 4:
+			swapOnSide(image, base, 0, 6, 5, 6, 11, 0, 7, 0, 3, 8);
+			break;
+		case 5:
+			swapOnSide(image, base, 0, 8, 1, 8, 10, 8, 11, 8, 4, 0);
+			break;
+	}
+	rotateFaceOnce(image, face);
+};
+const applyRepeatedTurns = (image, amount, turn) => {
+	for (let index = 0; index < amount; index += 1) turn();
+};
+const cycleCenters = (image, firstFace, secondFace, thirdFace, fourthFace, fifthFace) => {
+	cycleStickers(image, [firstFace, CENTER_INDEX], [secondFace, CENTER_INDEX], [thirdFace, CENTER_INDEX], [fourthFace, CENTER_INDEX], [fifthFace, CENTER_INDEX]);
+};
+const swapWholeFace = (image, firstFace, firstSticker, secondFace, secondSticker, thirdFace, thirdSticker, fourthFace, fourthSticker, fifthFace, fifthSticker) => {
+	for (let index = 0; index < 10; index += 1) cycleStickers(image, [firstFace, (firstSticker + index) % 10], [secondFace, (secondSticker + index) % 10], [thirdFace, (thirdSticker + index) % 10], [fourthFace, (fourthSticker + index) % 10], [fifthFace, (fifthSticker + index) % 10]);
+	cycleCenters(image, firstFace, secondFace, thirdFace, fourthFace, fifthFace);
+};
+const bigTurnOnce = (image, face) => {
+	if (face === "DBR") {
+		for (let index = 0; index < 7; index += 1) cycleStickers(image, [0, (1 + index) % 10], [4, (3 + index) % 10], [11, (1 + index) % 10], [10, (1 + index) % 10], [1, (1 + index) % 10]);
+		cycleCenters(image, 0, 4, 11, 10, 1);
+		swapWholeFace(image, 2, 0, 3, 0, 7, 0, 6, 8, 9, 8);
+		rotateFaceOnce(image, "DBR");
+		return;
+	}
+	for (let index = 0; index < 7; index += 1) cycleStickers(image, [1, (9 + index) % 10], [2, (1 + index) % 10], [3, (3 + index) % 10], [4, (5 + index) % 10], [5, (7 + index) % 10]);
+	cycleCenters(image, 1, 2, 3, 4, 5);
+	swapWholeFace(image, 11, 0, 10, 8, 9, 6, 8, 4, 7, 2);
+	rotateFaceOnce(image, "D");
+};
+const bigTurnFace = (name) => name === "R" ? "DBR" : "D";
+const validateMove = (move) => {
+	if (typeof move !== "object" || move === null) throw new InvalidMoveError(MALFORMED_MOVE, "megaminx");
+	if (move.type === "face") {
+		if (!isMegaminxFace(move.face) || !isMoveAmount(move.amount)) throw new InvalidMoveError(MALFORMED_MOVE, "megaminx");
+		return move;
+	}
+	if (move.type === "big-turn" && isBigTurnName(move.name) && isMoveAmount(move.amount)) return move;
+	throw new InvalidMoveError(MALFORMED_MOVE, "megaminx");
+};
+const createSolvedMegaminxState = () => createMegaminxState(MEGAMINX_FACES.map((_, face) => Array(STICKERS_PER_FACE).fill(face)));
+const applyMegaminxMove = (state, move) => {
+	const validMove = validateMove(move);
+	const nextImage = cloneMegaminxImage(state.image);
+	if (validMove.type === "face") applyRepeatedTurns(nextImage, validMove.amount, () => turnFaceOnce(nextImage, validMove.face));
+	else applyRepeatedTurns(nextImage, validMove.amount, () => bigTurnOnce(nextImage, bigTurnFace(validMove.name)));
+	return createMegaminxState(nextImage);
+};
+const areMegaminxStatesEqual = (a, b) => a.image.every((face, faceIndexValue) => face.every((sticker, stickerIndex) => sticker === b.image[faceIndexValue]?.[stickerIndex]));
+//#endregion
+export { applyMegaminxMove, areMegaminxStatesEqual, createSolvedMegaminxState };

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

@@ -0,0 +1,19 @@
+import { WcaEventId } from "./events2.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/puzzle-definition.d.ts
+interface PuzzleDefinition<State, Move> {
+  readonly id: string;
+  readonly eventIds: readonly WcaEventId[];
+  createSolvedState(): State;
+  parseAlgorithm(algorithm: string): readonly Move[];
+  applyMove(state: State, move: Move): State;
+  applyAlgorithm(state: State, algorithm: string): State;
+  isSolved(state: State): boolean;
+  normalizeState?(state: State): State;
+}
+interface AppliedPuzzleState<State> {
+  readonly puzzleId: string;
+  readonly state: State;
+}
+//#endregion
+export { AppliedPuzzleState, PuzzleDefinition };

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

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

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm.mjs";
+import { parsePyraminxAlgorithm } from "./pyraminx-parser.mjs";
+import { applyPyraminxMove, arePyraminxStatesEqual, createSolvedPyraminxState } from "./pyraminx-state.mjs";
+//#region ../scramble-puzzle/src/pyraminx/pyraminx-definition.ts
+const createPyraminxDefinition = () => {
+	const definition = {
+		id: "pyraminx",
+		eventIds: ["pyram"],
+		createSolvedState: createSolvedPyraminxState,
+		parseAlgorithm: parsePyraminxAlgorithm,
+		applyMove: applyPyraminxMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => arePyraminxStatesEqual(state, createSolvedPyraminxState())
+	};
+	return definition;
+};
+//#endregion
+export { createPyraminxDefinition };

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm2.mjs";
+import { parsePyraminxAlgorithm } from "./pyraminx-parser2.mjs";
+import { applyPyraminxMove, arePyraminxStatesEqual, createSolvedPyraminxState } from "./pyraminx-state2.mjs";
+//#region .build/vendor/scramble-puzzle/src/pyraminx/pyraminx-definition.ts
+const createPyraminxDefinition = () => {
+	const definition = {
+		id: "pyraminx",
+		eventIds: ["pyram"],
+		createSolvedState: createSolvedPyraminxState,
+		parseAlgorithm: parsePyraminxAlgorithm,
+		applyMove: applyPyraminxMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => arePyraminxStatesEqual(state, createSolvedPyraminxState())
+	};
+	return definition;
+};
+//#endregion
+export { createPyraminxDefinition };

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

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

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

@@ -0,0 +1,34 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { splitAlgorithm } from "../algorithm.mjs";
+//#region ../scramble-puzzle/src/pyraminx/pyraminx-parser.ts
+const PYRAMINX_FACES = [
+	"F",
+	"D",
+	"L",
+	"R"
+];
+const PYRAMINX_AXES = [
+	"U",
+	"L",
+	"R",
+	"B"
+];
+const PYRAMINX_MOVE_PATTERN = /^([ULRBulrb])('?)$/;
+const PYRAMINX_AXIS_SET = new Set(PYRAMINX_AXES);
+const isPyraminxAxis = (face) => PYRAMINX_AXIS_SET.has(face);
+const parsePyraminxMove = (token) => {
+	const match = token.match(PYRAMINX_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "pyraminx");
+	const [, rawFace, suffix] = match;
+	if (rawFace === void 0) throw new InvalidMoveError(token, "pyraminx");
+	const face = rawFace.toUpperCase();
+	if (!isPyraminxAxis(face)) throw new InvalidMoveError(token, "pyraminx");
+	return {
+		type: rawFace === face ? "turn" : "tip",
+		face,
+		amount: suffix === "'" ? 2 : 1
+	};
+};
+const parsePyraminxAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parsePyraminxMove);
+//#endregion
+export { PYRAMINX_AXES, PYRAMINX_FACES, parsePyraminxAlgorithm, parsePyraminxMove };

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

@@ -0,0 +1,21 @@
+//#region .build/vendor/scramble-puzzle/src/pyraminx/pyraminx-parser.d.ts
+declare const PYRAMINX_FACES: readonly ["F", "D", "L", "R"];
+declare const PYRAMINX_AXES: readonly ["U", "L", "R", "B"];
+type PyraminxFace = (typeof PYRAMINX_FACES)[number];
+type PyraminxAxis = (typeof PYRAMINX_AXES)[number];
+type PyraminxMoveAmount = 1 | 2;
+interface PyraminxTurnMove {
+  readonly type: 'turn';
+  readonly face: PyraminxAxis;
+  readonly amount: PyraminxMoveAmount;
+}
+interface PyraminxTipMove {
+  readonly type: 'tip';
+  readonly face: PyraminxAxis;
+  readonly amount: PyraminxMoveAmount;
+}
+type PyraminxMove = PyraminxTurnMove | PyraminxTipMove;
+declare const parsePyraminxMove: (token: string) => PyraminxMove;
+declare const parsePyraminxAlgorithm: (algorithm: string) => readonly PyraminxMove[];
+//#endregion
+export { PYRAMINX_AXES, PYRAMINX_FACES, PyraminxAxis, PyraminxFace, PyraminxMove, PyraminxMoveAmount, PyraminxTipMove, PyraminxTurnMove, parsePyraminxAlgorithm, parsePyraminxMove };

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

@@ -0,0 +1,34 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { splitAlgorithm } from "../algorithm2.mjs";
+//#region .build/vendor/scramble-puzzle/src/pyraminx/pyraminx-parser.ts
+const PYRAMINX_FACES = [
+	"F",
+	"D",
+	"L",
+	"R"
+];
+const PYRAMINX_AXES = [
+	"U",
+	"L",
+	"R",
+	"B"
+];
+const PYRAMINX_MOVE_PATTERN = /^([ULRBulrb])('?)$/;
+const PYRAMINX_AXIS_SET = new Set(PYRAMINX_AXES);
+const isPyraminxAxis = (face) => PYRAMINX_AXIS_SET.has(face);
+const parsePyraminxMove = (token) => {
+	const match = token.match(PYRAMINX_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "pyraminx");
+	const [, rawFace, suffix] = match;
+	if (rawFace === void 0) throw new InvalidMoveError(token, "pyraminx");
+	const face = rawFace.toUpperCase();
+	if (!isPyraminxAxis(face)) throw new InvalidMoveError(token, "pyraminx");
+	return {
+		type: rawFace === face ? "turn" : "tip",
+		face,
+		amount: suffix === "'" ? 2 : 1
+	};
+};
+const parsePyraminxAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parsePyraminxMove);
+//#endregion
+export { PYRAMINX_AXES, PYRAMINX_FACES, parsePyraminxAlgorithm, parsePyraminxMove };

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

@@ -0,0 +1,11 @@
+import { PyraminxFace } from "./pyraminx-parser.mjs";
+
+//#region ../scramble-puzzle/src/pyraminx/pyraminx-state.d.ts
+type PyraminxFacelet = number;
+type PyraminxFaceState = readonly PyraminxFacelet[];
+type PyraminxImage = readonly PyraminxFaceState[];
+interface PyraminxState {
+  readonly image: PyraminxImage;
+}
+//#endregion
+export { PyraminxState };

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

@@ -0,0 +1,90 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { PYRAMINX_AXES, PYRAMINX_FACES } from "./pyraminx-parser.mjs";
+//#region ../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 };