cubegin 0.0.1

package/dist/scramble-image/src/svg/svg-elements.d.mts

@@ -0,0 +1,15 @@
+//#region .build/vendor/scramble-image/src/svg/svg-elements.d.ts
+type SvgElementName = 'rect' | 'circle' | 'path' | 'text' | 'g';
+interface SvgNode {
+  name: SvgElementName;
+  attrs: Record<string, string | number>;
+  children?: readonly SvgNode[];
+  text?: string;
+}
+declare const rect: (attrs: Record<string, string | number>) => SvgNode;
+declare const circle: (attrs: Record<string, string | number>) => SvgNode;
+declare const path: (attrs: Record<string, string | number>) => SvgNode;
+declare const text: (attrs: Record<string, string | number>, value: string) => SvgNode;
+declare const group: (attrs: Record<string, string | number>, children: readonly SvgNode[]) => SvgNode;
+//#endregion
+export { SvgNode, circle, group, path, rect, text };

package/dist/scramble-image/src/svg/svg-elements.mjs

@@ -0,0 +1,25 @@
+//#region .build/vendor/scramble-image/src/svg/svg-elements.ts
+const rect = (attrs) => ({
+	name: "rect",
+	attrs
+});
+const circle = (attrs) => ({
+	name: "circle",
+	attrs
+});
+const path = (attrs) => ({
+	name: "path",
+	attrs
+});
+const text = (attrs, value) => ({
+	name: "text",
+	attrs,
+	text: value
+});
+const group = (attrs, children) => ({
+	name: "g",
+	attrs,
+	children
+});
+//#endregion
+export { circle, group, path, rect, text };

package/dist/scramble-image/src/svg/svg-serialize.mjs

@@ -0,0 +1,29 @@
+//#region .build/vendor/scramble-image/src/svg/svg-serialize.ts
+const ERROR_PREFIX = "@cubegin/scramble-image";
+const SUPPORTED_ELEMENT_NAMES = new Set([
+	"rect",
+	"circle",
+	"path",
+	"text",
+	"g"
+]);
+const SVG_NAME_PATTERN = /^[A-Za-z_:][A-Za-z0-9_.:-]*$/;
+const escapeAttr = (value) => String(value).replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+const assertValidElementName = (name) => {
+	if (!SUPPORTED_ELEMENT_NAMES.has(name)) throw new Error(`${ERROR_PREFIX}: invalid SVG element name '${name}'`);
+};
+const assertValidAttrName = (name) => {
+	if (!SVG_NAME_PATTERN.test(name)) throw new Error(`${ERROR_PREFIX}: invalid SVG attribute name '${name}'`);
+};
+const serializeSvgNode = (node) => {
+	assertValidElementName(node.name);
+	const attrs = Object.entries(node.attrs).map(([key, value]) => {
+		assertValidAttrName(key);
+		return ` ${key}="${escapeAttr(value)}"`;
+	}).join("");
+	const children = node.children?.map(serializeSvgNode).join("") ?? "";
+	const text = node.text === void 0 ? "" : escapeAttr(node.text);
+	return `<${node.name}${attrs}>${children}${text}</${node.name}>`;
+};
+//#endregion
+export { serializeSvgNode };

package/dist/scramble-image.d.mts

@@ -0,0 +1,15 @@
+import { DEFAULT_CUBE_COLORS, HexColor } from "./scramble-image/src/color.mjs";
+import { ScrambleImageOptions, ScrambleImageView, renderScrambleImage } from "./scramble-image/src/render.mjs";
+import { renderClockState } from "./scramble-image/src/renderers/clock.mjs";
+import { CubeIsometricColorScheme, renderCubeIsometric } from "./scramble-image/src/renderers/cube-isometric.mjs";
+import { renderCubeNet } from "./scramble-image/src/renderers/cube-net.mjs";
+import { MegaminxIsometricColorScheme, renderMegaminxIsometricState } from "./scramble-image/src/renderers/megaminx-isometric.mjs";
+import { MegaminxColorScheme, renderMegaminxState } from "./scramble-image/src/renderers/megaminx.mjs";
+import { PyraminxIsometricColorScheme, renderPyraminxIsometricState } from "./scramble-image/src/renderers/pyraminx-isometric.mjs";
+import { PyraminxColorScheme, renderPyraminxState } from "./scramble-image/src/renderers/pyraminx.mjs";
+import { SkewbIsometricColorScheme, renderSkewbIsometricState } from "./scramble-image/src/renderers/skewb-isometric.mjs";
+import { SkewbColorScheme, renderSkewbState } from "./scramble-image/src/renderers/skewb.mjs";
+import { SquareOneColorScheme, SquareOneFace, renderSquareOneState } from "./scramble-image/src/renderers/square1.mjs";
+import { SvgNode, circle, group, path, rect, text } from "./scramble-image/src/svg/svg-elements.mjs";
+import { createSvgDocument } from "./scramble-image/src/svg/svg-document.mjs";
+export { type CubeIsometricColorScheme, DEFAULT_CUBE_COLORS, type HexColor, type MegaminxColorScheme, type MegaminxIsometricColorScheme, type PyraminxColorScheme, type PyraminxIsometricColorScheme, type ScrambleImageOptions, type ScrambleImageView, type SkewbColorScheme, type SkewbIsometricColorScheme, type SquareOneColorScheme, type SquareOneFace, type SvgNode, circle, createSvgDocument, group, path, rect, renderClockState, renderCubeIsometric, renderCubeNet, renderMegaminxIsometricState, renderMegaminxState, renderPyraminxIsometricState, renderPyraminxState, renderScrambleImage, renderSkewbIsometricState, renderSkewbState, renderSquareOneState, text };

package/dist/scramble-image.mjs

@@ -0,0 +1,15 @@
+import { DEFAULT_CUBE_COLORS } from "./scramble-image/src/color.mjs";
+import { createSvgDocument } from "./scramble-image/src/svg/svg-document.mjs";
+import { circle, group, path, rect, text } from "./scramble-image/src/svg/svg-elements.mjs";
+import { renderClockState } from "./scramble-image/src/renderers/clock.mjs";
+import { renderCubeIsometric } from "./scramble-image/src/renderers/cube-isometric.mjs";
+import { renderCubeNet } from "./scramble-image/src/renderers/cube-net.mjs";
+import { renderMegaminxIsometricState } from "./scramble-image/src/renderers/megaminx-isometric.mjs";
+import { renderMegaminxState } from "./scramble-image/src/renderers/megaminx.mjs";
+import { renderPyraminxIsometricState } from "./scramble-image/src/renderers/pyraminx-isometric.mjs";
+import { renderPyraminxState } from "./scramble-image/src/renderers/pyraminx.mjs";
+import { renderSkewbIsometricState } from "./scramble-image/src/renderers/skewb-isometric.mjs";
+import { renderSkewbState } from "./scramble-image/src/renderers/skewb.mjs";
+import { renderSquareOneState } from "./scramble-image/src/renderers/square1.mjs";
+import { renderScrambleImage } from "./scramble-image/src/render.mjs";
+export { DEFAULT_CUBE_COLORS, circle, createSvgDocument, group, path, rect, renderClockState, renderCubeIsometric, renderCubeNet, renderMegaminxIsometricState, renderMegaminxState, renderPyraminxIsometricState, renderPyraminxState, renderScrambleImage, renderSkewbIsometricState, renderSkewbState, renderSquareOneState, text };

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

@@ -0,0 +1,8 @@
+import { PuzzleDefinition } from "./puzzle-definition.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/algorithm.d.ts
+type AlgorithmApplier<State, Move> = Pick<PuzzleDefinition<State, Move>, 'applyMove' | 'parseAlgorithm'>;
+declare const splitAlgorithm: (algorithm: string) => readonly string[];
+declare const applyAlgorithm: <State, Move>(definition: AlgorithmApplier<State, Move>, state: State, algorithm: string) => State;
+//#endregion
+export { applyAlgorithm, splitAlgorithm };

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

@@ -0,0 +1,16 @@
+import { InvalidScrambleError } from "./errors.mjs";
+//#region ../scramble-puzzle/src/algorithm.ts
+const splitAlgorithm = (algorithm) => {
+	const trimmedAlgorithm = algorithm.trim();
+	if (trimmedAlgorithm.length === 0) return [];
+	return trimmedAlgorithm.split(/\s+/u);
+};
+const applyAlgorithm = (definition, state, algorithm) => {
+	try {
+		return definition.parseAlgorithm(algorithm).reduce((nextState, move) => definition.applyMove(nextState, move), state);
+	} catch (err) {
+		throw new InvalidScrambleError(algorithm, err);
+	}
+};
+//#endregion
+export { applyAlgorithm, splitAlgorithm };

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

@@ -0,0 +1,16 @@
+import { InvalidScrambleError } from "./errors2.mjs";
+//#region .build/vendor/scramble-puzzle/src/algorithm.ts
+const splitAlgorithm = (algorithm) => {
+	const trimmedAlgorithm = algorithm.trim();
+	if (trimmedAlgorithm.length === 0) return [];
+	return trimmedAlgorithm.split(/\s+/u);
+};
+const applyAlgorithm = (definition, state, algorithm) => {
+	try {
+		return definition.parseAlgorithm(algorithm).reduce((nextState, move) => definition.applyMove(nextState, move), state);
+	} catch (err) {
+		throw new InvalidScrambleError(algorithm, err);
+	}
+};
+//#endregion
+export { applyAlgorithm, splitAlgorithm };

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

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

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

@@ -0,0 +1,18 @@
+import { applyAlgorithm } from "../algorithm.mjs";
+import { parseClockAlgorithm } from "./clock-parser.mjs";
+import { applyClockMove, areClockStatesEqual, createSolvedClockState } from "./clock-state.mjs";
+//#region ../scramble-puzzle/src/clock/clock-definition.ts
+const createClockDefinition = () => {
+	const definition = {
+		id: "clock",
+		eventIds: ["clock"],
+		createSolvedState: createSolvedClockState,
+		parseAlgorithm: parseClockAlgorithm,
+		applyMove: applyClockMove,
+		applyAlgorithm: (state, algorithm) => applyAlgorithm(definition, state, algorithm),
+		isSolved: (state) => areClockStatesEqual(state, createSolvedClockState())
+	};
+	return definition;
+};
+//#endregion
+export { createClockDefinition };

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

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

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

@@ -0,0 +1,18 @@
+//#region .build/vendor/scramble-puzzle/src/clock/clock-parser.d.ts
+declare const CLOCK_TURN_NAMES: readonly ["UR", "DR", "DL", "UL", "U", "R", "D", "L", "ALL"];
+type ClockTurnName = (typeof CLOCK_TURN_NAMES)[number];
+type ClockDirection = '+' | '-';
+interface ClockTurnMove {
+  readonly type: 'turn';
+  readonly name: ClockTurnName;
+  readonly amount: number;
+  readonly direction: ClockDirection;
+}
+interface ClockRotationMove {
+  readonly type: 'rotation';
+}
+type ClockMove = ClockTurnMove | ClockRotationMove;
+declare const parseClockMove: (token: string) => ClockMove;
+declare const parseClockAlgorithm: (algorithm: string) => readonly ClockMove[];
+//#endregion
+export { ClockDirection, ClockMove, ClockRotationMove, ClockTurnMove, ClockTurnName, parseClockAlgorithm, parseClockMove };

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

@@ -0,0 +1,35 @@
+import { InvalidMoveError } from "../errors.mjs";
+import { splitAlgorithm } from "../algorithm.mjs";
+//#region ../scramble-puzzle/src/clock/clock-parser.ts
+const CLOCK_TURN_NAMES = [
+	"UR",
+	"DR",
+	"DL",
+	"UL",
+	"U",
+	"R",
+	"D",
+	"L",
+	"ALL"
+];
+const CLOCK_MOVE_PATTERN = /^(UR|DR|DL|UL|ALL|U|R|D|L)(\d)([+-])$/;
+const CLOCK_TURN_NAME_SET = new Set(CLOCK_TURN_NAMES);
+const isClockTurnName = (name) => CLOCK_TURN_NAME_SET.has(name);
+const parseClockMove = (token) => {
+	if (token === "y2") return { type: "rotation" };
+	const match = token.match(CLOCK_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "clock");
+	const [, name, amountText, direction] = match;
+	if (!isClockTurnName(name) || direction !== "+" && direction !== "-") throw new InvalidMoveError(token, "clock");
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount < 0 || amount > 6 || direction === "-" && (amount === 0 || amount === 6)) throw new InvalidMoveError(token, "clock");
+	return {
+		type: "turn",
+		name,
+		amount,
+		direction
+	};
+};
+const parseClockAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseClockMove);
+//#endregion
+export { CLOCK_TURN_NAMES, parseClockAlgorithm, parseClockMove };

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

@@ -0,0 +1,35 @@
+import { InvalidMoveError } from "../errors2.mjs";
+import { splitAlgorithm } from "../algorithm2.mjs";
+//#region .build/vendor/scramble-puzzle/src/clock/clock-parser.ts
+const CLOCK_TURN_NAMES = [
+	"UR",
+	"DR",
+	"DL",
+	"UL",
+	"U",
+	"R",
+	"D",
+	"L",
+	"ALL"
+];
+const CLOCK_MOVE_PATTERN = /^(UR|DR|DL|UL|ALL|U|R|D|L)(\d)([+-])$/;
+const CLOCK_TURN_NAME_SET = new Set(CLOCK_TURN_NAMES);
+const isClockTurnName = (name) => CLOCK_TURN_NAME_SET.has(name);
+const parseClockMove = (token) => {
+	if (token === "y2") return { type: "rotation" };
+	const match = token.match(CLOCK_MOVE_PATTERN);
+	if (!match) throw new InvalidMoveError(token, "clock");
+	const [, name, amountText, direction] = match;
+	if (!isClockTurnName(name) || direction !== "+" && direction !== "-") throw new InvalidMoveError(token, "clock");
+	const amount = Number(amountText);
+	if (!Number.isSafeInteger(amount) || amount < 0 || amount > 6 || direction === "-" && (amount === 0 || amount === 6)) throw new InvalidMoveError(token, "clock");
+	return {
+		type: "turn",
+		name,
+		amount,
+		direction
+	};
+};
+const parseClockAlgorithm = (algorithm) => splitAlgorithm(algorithm).map(parseClockMove);
+//#endregion
+export { CLOCK_TURN_NAMES, parseClockAlgorithm, parseClockMove };

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

@@ -0,0 +1,8 @@
+//#region ../scramble-puzzle/src/clock/clock-state.d.ts
+type ClockPositions = readonly number[];
+interface ClockState {
+  readonly positions: ClockPositions;
+  readonly rightSideUp: boolean;
+}
+//#endregion
+export { ClockState };

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

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

@@ -0,0 +1,13 @@
+import { ClockMove } from "./clock-parser.mjs";
+
+//#region .build/vendor/scramble-puzzle/src/clock/clock-state.d.ts
+type ClockPositions = readonly number[];
+interface ClockState {
+  readonly positions: ClockPositions;
+  readonly rightSideUp: boolean;
+}
+declare const createSolvedClockState: () => ClockState;
+declare const applyClockMove: (state: ClockState, move: ClockMove) => ClockState;
+declare const areClockStatesEqual: (a: ClockState, b: ClockState) => boolean;
+//#endregion
+export { ClockPositions, ClockState, applyClockMove, areClockStatesEqual, createSolvedClockState };