cubegin 0.0.1

package/dist/scramble-image/src/renderers/cube-isometric.mjs

@@ -0,0 +1,204 @@
+import { DEFAULT_CUBE_COLORS } from "../color.mjs";
+import { createSvgDocument } from "../svg/svg-document.mjs";
+import { path } from "../svg/svg-elements.mjs";
+//#region .build/vendor/scramble-image/src/renderers/cube-isometric.ts
+const PADDING = 6;
+const VIEW_GAP = 28;
+const STROKE = "#000000";
+const STROKE_WIDTH = 2.5;
+const FACE_ORDER = [
+	"R",
+	"U",
+	"F",
+	"L",
+	"D",
+	"B"
+];
+const point = (x, y) => ({
+	x,
+	y
+});
+const transformFromCorners = (topLeft, topRight, bottomRight, bottomLeft) => ({
+	topLeft,
+	topRight,
+	bottomRight,
+	bottomLeft
+});
+const createCornerViewPoints = (geometry) => ({
+	top: point(geometry.centerX, geometry.topY),
+	leftTop: point(geometry.centerX - geometry.topHalfWidth, geometry.topEdgeY),
+	rightTop: point(geometry.centerX + geometry.topHalfWidth, geometry.topEdgeY),
+	center: point(geometry.centerX, geometry.centerY),
+	leftBottom: point(geometry.centerX - geometry.bottomHalfWidth, geometry.bottomEdgeY),
+	rightBottom: point(geometry.centerX + geometry.bottomHalfWidth, geometry.bottomEdgeY),
+	bottom: point(geometry.centerX, geometry.bottomY)
+});
+const frontView = createCornerViewPoints({
+	centerX: 84,
+	topY: 6,
+	topEdgeY: 42,
+	centerY: 80,
+	bottomEdgeY: 116,
+	bottomY: 160,
+	topHalfWidth: 74,
+	bottomHalfWidth: 74
+});
+const backView = createCornerViewPoints({
+	centerX: 84,
+	topY: 6,
+	topEdgeY: 42,
+	centerY: 80,
+	bottomEdgeY: 116,
+	bottomY: 160,
+	topHalfWidth: 74,
+	bottomHalfWidth: 74
+});
+const FRONT_VIEW_FACES = [
+	{
+		face: "U",
+		transform: transformFromCorners(frontView.leftTop, frontView.top, frontView.rightTop, frontView.center)
+	},
+	{
+		face: "F",
+		transform: transformFromCorners(frontView.leftTop, frontView.center, frontView.bottom, frontView.leftBottom)
+	},
+	{
+		face: "R",
+		transform: transformFromCorners(frontView.center, frontView.rightTop, frontView.rightBottom, frontView.bottom)
+	}
+];
+const BACK_VIEW_FACES = [
+	{
+		face: "D",
+		transform: transformFromCorners(backView.leftTop, backView.top, backView.rightTop, backView.center)
+	},
+	{
+		face: "B",
+		transform: transformFromCorners(backView.leftTop, backView.center, backView.bottom, backView.leftBottom)
+	},
+	{
+		face: "L",
+		transform: transformFromCorners(backView.center, backView.rightTop, backView.rightBottom, backView.bottom)
+	}
+];
+const interpolatePoint = (start, end, ratio) => ({
+	x: start.x + (end.x - start.x) * ratio,
+	y: start.y + (end.y - start.y) * ratio
+});
+const transformPoint = (pointValue, transform) => {
+	return interpolatePoint(interpolatePoint(transform.topLeft, transform.topRight, pointValue.x), interpolatePoint(transform.bottomLeft, transform.bottomRight, pointValue.x), pointValue.y);
+};
+const stickerPoints = (row, col, size, transform) => {
+	const left = col / size;
+	const right = (col + 1) / size;
+	const top = row / size;
+	const bottom = (row + 1) / size;
+	return [
+		transformPoint(point(left, top), transform),
+		transformPoint(point(right, top), transform),
+		transformPoint(point(right, bottom), transform),
+		transformPoint(point(left, bottom), transform)
+	];
+};
+const polygonPath = (points) => {
+	const [firstPoint, ...remainingPoints] = points;
+	if (!firstPoint) return "";
+	return [
+		`M ${formatCoordinate(firstPoint.x)} ${formatCoordinate(firstPoint.y)}`,
+		...remainingPoints.map((pointValue) => `L ${formatCoordinate(pointValue.x)} ${formatCoordinate(pointValue.y)}`),
+		"Z"
+	].join(" ");
+};
+const formatCoordinate = (value) => Number(value.toFixed(3));
+const lineworkPath = (segments) => segments.map(({ start, end }) => `M ${formatCoordinate(start.x)} ${formatCoordinate(start.y)} L ${formatCoordinate(end.x)} ${formatCoordinate(end.y)}`).join(" ");
+const cubeFaceIndex = (face) => FACE_ORDER.indexOf(face);
+const createStickerPolygonsForView = (state, colors, faces) => {
+	const stickers = [];
+	for (const { face, transform } of faces) {
+		const faceIndex = cubeFaceIndex(face);
+		const faceImage = state.image[faceIndex];
+		for (let row = 0; row < state.size; row += 1) for (let col = 0; col < state.size; col += 1) stickers.push({
+			points: stickerPoints(row, col, state.size, transform),
+			fill: colors[faceImage[row][col]]
+		});
+	}
+	return stickers;
+};
+const createStickerPolygons = (state, colors) => {
+	const frontViewStickers = createStickerPolygonsForView(state, colors, FRONT_VIEW_FACES);
+	const backViewStickers = createStickerPolygonsForView(state, colors, BACK_VIEW_FACES);
+	const [frontMinX, frontMinY, frontMaxX] = boundsFor(frontViewStickers);
+	const [backMinX, backMinY] = boundsFor(backViewStickers);
+	const backOffsetX = frontMaxX - frontMinX + VIEW_GAP;
+	const frontOffsetY = Math.max(0, backMinY - frontMinY);
+	const backOffsetY = Math.max(0, frontMinY - backMinY);
+	return [...frontViewStickers.map((sticker) => ({
+		points: translatePoints(sticker.points, -frontMinX, -frontMinY + frontOffsetY),
+		fill: sticker.fill
+	})), ...backViewStickers.map((sticker) => ({
+		points: translatePoints(sticker.points, backOffsetX - backMinX, -backMinY + backOffsetY),
+		fill: sticker.fill
+	}))];
+};
+const segmentKey = ({ start, end }) => {
+	const startKey = `${formatCoordinate(start.x)},${formatCoordinate(start.y)}`;
+	const endKey = `${formatCoordinate(end.x)},${formatCoordinate(end.y)}`;
+	return startKey < endKey ? `${startKey}|${endKey}` : `${endKey}|${startKey}`;
+};
+const createLineworkSegments = (stickers) => {
+	const segments = /* @__PURE__ */ new Map();
+	for (const sticker of stickers) for (let index = 0; index < sticker.points.length; index += 1) {
+		const segment = {
+			start: sticker.points[index],
+			end: sticker.points[(index + 1) % sticker.points.length]
+		};
+		segments.set(segmentKey(segment), segment);
+	}
+	return [...segments.values()];
+};
+const drawStickers = (stickers) => stickers.map((sticker) => path({
+	d: polygonPath(sticker.points.map((pointValue) => ({
+		x: pointValue.x + PADDING,
+		y: pointValue.y + PADDING
+	}))),
+	fill: sticker.fill,
+	stroke: "none"
+}));
+const drawLinework = (stickers) => path({
+	d: lineworkPath(createLineworkSegments(stickers.map((sticker) => ({
+		points: sticker.points.map((pointValue) => ({
+			x: pointValue.x + PADDING,
+			y: pointValue.y + PADDING
+		})),
+		fill: sticker.fill
+	})))),
+	fill: "none",
+	stroke: STROKE,
+	"stroke-linecap": "round",
+	"stroke-linejoin": "round",
+	"stroke-width": STROKE_WIDTH
+});
+const translatePoints = (points, offsetX, offsetY) => points.map((pointValue) => ({
+	x: pointValue.x + offsetX,
+	y: pointValue.y + offsetY
+}));
+const boundsFor = (stickers) => {
+	const points = stickers.flatMap((sticker) => sticker.points);
+	return [
+		Math.min(...points.map((pointValue) => pointValue.x)),
+		Math.min(...points.map((pointValue) => pointValue.y)),
+		Math.max(...points.map((pointValue) => pointValue.x)),
+		Math.max(...points.map((pointValue) => pointValue.y))
+	];
+};
+const renderCubeIsometric = (state, colorScheme = {}) => {
+	const stickers = createStickerPolygons(state, {
+		...DEFAULT_CUBE_COLORS,
+		...colorScheme
+	});
+	const [, , maxX, maxY] = boundsFor(stickers);
+	const nodes = [...drawStickers(stickers), drawLinework(stickers)];
+	return createSvgDocument(Math.ceil(maxX + 2 * PADDING), Math.ceil(maxY + 2 * PADDING), nodes);
+};
+//#endregion
+export { renderCubeIsometric };

package/dist/scramble-image/src/renderers/cube-net.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-net.d.ts
+type CubeColorScheme = Partial<Record<CubeFacelet, HexColor>>;
+declare const renderCubeNet: (state: CubeState, colorScheme?: CubeColorScheme) => string;
+//#endregion
+export { renderCubeNet };

package/dist/scramble-image/src/renderers/cube-net.mjs

@@ -0,0 +1,52 @@
+import { DEFAULT_CUBE_COLORS } from "../color.mjs";
+import { createSvgDocument } from "../svg/svg-document.mjs";
+import { rect } from "../svg/svg-elements.mjs";
+//#region .build/vendor/scramble-image/src/renderers/cube-net.ts
+const GAP = 2;
+const STICKER = 10;
+const STROKE = "#000000";
+const STROKE_WIDTH = 1;
+const FACE_ORDER = [
+	"R",
+	"U",
+	"F",
+	"L",
+	"D",
+	"B"
+];
+const createFaceOrigins = (unit) => ({
+	L: [GAP, 2 * GAP + unit],
+	D: [2 * GAP + unit, 3 * GAP + 2 * unit],
+	B: [4 * GAP + 3 * unit, 2 * GAP + unit],
+	R: [3 * GAP + 2 * unit, 2 * GAP + unit],
+	U: [2 * GAP + unit, GAP],
+	F: [2 * GAP + unit, 2 * GAP + unit]
+});
+const renderCubeNet = (state, colorScheme = {}) => {
+	const colors = {
+		...DEFAULT_CUBE_COLORS,
+		...colorScheme
+	};
+	const unit = state.size * STICKER;
+	const width = (unit + GAP) * 4 + GAP;
+	const height = (unit + GAP) * 3 + GAP;
+	const faceOrigins = createFaceOrigins(unit);
+	const nodes = [];
+	for (const [face, [originX, originY]] of Object.entries(faceOrigins)) {
+		const faceIndex = FACE_ORDER.indexOf(face);
+		const stickers = state.image[faceIndex];
+		for (let row = 0; row < state.size; row += 1) for (let col = 0; col < state.size; col += 1) nodes.push(rect({
+			x: originX + col * STICKER,
+			y: originY + row * STICKER,
+			width: STICKER,
+			height: STICKER,
+			fill: colors[stickers[row][col]],
+			stroke: STROKE,
+			"stroke-width": STROKE_WIDTH,
+			"shape-rendering": "crispEdges"
+		}));
+	}
+	return createSvgDocument(width, height, nodes);
+};
+//#endregion
+export { renderCubeNet };

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

@@ -0,0 +1,9 @@
+import { MegaminxFace } from "../../../scramble-puzzle/src/megaminx/megaminx-parser.mjs";
+import { MegaminxState } from "../../../scramble-puzzle/src/megaminx/megaminx-state.mjs";
+import { HexColor } from "../color.mjs";
+
+//#region .build/vendor/scramble-image/src/renderers/megaminx-isometric.d.ts
+type MegaminxIsometricColorScheme = Partial<Record<MegaminxFace, HexColor>>;
+declare const renderMegaminxIsometricState: (state: MegaminxState, colorScheme?: MegaminxIsometricColorScheme) => string;
+//#endregion
+export { MegaminxIsometricColorScheme, renderMegaminxIsometricState };

package/dist/scramble-image/src/renderers/megaminx-isometric.mjs

@@ -0,0 +1,320 @@
+import { MEGAMINX_FACES } from "../../../scramble-puzzle/src/megaminx/megaminx-parser.mjs";
+import "../../../scramble-puzzle/src/index.mjs";
+import { createSvgDocument } from "../svg/svg-document.mjs";
+import { path } from "../svg/svg-elements.mjs";
+//#region .build/vendor/scramble-image/src/renderers/megaminx-isometric.ts
+const WIDTH = 410;
+const HEIGHT = 190;
+const PADDING = 8;
+const VIEW_GAP = 24;
+const FACE_RADIUS = 52;
+const ADJACENT_DEPTH = .52;
+const STROKE = "#000000";
+const STROKE_WIDTH = 2.75;
+const DEFAULT_MEGAMINX_COLORS = {
+	U: "#ffffff",
+	BL: "#ffcc00",
+	BR: "#0000b3",
+	R: "#dd0000",
+	F: "#006600",
+	L: "#8a1aff",
+	D: "#999999",
+	DR: "#ffffb3",
+	DBR: "#ff99ff",
+	B: "#71e600",
+	DBL: "#ff8433",
+	DL: "#88ddff"
+};
+const VIEW_SPECS = [{
+	centerFace: "F",
+	faceByEdge: [
+		"DL",
+		"L",
+		"U",
+		"R",
+		"DR"
+	],
+	rotation: Math.PI / 2
+}, {
+	centerFace: "B",
+	faceByEdge: [
+		"BL",
+		"DBL",
+		"D",
+		"DBR",
+		"BR"
+	],
+	rotation: -Math.PI / 2
+}];
+const STICKER_ORIENTATIONS = {
+	U: {
+		mirrored: true,
+		rotation: 1
+	},
+	BL: {
+		mirrored: true,
+		rotation: 2
+	},
+	BR: {
+		mirrored: true,
+		rotation: 1
+	},
+	R: {
+		mirrored: true,
+		rotation: 3
+	},
+	F: {
+		mirrored: false,
+		rotation: 4
+	},
+	L: {
+		mirrored: true,
+		rotation: 0
+	},
+	D: {
+		mirrored: true,
+		rotation: 0
+	},
+	DR: {
+		mirrored: true,
+		rotation: 0
+	},
+	DBR: {
+		mirrored: true,
+		rotation: 2
+	},
+	B: {
+		mirrored: false,
+		rotation: 3
+	},
+	DBL: {
+		mirrored: true,
+		rotation: 4
+	},
+	DL: {
+		mirrored: true,
+		rotation: 1
+	}
+};
+const formatCoordinate = (value) => Number(value.toFixed(3));
+const wrapPentagonIndex = (index) => (index + 5) % 5;
+const wrapStickerIndex = (index) => (index + 10) % 10;
+const averagePoint = (first, second) => ({
+	x: (first.x + second.x) / 2,
+	y: (first.y + second.y) / 2
+});
+const pentagon = (rotation) => [
+	0,
+	1,
+	2,
+	3,
+	4
+].map((index) => {
+	const angle = rotation + 2 * Math.PI * index / 5;
+	return {
+		x: FACE_RADIUS * Math.cos(angle),
+		y: FACE_RADIUS * Math.sin(angle)
+	};
+});
+const projectPointToLine = (pointValue, lineStart, lineEnd) => {
+	const deltaX = lineEnd.x - lineStart.x;
+	const deltaY = lineEnd.y - lineStart.y;
+	const lengthSquared = deltaX * deltaX + deltaY * deltaY;
+	const ratio = ((pointValue.x - lineStart.x) * deltaX + (pointValue.y - lineStart.y) * deltaY) / lengthSquared;
+	return {
+		x: lineStart.x + ratio * deltaX,
+		y: lineStart.y + ratio * deltaY
+	};
+};
+const reflectPointAcrossLine = (pointValue, lineStart, lineEnd) => {
+	const projected = projectPointToLine(pointValue, lineStart, lineEnd);
+	return {
+		x: 2 * projected.x - pointValue.x,
+		y: 2 * projected.y - pointValue.y
+	};
+};
+const compressPointAwayFromLine = (pointValue, lineStart, lineEnd, scale) => {
+	const projected = projectPointToLine(pointValue, lineStart, lineEnd);
+	return {
+		x: projected.x + (pointValue.x - projected.x) * scale,
+		y: projected.y + (pointValue.y - projected.y) * scale
+	};
+};
+const adjacentBoundary = (centerBoundary, edgeIndex) => {
+	const lineStart = centerBoundary[edgeIndex];
+	const lineEnd = centerBoundary[(edgeIndex + 1) % centerBoundary.length];
+	return centerBoundary.map((pointValue) => compressPointAwayFromLine(reflectPointAcrossLine(pointValue, lineStart, lineEnd), lineStart, lineEnd, ADJACENT_DEPTH));
+};
+const stitchAdjacentBoundaries = (boundaries) => {
+	const sharedOuterPoints = boundaries.map((boundary, vertexIndex) => {
+		const currentFacePoint = boundary[wrapPentagonIndex(vertexIndex + 4)];
+		const previousFacePoint = boundaries[wrapPentagonIndex(vertexIndex - 1)][wrapPentagonIndex(vertexIndex + 1)];
+		return averagePoint(currentFacePoint, previousFacePoint);
+	});
+	return boundaries.map((boundary, edgeIndex) => boundary.map((pointValue, pointIndex) => {
+		if (pointIndex === wrapPentagonIndex(edgeIndex + 4)) return sharedOuterPoints[edgeIndex];
+		if (pointIndex === wrapPentagonIndex(edgeIndex + 2)) return sharedOuterPoints[wrapPentagonIndex(edgeIndex + 1)];
+		return pointValue;
+	}));
+};
+const createViewPlacements = (spec) => {
+	const centerBoundary = pentagon(spec.rotation);
+	const adjacentBoundaries = stitchAdjacentBoundaries(spec.faceByEdge.map((_, edgeIndex) => adjacentBoundary(centerBoundary, edgeIndex)));
+	const adjacentPlacements = spec.faceByEdge.map((face, edgeIndex) => ({
+		face,
+		boundary: adjacentBoundaries[edgeIndex]
+	}));
+	return [{
+		face: spec.centerFace,
+		boundary: centerBoundary
+	}, ...adjacentPlacements];
+};
+const translatePoint = (pointValue, offsetX, offsetY) => ({
+	x: pointValue.x + offsetX,
+	y: pointValue.y + offsetY
+});
+const translatePolygon = (points, offsetX, offsetY) => points.map((pointValue) => translatePoint(pointValue, offsetX, offsetY));
+const translatePlacements = (placements, offsetX, offsetY) => placements.map(({ face, boundary }) => ({
+	face,
+	boundary: translatePolygon(boundary, offsetX, offsetY)
+}));
+const boundsForPolygons = (polygons) => {
+	const points = polygons.flat();
+	const xs = points.map((pointValue) => pointValue.x);
+	const ys = points.map((pointValue) => pointValue.y);
+	return {
+		minX: Math.min(...xs),
+		minY: Math.min(...ys),
+		maxX: Math.max(...xs),
+		maxY: Math.max(...ys)
+	};
+};
+const boundsForPlacements = (placements) => boundsForPolygons(placements.map((placement) => placement.boundary));
+const layoutPlacements = () => {
+	const [leftView, rightView] = VIEW_SPECS.map(createViewPlacements);
+	const leftBounds = boundsForPlacements(leftView);
+	const rightBounds = boundsForPlacements(rightView);
+	const leftWidth = leftBounds.maxX - leftBounds.minX;
+	const rightWidth = rightBounds.maxX - rightBounds.minX;
+	const startX = (WIDTH - (leftWidth + VIEW_GAP + rightWidth)) / 2;
+	const viewHeight = HEIGHT - 2 * PADDING;
+	const leftHeight = leftBounds.maxY - leftBounds.minY;
+	const rightHeight = rightBounds.maxY - rightBounds.minY;
+	const leftOffsetY = PADDING + (viewHeight - leftHeight) / 2 - leftBounds.minY;
+	const rightOffsetY = PADDING + (viewHeight - rightHeight) / 2 - rightBounds.minY;
+	return [...translatePlacements(leftView, startX - leftBounds.minX, leftOffsetY), ...translatePlacements(rightView, startX + leftWidth + VIEW_GAP - rightBounds.minX, rightOffsetY)];
+};
+const FACE_PLACEMENTS = layoutPlacements();
+const det = (a, b, c, d) => a * d - b * c;
+const lineIntersection = (firstStart, firstEnd, secondStart, secondEnd) => {
+	const firstDet = det(firstStart.x, firstStart.y, firstEnd.x, firstEnd.y);
+	const secondDet = det(secondStart.x, secondStart.y, secondEnd.x, secondEnd.y);
+	const divisor = det(firstStart.x - firstEnd.x, firstStart.y - firstEnd.y, secondStart.x - secondEnd.x, secondStart.y - secondEnd.y);
+	return {
+		x: det(firstDet, firstStart.x - firstEnd.x, secondDet, secondStart.x - secondEnd.x) / divisor,
+		y: det(firstDet, firstStart.y - firstEnd.y, secondDet, secondStart.y - secondEnd.y) / divisor
+	};
+};
+const polygonPath = (points) => {
+	const [firstPoint, ...remainingPoints] = points;
+	if (!firstPoint) return "";
+	return [
+		`M ${formatCoordinate(firstPoint.x)} ${formatCoordinate(firstPoint.y)}`,
+		...remainingPoints.map((pointValue) => `L ${formatCoordinate(pointValue.x)} ${formatCoordinate(pointValue.y)}`),
+		"Z"
+	].join(" ");
+};
+const lineworkPath = (segments) => segments.map(({ start, end }) => `M ${formatCoordinate(start.x)} ${formatCoordinate(start.y)} L ${formatCoordinate(end.x)} ${formatCoordinate(end.y)}`).join(" ");
+const createStickerPolygons = (boundary) => {
+	const edgePoints = [];
+	for (let index = 0; index < 5; index += 1) {
+		const current = boundary[index];
+		const next = boundary[(index + 1) % 5];
+		edgePoints[index] = {
+			x: .4 * next.x + .6 * current.x,
+			y: .4 * next.y + .6 * current.y
+		};
+		edgePoints[index + 5] = {
+			x: .6 * next.x + .4 * current.x,
+			y: .6 * next.y + .4 * current.y
+		};
+	}
+	const innerPentagon = [];
+	for (let index = 0; index < 5; index += 1) innerPentagon[index] = lineIntersection(edgePoints[index], edgePoints[5 + (3 + index) % 5], edgePoints[(index + 1) % 5], edgePoints[5 + (4 + index) % 5]);
+	const stickers = [];
+	for (let index = 0; index < 5; index += 1) {
+		stickers[2 * index] = [
+			boundary[index],
+			edgePoints[index],
+			innerPentagon[index],
+			edgePoints[5 + (4 + index) % 5]
+		];
+		stickers[2 * index + 1] = [
+			edgePoints[index],
+			edgePoints[index + 5],
+			innerPentagon[(index + 1) % 5],
+			innerPentagon[index]
+		];
+	}
+	stickers[10] = innerPentagon;
+	return stickers;
+};
+const stickerIndexForOrientation = (stickerIndex, orientation) => {
+	if (stickerIndex >= 10) return stickerIndex;
+	const offset = 2 * orientation.rotation;
+	if (orientation.mirrored) return wrapStickerIndex(offset - stickerIndex);
+	return wrapStickerIndex(stickerIndex + offset);
+};
+const colorForSticker = (facelet, colors) => colors[MEGAMINX_FACES[facelet] ?? "U"];
+const createFaceStickers = (state, placement, colors) => {
+	const faceIndexValue = MEGAMINX_FACES.indexOf(placement.face);
+	const stickers = state.image[faceIndexValue];
+	const orientation = STICKER_ORIENTATIONS[placement.face];
+	return createStickerPolygons(placement.boundary).map((polygon, stickerIndex) => {
+		return {
+			points: polygon,
+			fill: colorForSticker(stickers[stickerIndexForOrientation(stickerIndex, orientation)], colors)
+		};
+	});
+};
+const segmentKey = ({ start, end }) => {
+	const startKey = `${formatCoordinate(start.x)},${formatCoordinate(start.y)}`;
+	const endKey = `${formatCoordinate(end.x)},${formatCoordinate(end.y)}`;
+	return startKey < endKey ? `${startKey}|${endKey}` : `${endKey}|${startKey}`;
+};
+const createLineworkSegments = (stickers) => {
+	const segments = /* @__PURE__ */ new Map();
+	for (const sticker of stickers) for (let index = 0; index < sticker.points.length; index += 1) {
+		const segment = {
+			start: sticker.points[index],
+			end: sticker.points[(index + 1) % sticker.points.length]
+		};
+		segments.set(segmentKey(segment), segment);
+	}
+	return [...segments.values()];
+};
+const drawStickers = (stickers) => stickers.map((sticker) => path({
+	d: polygonPath(sticker.points),
+	fill: sticker.fill,
+	stroke: "none"
+}));
+const drawLinework = (stickers) => path({
+	d: lineworkPath(createLineworkSegments(stickers)),
+	fill: "none",
+	stroke: STROKE,
+	"stroke-linecap": "round",
+	"stroke-linejoin": "round",
+	"stroke-width": STROKE_WIDTH
+});
+const drawFaces = (state, colors) => {
+	const stickers = FACE_PLACEMENTS.flatMap((placement) => createFaceStickers(state, placement, colors));
+	return [...drawStickers(stickers), drawLinework(stickers)];
+};
+const renderMegaminxIsometricState = (state, colorScheme = {}) => {
+	return createSvgDocument(WIDTH, HEIGHT, drawFaces(state, {
+		...DEFAULT_MEGAMINX_COLORS,
+		...colorScheme
+	}));
+};
+//#endregion
+export { renderMegaminxIsometricState };

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

@@ -0,0 +1,9 @@
+import { MegaminxFace } from "../../../scramble-puzzle/src/megaminx/megaminx-parser.mjs";
+import { MegaminxState } from "../../../scramble-puzzle/src/megaminx/megaminx-state.mjs";
+import { HexColor } from "../color.mjs";
+
+//#region .build/vendor/scramble-image/src/renderers/megaminx.d.ts
+type MegaminxColorScheme = Partial<Record<MegaminxFace, HexColor>>;
+declare const renderMegaminxState: (state: MegaminxState, colorScheme?: MegaminxColorScheme) => string;
+//#endregion
+export { MegaminxColorScheme, renderMegaminxState };