cubegin 0.0.1

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

@@ -0,0 +1,233 @@
+import { createSvgDocument } from "../svg/svg-document.mjs";
+import { path } from "../svg/svg-elements.mjs";
+//#region .build/vendor/scramble-image/src/renderers/skewb-isometric.ts
+const WIDTH = 404;
+const HEIGHT = 168;
+const STROKE = "#000000";
+const STROKE_WIDTH = 2.5;
+const STATE_FACE_ORDER = [
+	"U",
+	"R",
+	"F",
+	"D",
+	"L",
+	"B"
+];
+const DEFAULT_SKEWB_COLORS = {
+	U: "#ffffff",
+	R: "#0000ff",
+	F: "#ff0000",
+	D: "#ffff00",
+	L: "#00ff00",
+	B: "#ff8000"
+};
+const FACE_STICKERS = [
+	[
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 0
+		},
+		{
+			x: 0,
+			y: -1
+		}
+	],
+	[
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: -1,
+			y: -1
+		},
+		{
+			x: 0,
+			y: -1
+		}
+	],
+	[
+		{
+			x: 0,
+			y: -1
+		},
+		{
+			x: 1,
+			y: -1
+		},
+		{
+			x: 1,
+			y: 0
+		}
+	],
+	[
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: -1,
+			y: 1
+		},
+		{
+			x: 0,
+			y: 1
+		}
+	],
+	[
+		{
+			x: 0,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 0
+		}
+	]
+];
+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: 90,
+	topY: 6,
+	topEdgeY: 39,
+	centerY: 82,
+	bottomEdgeY: 120,
+	bottomY: 162,
+	topHalfWidth: 72,
+	bottomHalfWidth: 66
+});
+const backView = createCornerViewPoints({
+	centerX: 314,
+	topY: 6,
+	topEdgeY: 39,
+	centerY: 88,
+	bottomEdgeY: 120,
+	bottomY: 156,
+	topHalfWidth: 68,
+	bottomHalfWidth: 72
+});
+const FACE_SPECS = [
+	{
+		face: "U",
+		transform: transformFromCorners(frontView.leftTop, frontView.top, frontView.rightTop, frontView.center)
+	},
+	{
+		face: "L",
+		transform: transformFromCorners(frontView.leftTop, frontView.center, frontView.bottom, frontView.leftBottom)
+	},
+	{
+		face: "F",
+		transform: transformFromCorners(frontView.rightTop, frontView.rightBottom, frontView.bottom, frontView.center)
+	},
+	{
+		face: "R",
+		transform: transformFromCorners(backView.leftTop, backView.top, backView.center, backView.leftBottom)
+	},
+	{
+		face: "B",
+		transform: transformFromCorners(backView.top, backView.rightTop, backView.rightBottom, backView.center)
+	},
+	{
+		face: "D",
+		transform: transformFromCorners(backView.center, backView.rightBottom, backView.bottom, backView.leftBottom)
+	}
+];
+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) => {
+	const horizontalRatio = (pointValue.x + 1) / 2;
+	const verticalRatio = (pointValue.y + 1) / 2;
+	return interpolatePoint(interpolatePoint(transform.topLeft, transform.topRight, horizontalRatio), interpolatePoint(transform.bottomLeft, transform.bottomRight, horizontalRatio), verticalRatio);
+};
+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 colorForSticker = (facelet, colors) => colors[STATE_FACE_ORDER[facelet] ?? "U"];
+const createFaceStickers = (state, faceSpec, colors) => {
+	const { face, transform } = faceSpec;
+	const faceIndex = STATE_FACE_ORDER.indexOf(face);
+	const stickers = state.image[faceIndex];
+	return FACE_STICKERS.map((polygon, stickerIndex) => ({
+		points: polygon.map((pointValue) => transformPoint(pointValue, transform)),
+		fill: colorForSticker(stickers[stickerIndex], 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 renderSkewbIsometricState = (state, colorScheme = {}) => {
+	const colors = {
+		...DEFAULT_SKEWB_COLORS,
+		...colorScheme
+	};
+	const stickers = FACE_SPECS.flatMap((faceSpec) => createFaceStickers(state, faceSpec, colors));
+	return createSvgDocument(WIDTH, HEIGHT, [...drawStickers(stickers), drawLinework(stickers)]);
+};
+//#endregion
+export { renderSkewbIsometricState };

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

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

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

@@ -0,0 +1,187 @@
+import { createSvgDocument } from "../svg/svg-document.mjs";
+import { path } from "../svg/svg-elements.mjs";
+//#region .build/vendor/scramble-image/src/renderers/skewb.ts
+const PIECE_SIZE = 30;
+const GAP = 3;
+const SQRT_THREE_OVER_TWO = Math.sqrt(3) / 2;
+const WIDTH = Math.ceil((3 * GAP + 8 * PIECE_SIZE + 1) * SQRT_THREE_OVER_TWO);
+const HEIGHT = Math.ceil(2 * GAP + 6 * PIECE_SIZE + 1);
+const STROKE = "#000000";
+const STROKE_WIDTH = 1.25;
+const SKEWB_RENDER_FACES = [
+	"U",
+	"R",
+	"F",
+	"D",
+	"L",
+	"B"
+];
+const DEFAULT_SKEWB_COLORS = {
+	U: "#ffffff",
+	R: "#0000ff",
+	F: "#ff0000",
+	D: "#ffff00",
+	L: "#00ff00",
+	B: "#ff8000"
+};
+const FACE_TRANSFORMS = [
+	{
+		a: PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		b: -PIECE_SIZE / 2,
+		c: PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		d: PIECE_SIZE / 2,
+		e: (PIECE_SIZE * 4 + GAP * 1.5) * SQRT_THREE_OVER_TWO,
+		f: PIECE_SIZE
+	},
+	{
+		a: PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		b: -PIECE_SIZE / 2,
+		c: 0,
+		d: PIECE_SIZE,
+		e: (PIECE_SIZE * 7 + GAP * 3) * SQRT_THREE_OVER_TWO,
+		f: PIECE_SIZE * 1.5
+	},
+	{
+		a: PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		b: -PIECE_SIZE / 2,
+		c: 0,
+		d: PIECE_SIZE,
+		e: (PIECE_SIZE * 5 + GAP * 2) * SQRT_THREE_OVER_TWO,
+		f: PIECE_SIZE * 2.5 + .5 * GAP
+	},
+	{
+		a: 0,
+		b: PIECE_SIZE,
+		c: -PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		d: -PIECE_SIZE / 2,
+		e: (PIECE_SIZE * 3 + GAP) * SQRT_THREE_OVER_TWO,
+		f: PIECE_SIZE * 4.5 + 1.5 * GAP
+	},
+	{
+		a: PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		b: PIECE_SIZE / 2,
+		c: 0,
+		d: PIECE_SIZE,
+		e: (PIECE_SIZE * 3 + GAP) * SQRT_THREE_OVER_TWO,
+		f: PIECE_SIZE * 2.5 + .5 * GAP
+	},
+	{
+		a: PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		b: PIECE_SIZE / 2,
+		c: 0,
+		d: PIECE_SIZE,
+		e: PIECE_SIZE * SQRT_THREE_OVER_TWO,
+		f: PIECE_SIZE * 1.5
+	}
+];
+const FACE_STICKERS = [
+	[
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: 0,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 0
+		},
+		{
+			x: 0,
+			y: -1
+		}
+	],
+	[
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: -1,
+			y: -1
+		},
+		{
+			x: 0,
+			y: -1
+		}
+	],
+	[
+		{
+			x: 0,
+			y: -1
+		},
+		{
+			x: 1,
+			y: -1
+		},
+		{
+			x: 1,
+			y: 0
+		}
+	],
+	[
+		{
+			x: -1,
+			y: 0
+		},
+		{
+			x: -1,
+			y: 1
+		},
+		{
+			x: 0,
+			y: 1
+		}
+	],
+	[
+		{
+			x: 0,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 1
+		},
+		{
+			x: 1,
+			y: 0
+		}
+	]
+];
+const transformPoint = (pointValue, transform) => ({
+	x: transform.a * pointValue.x + transform.c * pointValue.y + transform.e,
+	y: transform.b * pointValue.x + transform.d * pointValue.y + transform.f
+});
+const polygonPath = (points) => {
+	const [firstPoint, ...remainingPoints] = points;
+	if (firstPoint === void 0) return "";
+	return [
+		`M ${firstPoint.x} ${firstPoint.y}`,
+		...remainingPoints.map((pointValue) => `L ${pointValue.x} ${pointValue.y}`),
+		"Z"
+	].join(" ");
+};
+const colorForSticker = (facelet, colors) => colors[SKEWB_RENDER_FACES[facelet] ?? "U"];
+const drawFace = (state, face, colors) => {
+	const faceIndex = SKEWB_RENDER_FACES.indexOf(face);
+	const stickers = state.image[faceIndex];
+	const transform = FACE_TRANSFORMS[faceIndex];
+	return FACE_STICKERS.map((polygon, stickerIndex) => path({
+		d: polygonPath(polygon.map((pointValue) => transformPoint(pointValue, transform))),
+		fill: colorForSticker(stickers[stickerIndex], colors),
+		stroke: STROKE,
+		"stroke-width": STROKE_WIDTH,
+		"stroke-linejoin": "round"
+	}));
+};
+const renderSkewbState = (state, colorScheme = {}) => {
+	const colors = {
+		...DEFAULT_SKEWB_COLORS,
+		...colorScheme
+	};
+	return createSvgDocument(WIDTH, HEIGHT, SKEWB_RENDER_FACES.flatMap((face) => drawFace(state, face, colors)));
+};
+//#endregion
+export { renderSkewbState };

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

@@ -0,0 +1,10 @@
+import { SquareOneState } from "../../../scramble-puzzle/src/square1/square1-state.mjs";
+import { HexColor } from "../color.mjs";
+
+//#region .build/vendor/scramble-image/src/renderers/square1.d.ts
+declare const SQUARE_ONE_FACES: readonly ["L", "B", "R", "F", "U", "D"];
+type SquareOneFace = (typeof SQUARE_ONE_FACES)[number];
+type SquareOneColorScheme = Partial<Record<SquareOneFace, HexColor>>;
+declare const renderSquareOneState: (state: SquareOneState, colorScheme?: SquareOneColorScheme) => string;
+//#endregion
+export { SquareOneColorScheme, SquareOneFace, renderSquareOneState };

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

@@ -0,0 +1,253 @@
+import { createSvgDocument } from "../svg/svg-document.mjs";
+import { path, rect } from "../svg/svg-elements.mjs";
+//#region .build/vendor/scramble-image/src/renderers/square1.ts
+const RADIUS = 32;
+const RADIUS_MULTIPLIER = Math.sqrt(2) * Math.cos(15 * Math.PI / 180);
+const MULTIPLIER = 1.4;
+const WIDTH = Math.trunc(2 * RADIUS_MULTIPLIER * MULTIPLIER * RADIUS);
+const HEIGHT = Math.trunc(4 * RADIUS_MULTIPLIER * MULTIPLIER * RADIUS);
+const STROKE_ATTRS = {
+	stroke: "#000000",
+	"stroke-width": "2px",
+	"stroke-miterlimit": 10,
+	"stroke-linejoin": "round"
+};
+const SQUARE_ONE_FACES = [
+	"L",
+	"B",
+	"R",
+	"F",
+	"U",
+	"D"
+];
+const DEFAULT_SQUARE_ONE_COLORS = {
+	L: "#0000ff",
+	B: "#ff8000",
+	R: "#00ff00",
+	F: "#ff0000",
+	U: "#ffff00",
+	D: "#ffffff"
+};
+const degreesToRadians = (degrees) => degrees * Math.PI / 180;
+const polygonPath = (points) => {
+	const [firstPoint, ...remainingPoints] = points;
+	if (firstPoint === void 0) return "";
+	return [
+		`M ${firstPoint.x} ${firstPoint.y}`,
+		...remainingPoints.map((pointValue) => `L ${pointValue.x} ${pointValue.y}`),
+		"Z"
+	].join(" ");
+};
+const translatePolygon = (points, translateX, translateY) => points.map((pointValue) => ({
+	x: pointValue.x + translateX,
+	y: pointValue.y + translateY
+}));
+const wedgePolygons = (centerX, centerY, radius) => {
+	const tipX = Math.sqrt(3) * radius / 2;
+	const tipY = radius / 2;
+	return [translatePolygon([
+		{
+			x: 0,
+			y: 0
+		},
+		{
+			x: radius,
+			y: 0
+		},
+		{
+			x: tipX,
+			y: tipY
+		}
+	], centerX, centerY), translatePolygon([
+		{
+			x: radius,
+			y: 0
+		},
+		{
+			x: MULTIPLIER * radius,
+			y: 0
+		},
+		{
+			x: MULTIPLIER * tipX,
+			y: MULTIPLIER * tipY
+		},
+		{
+			x: tipX,
+			y: tipY
+		}
+	], centerX, centerY)];
+};
+const cornerPolygons = (centerX, centerY, radius) => {
+	const outerX = radius * (1 + Math.cos(degreesToRadians(75)) / Math.sqrt(2));
+	const outerY = radius * Math.sin(degreesToRadians(75)) / Math.sqrt(2);
+	const innerX = radius / 2;
+	const innerY = Math.sqrt(3) * radius / 2;
+	return [
+		translatePolygon([
+			{
+				x: 0,
+				y: 0
+			},
+			{
+				x: radius,
+				y: 0
+			},
+			{
+				x: outerX,
+				y: outerY
+			},
+			{
+				x: innerX,
+				y: innerY
+			}
+		], centerX, centerY),
+		translatePolygon([
+			{
+				x: radius,
+				y: 0
+			},
+			{
+				x: MULTIPLIER * radius,
+				y: 0
+			},
+			{
+				x: MULTIPLIER * outerX,
+				y: MULTIPLIER * outerY
+			},
+			{
+				x: outerX,
+				y: outerY
+			}
+		], centerX, centerY),
+		translatePolygon([
+			{
+				x: MULTIPLIER * outerX,
+				y: MULTIPLIER * outerY
+			},
+			{
+				x: outerX,
+				y: outerY
+			},
+			{
+				x: innerX,
+				y: innerY
+			},
+			{
+				x: MULTIPLIER * innerX,
+				y: MULTIPLIER * innerY
+			}
+		], centerX, centerY)
+	];
+};
+const isCornerPiece = (piece) => (piece + (piece <= 7 ? 0 : 1)) % 2 === 0;
+const getSideColor = (sideIndex, colors) => colors[SQUARE_ONE_FACES[sideIndex] ?? "L"];
+const getPieceColors = (pieceValue, colors) => {
+	const isTopPiece = pieceValue <= 7;
+	const topColor = isTopPiece ? colors.U : colors.D;
+	let piece = pieceValue;
+	if (isCornerPiece(piece)) {
+		if (!isTopPiece) piece = 15 - piece;
+		let firstSideColor = getSideColor((Math.trunc(piece / 2) + 3) % 4, colors);
+		let secondSideColor = getSideColor(Math.trunc(piece / 2), colors);
+		if (!isTopPiece) {
+			const previousFirstSideColor = firstSideColor;
+			firstSideColor = secondSideColor;
+			secondSideColor = previousFirstSideColor;
+		}
+		return [
+			topColor,
+			firstSideColor,
+			secondSideColor
+		];
+	}
+	if (!isTopPiece) piece = 14 - piece;
+	return [topColor, getSideColor(Math.trunc(piece / 2), colors)];
+};
+const drawPiece = (piece, centerX, centerY, radius, angleDegrees, colors) => {
+	const corner = isCornerPiece(piece);
+	const pieceColors = getPieceColors(piece, colors);
+	const polygons = corner ? cornerPolygons(centerX, centerY, radius) : wedgePolygons(centerX, centerY, radius);
+	const nodes = [];
+	for (let colorIndex = pieceColors.length - 1; colorIndex >= 0; colorIndex -= 1) nodes.push(path({
+		d: polygonPath(polygons[colorIndex]),
+		fill: pieceColors[colorIndex],
+		transform: `rotate(${angleDegrees} ${centerX} ${centerY})`,
+		...STROKE_ATTRS
+	}));
+	return {
+		nodes,
+		degrees: 30 * (corner ? 2 : 1)
+	};
+};
+const drawFace = (pieces, centerX, centerY, initialAngleDegrees, colors) => {
+	const nodes = [];
+	const hasWrappedCorner = pieces[0] !== void 0 && pieces[11] === pieces[0] && isCornerPiece(pieces[0]);
+	let angleDegrees = initialAngleDegrees + (hasWrappedCorner ? 30 : 0);
+	const firstPieceIndex = hasWrappedCorner ? 1 : 0;
+	for (let pieceIndex = firstPieceIndex; pieceIndex < 12; pieceIndex += 1) {
+		if (pieceIndex < 11 && pieces[pieceIndex] === pieces[pieceIndex + 1]) pieceIndex += 1;
+		const piece = pieces[pieceIndex];
+		if (piece === void 0) continue;
+		const drawnPiece = drawPiece(piece, centerX, centerY, RADIUS, angleDegrees, colors);
+		nodes.push(...drawnPiece.nodes);
+		angleDegrees += drawnPiece.degrees;
+	}
+	return nodes;
+};
+const drawMiddleSlice = (sliceSolved, colors) => {
+	const halfSquareWidth = RADIUS * RADIUS_MULTIPLIER * MULTIPLIER / Math.sqrt(2);
+	const edgeWidth = 2 * RADIUS * MULTIPLIER * Math.sin(degreesToRadians(15));
+	const cornerWidth = halfSquareWidth - edgeWidth / 2;
+	const sliceX = WIDTH / 2 - halfSquareWidth;
+	const sliceY = HEIGHT / 2 - RADIUS * (MULTIPLIER - 1) / 2;
+	const sliceHeight = RADIUS * (MULTIPLIER - 1);
+	const rightSliceWidth = sliceSolved ? 2 * cornerWidth + edgeWidth : cornerWidth + edgeWidth;
+	return [
+		rect({
+			x: sliceX,
+			y: sliceY,
+			width: rightSliceWidth,
+			height: sliceHeight,
+			fill: sliceSolved ? colors.F : colors.B
+		}),
+		rect({
+			x: sliceX,
+			y: sliceY,
+			width: cornerWidth,
+			height: sliceHeight,
+			fill: colors.F
+		}),
+		rect({
+			x: sliceX,
+			y: sliceY,
+			width: rightSliceWidth,
+			height: sliceHeight,
+			fill: "none",
+			...STROKE_ATTRS
+		}),
+		rect({
+			x: sliceX,
+			y: sliceY,
+			width: cornerWidth,
+			height: sliceHeight,
+			fill: "none",
+			...STROKE_ATTRS
+		})
+	];
+};
+const renderSquareOneState = (state, colorScheme = {}) => {
+	const colors = {
+		...DEFAULT_SQUARE_ONE_COLORS,
+		...colorScheme
+	};
+	const centerX = WIDTH / 2;
+	const topCenterY = HEIGHT / 4;
+	const bottomCenterY = HEIGHT / 4 * 3;
+	return createSvgDocument(WIDTH, HEIGHT, [
+		...drawMiddleSlice(state.sliceSolved, colors),
+		...drawFace(state.pieces, centerX, topCenterY, 105, colors),
+		...drawFace(state.pieces.slice(12), centerX, bottomCenterY, -105, colors)
+	]);
+};
+//#endregion
+export { renderSquareOneState };

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

@@ -0,0 +1,6 @@
+import { SvgNode } from "./svg-elements.mjs";
+
+//#region .build/vendor/scramble-image/src/svg/svg-document.d.ts
+declare const createSvgDocument: (width: number, height: number, children: readonly SvgNode[]) => string;
+//#endregion
+export { createSvgDocument };

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

@@ -0,0 +1,7 @@
+import { serializeSvgNode } from "./svg-serialize.mjs";
+//#region .build/vendor/scramble-image/src/svg/svg-document.ts
+const createSvgDocument = (width, height, children) => {
+	return `<svg width="${width}" height="${height}" viewBox="0 0 ${width} ${height}" version="1.1" xmlns="http://www.w3.org/2000/svg">${children.map(serializeSvgNode).join("")}</svg>`;
+};
+//#endregion
+export { createSvgDocument };