cubegin 0.0.1

package/dist/scramble-core/src/solvers/two-by-two-solver.mjs

@@ -0,0 +1,298 @@
+//#region .build/vendor/scramble-core/src/solvers/two-by-two-solver.ts
+const ERROR_PREFIX = "@cubegin/scramble-core";
+const N_PERM = 5040;
+const N_ORIENT = 729;
+const N_MOVES = 9;
+const MAX_LENGTH = 20;
+const MOVE_TO_STRING = [
+	"U",
+	"U2",
+	"U'",
+	"R",
+	"R2",
+	"R'",
+	"F",
+	"F2",
+	"F'"
+];
+const INVERSE_MOVE_TO_STRING = [
+	"U'",
+	"U2",
+	"U",
+	"R'",
+	"R2",
+	"R",
+	"F'",
+	"F2",
+	"F"
+];
+const FACT = [
+	1,
+	1,
+	2,
+	6,
+	24,
+	120,
+	720
+];
+const COST_U = 8;
+const COST_U_LOW = 20;
+const COST_U2 = 10;
+const COST_U3 = 7;
+const COST_R = 6;
+const COST_R2 = 10;
+const COST_R3 = 6;
+const COST_F = 10;
+const COST_F2 = 30;
+const COST_F3 = 19;
+const COST_REGRIP = 20;
+let cachedTables;
+const packPerm = (cubies) => {
+	let index = 0;
+	let value = 106181136;
+	for (let position = 0; position < 6; position += 1) {
+		const shiftedCubie = (cubies[position] & 7) << 2;
+		index = (7 - position) * index + (value >> shiftedCubie & 7);
+		value -= 17895696 << shiftedCubie;
+	}
+	return index;
+};
+const unpackPerm = (permutation, cubies) => {
+	let remaining = permutation;
+	let value = 106181136;
+	for (let position = 0; position < 6; position += 1) {
+		const divisor = FACT[6 - position];
+		let cubie = Math.floor(remaining / divisor);
+		remaining -= cubie * divisor;
+		cubie <<= 2;
+		cubies[position] = value >> cubie & 7;
+		const mask = (1 << cubie) - 1;
+		value = (value & mask) + (value >> 4 & ~mask);
+	}
+	cubies[6] = value;
+};
+const packOrient = (cubies) => {
+	let orientation = 0;
+	for (let position = 0; position < 6; position += 1) orientation = 3 * orientation + (cubies[position] >> 3);
+	return orientation;
+};
+const unpackOrient = (orientation, cubies) => {
+	let remaining = orientation;
+	let orientationSum = 0;
+	for (let position = 5; position >= 0; position -= 1) {
+		const cubieOrientation = remaining % 3;
+		cubies[position] = cubieOrientation << 3;
+		orientationSum += cubieOrientation;
+		remaining = Math.floor(remaining / 3);
+	}
+	cubies[6] = (42424242 - orientationSum) % 3 << 3;
+};
+const cycle = (cubies, first, second, third, fourth, times) => {
+	for (let count = 0; count < times; count += 1) {
+		const previousFourth = cubies[fourth];
+		cubies[fourth] = cubies[third];
+		cubies[third] = cubies[second];
+		cubies[second] = cubies[first];
+		cubies[first] = previousFourth;
+	}
+};
+const cycleAndOrient = (cubies, first, second, third, fourth, times) => {
+	for (let count = 0; count < times; count += 1) {
+		const previousFourth = cubies[fourth];
+		cubies[fourth] = (cubies[third] + 8) % 24;
+		cubies[third] = (cubies[second] + 16) % 24;
+		cubies[second] = (cubies[first] + 8) % 24;
+		cubies[first] = (previousFourth + 16) % 24;
+	}
+};
+const moveCubies = (cubies, move) => {
+	const face = Math.floor(move / 3);
+	const times = move % 3 + 1;
+	switch (face) {
+		case 0:
+			cycle(cubies, 1, 3, 2, 0, times);
+			break;
+		case 1:
+			cycleAndOrient(cubies, 0, 2, 6, 4, times);
+			break;
+		case 2:
+			cycleAndOrient(cubies, 1, 0, 4, 5, times);
+			break;
+	}
+};
+const copyCubies = (source, target) => {
+	for (let index = 0; index < source.length; index += 1) target[index] = source[index];
+};
+const createMoveTables = () => {
+	const movePerm = Array.from({ length: N_PERM }, () => new Uint16Array(N_MOVES));
+	const moveOrient = Array.from({ length: N_ORIENT }, () => new Uint16Array(N_MOVES));
+	const cubies = Array.from({ length: 7 }, () => 0);
+	const movedCubies = Array.from({ length: 7 }, () => 0);
+	for (let permutation = 0; permutation < N_PERM; permutation += 1) {
+		unpackPerm(permutation, cubies);
+		for (let move = 0; move < N_MOVES; move += 1) {
+			copyCubies(cubies, movedCubies);
+			moveCubies(movedCubies, move);
+			movePerm[permutation][move] = packPerm(movedCubies);
+		}
+	}
+	for (let orientation = 0; orientation < N_ORIENT; orientation += 1) {
+		unpackOrient(orientation, cubies);
+		for (let move = 0; move < N_MOVES; move += 1) {
+			copyCubies(cubies, movedCubies);
+			moveCubies(movedCubies, move);
+			moveOrient[orientation][move] = packOrient(movedCubies);
+		}
+	}
+	return {
+		movePerm,
+		moveOrient
+	};
+};
+const createPruningTable = (size, moves) => {
+	const pruning = new Int8Array(size);
+	pruning.fill(-1);
+	pruning[0] = 0;
+	let done = 1;
+	for (let length = 0; done < size; length += 1) for (let coordinate = 0; coordinate < size; coordinate += 1) {
+		if (pruning[coordinate] !== length) continue;
+		for (let move = 0; move < N_MOVES; move += 1) {
+			const nextCoordinate = moves[coordinate][move];
+			if (pruning[nextCoordinate] !== -1) continue;
+			pruning[nextCoordinate] = length + 1;
+			done += 1;
+		}
+	}
+	return pruning;
+};
+const createTables = () => {
+	const { movePerm, moveOrient } = createMoveTables();
+	return {
+		movePerm,
+		moveOrient,
+		prunPerm: createPruningTable(N_PERM, movePerm),
+		prunOrient: createPruningTable(N_ORIENT, moveOrient)
+	};
+};
+const getTables = () => {
+	cachedTables ??= createTables();
+	return cachedTables;
+};
+const validateCoordinate = (coordinateName, coordinate, maxExclusive) => {
+	if (!Number.isSafeInteger(coordinate) || coordinate < 0 || coordinate >= maxExclusive) throw new RangeError(`${ERROR_PREFIX}: 2x2 ${coordinateName} must be an integer from 0 to ${maxExclusive - 1}`);
+};
+const validateState = (state) => {
+	validateCoordinate("permutation", state.permutation, N_PERM);
+	validateCoordinate("orientation", state.orientation, N_ORIENT);
+};
+const validateLength = (length) => {
+	if (!Number.isSafeInteger(length) || length < 0 || length > MAX_LENGTH) throw new RangeError(`${ERROR_PREFIX}: 2x2 solve length must be an integer from 0 to ${MAX_LENGTH}`);
+};
+const computeCost = (solution, index, currentCost, grip) => {
+	if (index < 0) return currentCost;
+	switch (solution[index]) {
+		case 0: return computeCost(solution, index - 1, currentCost + COST_U3, grip);
+		case 1: return computeCost(solution, index - 1, currentCost + COST_U2, grip);
+		case 2:
+			if (grip === 0) return computeCost(solution, index - 1, currentCost + COST_U, 0);
+			if (grip === -1) return Math.min(computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_U, 0), computeCost(solution, index - 1, currentCost + COST_U_LOW, grip));
+			return computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_U, 0);
+		case 3:
+			if (grip > -1) return computeCost(solution, index - 1, currentCost + COST_R3, grip - 1);
+			return computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_R3, -1);
+		case 4:
+			if (grip !== 0) return computeCost(solution, index - 1, currentCost + COST_R2, -grip);
+			return Math.min(computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_R2, -1), computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_R2, 1));
+		case 5:
+			if (grip < 1) return computeCost(solution, index - 1, currentCost + COST_R, grip + 1);
+			return computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_R, 1);
+		case 6:
+			if (grip !== 0) return computeCost(solution, index - 1, currentCost + COST_F3, grip);
+			return Math.min(computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_F3, -1), computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_F3, 1));
+		case 7:
+			if (grip === -1) return computeCost(solution, index - 1, currentCost + COST_F2, -1);
+			return computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_F2, -1);
+		case 8:
+			if (grip === -1) return computeCost(solution, index - 1, currentCost + COST_F, -1);
+			return computeCost(solution, index - 1, currentCost + COST_REGRIP + COST_F, -1);
+		default: return -1;
+	}
+};
+const search = ({ permutation, orientation, depth, length, lastMove, solution, bestSolution, tables }) => {
+	if (length === 0) {
+		if (permutation !== 0 || orientation !== 0) return false;
+		const cost = computeCost(solution, depth, 0, 0);
+		if (cost < bestSolution[depth]) {
+			for (let index = 0; index < depth; index += 1) bestSolution[index] = solution[index];
+			bestSolution[depth] = cost;
+		}
+		return true;
+	}
+	if (tables.prunPerm[permutation] > length || tables.prunOrient[orientation] > length) return false;
+	let solutionFound = false;
+	for (let move = 0; move < N_MOVES; move += 1) {
+		if (Math.floor(move / 3) === Math.floor(lastMove / 3)) continue;
+		solution[depth] = move;
+		solutionFound = search({
+			permutation: tables.movePerm[permutation][move],
+			orientation: tables.moveOrient[orientation][move],
+			depth: depth + 1,
+			length: length - 1,
+			lastMove: move,
+			solution,
+			bestSolution,
+			tables
+		}) || solutionFound;
+	}
+	return solutionFound;
+};
+const formatSolution = (solution, length, inverse) => {
+	if (length === 0) return "";
+	const moves = [];
+	if (inverse) for (let index = length - 1; index >= 0; index -= 1) moves.push(INVERSE_MOVE_TO_STRING[solution[index]]);
+	else for (let index = 0; index < length; index += 1) moves.push(MOVE_TO_STRING[solution[index]]);
+	return moves.join(" ");
+};
+var TwoByTwoSolver = class {
+	randomState(random) {
+		const state = {
+			permutation: random.nextInt(N_PERM),
+			orientation: random.nextInt(N_ORIENT)
+		};
+		validateState(state);
+		return state;
+	}
+	solveIn(state, maxLength) {
+		return this.solve(state, maxLength, false, false);
+	}
+	generateExactly(state, length) {
+		const scramble = this.solve(state, length, true, true);
+		if (scramble === null) throw new Error(`${ERROR_PREFIX}: could not generate a 2x2 scramble exactly ${length} moves long`);
+		return scramble;
+	}
+	solve(state, desiredLength, exactLength, inverse) {
+		validateState(state);
+		validateLength(desiredLength);
+		const tables = getTables();
+		const solution = Array.from({ length: MAX_LENGTH + 1 }, () => 0);
+		const bestSolution = Array.from({ length: MAX_LENGTH + 1 }, () => 0);
+		let length = exactLength ? desiredLength : 0;
+		while (length <= desiredLength) {
+			bestSolution[length] = 42424242;
+			if (search({
+				permutation: state.permutation,
+				orientation: state.orientation,
+				depth: 0,
+				length,
+				lastMove: 42,
+				solution,
+				bestSolution,
+				tables
+			})) return formatSolution(bestSolution, length, inverse);
+			length += 1;
+		}
+		return null;
+	}
+};
+//#endregion
+export { TwoByTwoSolver };

package/dist/scramble-core.d.mts

@@ -0,0 +1,15 @@
+import { RandomSource, createMathRandomSource } from "./scramble-core/src/random-source.mjs";
+import { DefaultScrambleGeneratorOptions, EventScrambleGenerator, GenerateOptions, ScrambleGenerator, ScrambleGeneratorOptions, ScrambleResult, createDefaultScrambleGenerator, createScrambleGenerator } from "./scramble-core/src/generator.mjs";
+import { ClockScrambleOptions, generateClockScramble } from "./scramble-core/src/generators/clock.mjs";
+import { CubeRandomTurnOptions, generateCubeRandomTurnScramble } from "./scramble-core/src/generators/cube-random-turns.mjs";
+import { FourByFourScrambleOptions, generateFourByFourNoInspectionScramble, generateFourByFourScramble } from "./scramble-core/src/generators/four-by-four.mjs";
+import { MegaminxScrambleOptions, generateMegaminxScramble } from "./scramble-core/src/generators/megaminx.mjs";
+import { PyraminxScrambleOptions, generatePyraminxScramble } from "./scramble-core/src/generators/pyraminx.mjs";
+import { SkewbScrambleOptions, generateSkewbScramble } from "./scramble-core/src/generators/skewb.mjs";
+import { SquareOneScrambleOptions, generateSquareOneScramble } from "./scramble-core/src/generators/square1.mjs";
+import { MultiBlindScrambleOptions, ThreeByThreeScrambleOptions, generateMultiBlindScramble, generateThreeByThreeFewestMovesScramble, generateThreeByThreeNoInspectionScramble, generateThreeByThreeScramble } from "./scramble-core/src/generators/three-by-three.mjs";
+import { TwoByTwoScrambleOptions, generateTwoByTwoScramble } from "./scramble-core/src/generators/two-by-two.mjs";
+import { PyraminxSolver, PyraminxSolverState } from "./scramble-core/src/solvers/pyraminx-solver.mjs";
+import { SkewbSolver, SkewbSolverState } from "./scramble-core/src/solvers/skewb-solver.mjs";
+import { TwoByTwoSolver, TwoByTwoState } from "./scramble-core/src/solvers/two-by-two-solver.mjs";
+export { type ClockScrambleOptions, type CubeRandomTurnOptions, type DefaultScrambleGeneratorOptions, type EventScrambleGenerator, type FourByFourScrambleOptions, type GenerateOptions, type MegaminxScrambleOptions, type MultiBlindScrambleOptions, type PyraminxScrambleOptions, PyraminxSolver, type PyraminxSolverState, type RandomSource, type ScrambleGenerator, type ScrambleGeneratorOptions, type ScrambleResult, type SkewbScrambleOptions, SkewbSolver, type SkewbSolverState, type SquareOneScrambleOptions, type ThreeByThreeScrambleOptions, type TwoByTwoScrambleOptions, TwoByTwoSolver, type TwoByTwoState, createDefaultScrambleGenerator, createMathRandomSource, createScrambleGenerator, generateClockScramble, generateCubeRandomTurnScramble, generateFourByFourNoInspectionScramble, generateFourByFourScramble, generateMegaminxScramble, generateMultiBlindScramble, generatePyraminxScramble, generateSkewbScramble, generateSquareOneScramble, generateThreeByThreeFewestMovesScramble, generateThreeByThreeNoInspectionScramble, generateThreeByThreeScramble, generateTwoByTwoScramble };

package/dist/scramble-core.mjs

@@ -0,0 +1,15 @@
+import { generateClockScramble } from "./scramble-core/src/generators/clock.mjs";
+import { generateCubeRandomTurnScramble } from "./scramble-core/src/generators/cube-random-turns.mjs";
+import { generateFourByFourNoInspectionScramble, generateFourByFourScramble } from "./scramble-core/src/generators/four-by-four.mjs";
+import { generateMegaminxScramble } from "./scramble-core/src/generators/megaminx.mjs";
+import { PyraminxSolver } from "./scramble-core/src/solvers/pyraminx-solver.mjs";
+import { generatePyraminxScramble } from "./scramble-core/src/generators/pyraminx.mjs";
+import { SkewbSolver } from "./scramble-core/src/solvers/skewb-solver.mjs";
+import { generateSkewbScramble } from "./scramble-core/src/generators/skewb.mjs";
+import { generateSquareOneScramble } from "./scramble-core/src/generators/square1.mjs";
+import { generateMultiBlindScramble, generateThreeByThreeFewestMovesScramble, generateThreeByThreeNoInspectionScramble, generateThreeByThreeScramble } from "./scramble-core/src/generators/three-by-three.mjs";
+import { TwoByTwoSolver } from "./scramble-core/src/solvers/two-by-two-solver.mjs";
+import { generateTwoByTwoScramble } from "./scramble-core/src/generators/two-by-two.mjs";
+import { createDefaultScrambleGenerator, createScrambleGenerator } from "./scramble-core/src/generator.mjs";
+import { createMathRandomSource } from "./scramble-core/src/random-source.mjs";
+export { PyraminxSolver, SkewbSolver, TwoByTwoSolver, createDefaultScrambleGenerator, createMathRandomSource, createScrambleGenerator, generateClockScramble, generateCubeRandomTurnScramble, generateFourByFourNoInspectionScramble, generateFourByFourScramble, generateMegaminxScramble, generateMultiBlindScramble, generatePyraminxScramble, generateSkewbScramble, generateSquareOneScramble, generateThreeByThreeFewestMovesScramble, generateThreeByThreeNoInspectionScramble, generateThreeByThreeScramble, generateTwoByTwoScramble };

package/dist/scramble-image/src/color.d.mts

@@ -0,0 +1,12 @@
+//#region .build/vendor/scramble-image/src/color.d.ts
+type HexColor = `#${string}`;
+declare const DEFAULT_CUBE_COLORS: Readonly<{
+  R: "#ff0000";
+  U: "#ffffff";
+  F: "#00ff00";
+  L: "#ff8000";
+  D: "#ffff00";
+  B: "#0000ff";
+}>;
+//#endregion
+export { DEFAULT_CUBE_COLORS, HexColor };

package/dist/scramble-image/src/color.mjs

@@ -0,0 +1,11 @@
+//#region .build/vendor/scramble-image/src/color.ts
+const DEFAULT_CUBE_COLORS = Object.freeze({
+	R: "#ff0000",
+	U: "#ffffff",
+	F: "#00ff00",
+	L: "#ff8000",
+	D: "#ffff00",
+	B: "#0000ff"
+});
+//#endregion
+export { DEFAULT_CUBE_COLORS };

package/dist/scramble-image/src/render.d.mts

@@ -0,0 +1,10 @@
+import { WcaEventId } from "../../scramble-puzzle/src/events.mjs";
+
+//#region .build/vendor/scramble-image/src/render.d.ts
+type ScrambleImageView = 'net' | 'isometric';
+interface ScrambleImageOptions {
+  view?: ScrambleImageView;
+}
+declare const renderScrambleImage: (eventId: WcaEventId, scramble: string, options?: ScrambleImageOptions) => string;
+//#endregion
+export { ScrambleImageOptions, ScrambleImageView, renderScrambleImage };

package/dist/scramble-image/src/render.mjs

@@ -0,0 +1,71 @@
+import { WCA_EVENT_INFO } from "../../scramble-puzzle/src/events.mjs";
+import { createCubeDefinition } from "../../scramble-puzzle/src/cube/cube-definition.mjs";
+import { createClockDefinition } from "../../scramble-puzzle/src/clock/clock-definition.mjs";
+import { createMegaminxDefinition } from "../../scramble-puzzle/src/megaminx/megaminx-definition.mjs";
+import { createPyraminxDefinition } from "../../scramble-puzzle/src/pyraminx/pyraminx-definition.mjs";
+import { createSkewbDefinition } from "../../scramble-puzzle/src/skewb/skewb-definition.mjs";
+import { createSquareOneDefinition } from "../../scramble-puzzle/src/square1/square1-definition.mjs";
+import "../../scramble-puzzle/src/index.mjs";
+import { renderClockState } from "./renderers/clock.mjs";
+import { renderCubeIsometric } from "./renderers/cube-isometric.mjs";
+import { renderCubeNet } from "./renderers/cube-net.mjs";
+import { renderMegaminxIsometricState } from "./renderers/megaminx-isometric.mjs";
+import { renderMegaminxState } from "./renderers/megaminx.mjs";
+import { renderPyraminxIsometricState } from "./renderers/pyraminx-isometric.mjs";
+import { renderPyraminxState } from "./renderers/pyraminx.mjs";
+import { renderSkewbIsometricState } from "./renderers/skewb-isometric.mjs";
+import { renderSkewbState } from "./renderers/skewb.mjs";
+import { renderSquareOneState } from "./renderers/square1.mjs";
+//#region .build/vendor/scramble-image/src/render.ts
+const CUBE_SIZE_BY_EVENT = {
+	"222": 2,
+	"333": 3,
+	"333bld": 3,
+	"333fm": 3,
+	"333oh": 3,
+	"333mbld": 3,
+	"444": 4,
+	"444bld": 4,
+	"555": 5,
+	"555bld": 5,
+	"666": 6,
+	"777": 7
+};
+const renderScrambleImage = (eventId, scramble, options = {}) => {
+	const eventInfo = WCA_EVENT_INFO[eventId];
+	const view = options.view ?? "net";
+	switch (eventInfo.puzzleId) {
+		case "cube": {
+			const size = CUBE_SIZE_BY_EVENT[eventId];
+			if (!size) throw new Error(`@cubegin/scramble-image: event '${eventId}' is not renderable yet`);
+			const cube = createCubeDefinition(size, [eventId]);
+			const state = cube.applyAlgorithm(cube.createSolvedState(), scramble);
+			return view === "isometric" ? renderCubeIsometric(state) : renderCubeNet(state);
+		}
+		case "clock": {
+			const clock = createClockDefinition();
+			return renderClockState(clock.applyAlgorithm(clock.createSolvedState(), scramble));
+		}
+		case "megaminx": {
+			const megaminx = createMegaminxDefinition();
+			const state = megaminx.applyAlgorithm(megaminx.createSolvedState(), scramble);
+			return view === "isometric" ? renderMegaminxIsometricState(state) : renderMegaminxState(state);
+		}
+		case "pyraminx": {
+			const pyraminx = createPyraminxDefinition();
+			const state = pyraminx.applyAlgorithm(pyraminx.createSolvedState(), scramble);
+			return view === "isometric" ? renderPyraminxIsometricState(state) : renderPyraminxState(state);
+		}
+		case "skewb": {
+			const skewb = createSkewbDefinition();
+			const state = skewb.applyAlgorithm(skewb.createSolvedState(), scramble);
+			return view === "isometric" ? renderSkewbIsometricState(state) : renderSkewbState(state);
+		}
+		case "square1": {
+			const squareOne = createSquareOneDefinition();
+			return renderSquareOneState(squareOne.applyAlgorithm(squareOne.createSolvedState(), scramble));
+		}
+	}
+};
+//#endregion
+export { renderScrambleImage };

package/dist/scramble-image/src/renderers/clock.d.mts

@@ -0,0 +1,6 @@
+import { ClockState } from "../../../scramble-puzzle/src/clock/clock-state.mjs";
+
+//#region .build/vendor/scramble-image/src/renderers/clock.d.ts
+declare const renderClockState: (state: ClockState) => string;
+//#endregion
+export { renderClockState };

package/dist/scramble-image/src/renderers/clock.mjs

@@ -0,0 +1,145 @@
+import { createSvgDocument } from "../svg/svg-document.mjs";
+import { circle, group, path } from "../svg/svg-elements.mjs";
+//#region .build/vendor/scramble-image/src/renderers/clock.ts
+const RADIUS = 70;
+const CLOCK_RADIUS = 14;
+const CLOCK_OUTER_RADIUS = 21;
+const POINT_RADIUS = (CLOCK_RADIUS + CLOCK_OUTER_RADIUS) / 2;
+const TICK_MARK_RADIUS = 1;
+const TOP_TICK_MARK_RADIUS = 2;
+const ARROW_HEIGHT = 10;
+const ARROW_RADIUS = 2;
+const PIN_RADIUS = 4;
+const GAP = 5;
+const WIDTH = 4 * (RADIUS + GAP);
+const HEIGHT = 2 * (RADIUS + GAP);
+const ARROW_ANGLE = Math.PI / 2 - Math.acos(ARROW_RADIUS / ARROW_HEIGHT);
+const COLORS = {
+	front: "#113366",
+	frontClock: "#ccddee",
+	frontTopClock: "#ffcc44",
+	frontHand: "#113366",
+	frontPin: "#88aacc",
+	back: "#ccddee",
+	backClock: "#113366",
+	backTopClock: "#cc6600",
+	backHand: "#ccddee",
+	backPin: "#446699",
+	stroke: "#000000"
+};
+const frontColors = {
+	body: COLORS.front,
+	clock: COLORS.frontClock,
+	topClock: COLORS.frontTopClock,
+	hand: COLORS.frontHand,
+	pin: COLORS.frontPin
+};
+const backColors = {
+	body: COLORS.back,
+	clock: COLORS.backClock,
+	topClock: COLORS.backTopClock,
+	hand: COLORS.backHand,
+	pin: COLORS.backPin
+};
+const translate = (x, y) => `translate(${x} ${y})`;
+const clockCenter = (sideIndex, clockIndex) => {
+	const sideCenterX = (sideIndex * 2 + 1) * (RADIUS + GAP);
+	const sideCenterY = RADIUS + GAP;
+	return [sideCenterX + 2 * (clockIndex % 3 - 1) * CLOCK_OUTER_RADIUS, sideCenterY + 2 * (Math.floor(clockIndex / 3) - 1) * CLOCK_OUTER_RADIUS];
+};
+const handPath = () => {
+	const x = ARROW_RADIUS * Math.cos(ARROW_ANGLE);
+	const y = -ARROW_RADIUS * Math.sin(ARROW_ANGLE);
+	return `M 0 0 L ${x} ${y} L 0 ${-ARROW_HEIGHT} L ${-x} ${y} Z`;
+};
+const sideColorFor = (sideIndex, rightSideUp) => {
+	if (sideIndex === 0) return rightSideUp ? frontColors : backColors;
+	return rightSideUp ? backColors : frontColors;
+};
+const handColorForClock = (clockIndex, rightSideUp) => {
+	return clockIndex < 9 !== rightSideUp ? backColors : frontColors;
+};
+const drawSideBackground = (sideIndex, colors) => {
+	const centerX = (sideIndex * 2 + 1) * (RADIUS + GAP);
+	const centerY = RADIUS + GAP;
+	const nodes = [];
+	for (const offsetX of [-2 * CLOCK_OUTER_RADIUS, 2 * CLOCK_OUTER_RADIUS]) for (const offsetY of [-2 * CLOCK_OUTER_RADIUS, 2 * CLOCK_OUTER_RADIUS]) nodes.push(circle({
+		cx: centerX + offsetX,
+		cy: centerY + offsetY,
+		r: CLOCK_OUTER_RADIUS,
+		fill: colors.body,
+		stroke: COLORS.stroke,
+		"stroke-width": 2
+	}));
+	nodes.push(circle({
+		cx: centerX,
+		cy: centerY,
+		r: RADIUS,
+		fill: colors.body,
+		stroke: COLORS.stroke,
+		"stroke-width": 2
+	}));
+	for (let clock = 0; clock < 9; clock += 1) {
+		const [clockX, clockY] = clockCenter(sideIndex, clock);
+		const ticks = [];
+		for (let tick = 0; tick < 12; tick += 1) ticks.push(circle({
+			cx: 0,
+			cy: -POINT_RADIUS,
+			r: tick === 0 ? TOP_TICK_MARK_RADIUS : TICK_MARK_RADIUS,
+			fill: tick === 0 ? colors.topClock : colors.clock,
+			transform: `rotate(${tick * 30})`
+		}));
+		nodes.push(group({ transform: translate(clockX, clockY) }, [circle({
+			cx: 0,
+			cy: 0,
+			r: CLOCK_RADIUS,
+			fill: colors.clock,
+			stroke: COLORS.stroke,
+			"stroke-width": 1
+		}), ...ticks]));
+	}
+	return nodes;
+};
+const drawHand = (clockIndex, position, rightSideUp) => {
+	const [x, y] = clockCenter(clockIndex < 9 ? 0 : 1, clockIndex % 9);
+	const colors = handColorForClock(clockIndex, rightSideUp);
+	return group({ transform: `${translate(x, y)} rotate(${position * 30} 0 0)` }, [path({
+		d: handPath(),
+		fill: colors.hand,
+		stroke: colors.hand,
+		"stroke-width": 2,
+		"stroke-linejoin": "round"
+	}), circle({
+		cx: 0,
+		cy: 0,
+		r: ARROW_RADIUS,
+		fill: colors.hand,
+		stroke: colors.hand,
+		"stroke-width": 2
+	})]);
+};
+const drawPins = (rightSideUp) => {
+	const pins = [];
+	for (const sideIndex of [0, 1]) {
+		const centerX = (sideIndex * 2 + 1) * (RADIUS + GAP);
+		const centerY = RADIUS + GAP;
+		const colors = sideIndex === 0 ? rightSideUp ? backColors : frontColors : rightSideUp ? frontColors : backColors;
+		for (const offsetX of [-CLOCK_OUTER_RADIUS, CLOCK_OUTER_RADIUS]) for (const offsetY of [-CLOCK_OUTER_RADIUS, CLOCK_OUTER_RADIUS]) pins.push(circle({
+			cx: centerX + offsetX,
+			cy: centerY + offsetY,
+			r: PIN_RADIUS,
+			fill: colors.pin
+		}));
+	}
+	return pins;
+};
+const renderClockState = (state) => {
+	return createSvgDocument(WIDTH, HEIGHT, [
+		...drawSideBackground(0, sideColorFor(0, state.rightSideUp)),
+		...drawSideBackground(1, sideColorFor(1, state.rightSideUp)),
+		...state.positions.map((position, index) => drawHand(index, position, state.rightSideUp)),
+		...drawPins(state.rightSideUp)
+	]);
+};
+//#endregion
+export { renderClockState };

package/dist/scramble-image/src/renderers/cube-isometric.d.mts

@@ -0,0 +1,8 @@
+import { CubeFacelet, CubeState } from "../../../scramble-puzzle/src/cube/cube-state.mjs";
+import { HexColor } from "../color.mjs";
+
+//#region .build/vendor/scramble-image/src/renderers/cube-isometric.d.ts
+type CubeIsometricColorScheme = Partial<Record<CubeFacelet, HexColor>>;
+declare const renderCubeIsometric: (state: CubeState, colorScheme?: CubeIsometricColorScheme) => string;
+//#endregion
+export { CubeIsometricColorScheme, renderCubeIsometric };