card-gate-frame 1.0.0

package/dist/core-DzM1ds_q.js

@@ -0,0 +1,2536 @@
+//#region src/core/geometry-utils.ts
+const COORDINATE_SCALE$1 = 1e4;
+const canonicalNumber = (value) => {
+	const rounded = Math.round(value * COORDINATE_SCALE$1) / COORDINATE_SCALE$1;
+	return Object.is(rounded, -0) ? 0 : rounded;
+};
+const canonicalizeCommand = (command) => {
+	switch (command.kind) {
+		case "M":
+		case "L": return {
+			kind: command.kind,
+			x: canonicalNumber(command.x),
+			y: canonicalNumber(command.y)
+		};
+		case "C": return {
+			kind: "C",
+			x1: canonicalNumber(command.x1),
+			y1: canonicalNumber(command.y1),
+			x2: canonicalNumber(command.x2),
+			y2: canonicalNumber(command.y2),
+			x: canonicalNumber(command.x),
+			y: canonicalNumber(command.y)
+		};
+		case "Q": return {
+			kind: "Q",
+			x1: canonicalNumber(command.x1),
+			y1: canonicalNumber(command.y1),
+			x: canonicalNumber(command.x),
+			y: canonicalNumber(command.y)
+		};
+		case "Z": return { kind: "Z" };
+	}
+};
+const canonicalizePath = (path) => path.map(canonicalizeCommand);
+const mirrorCommand = (command, width) => {
+	switch (command.kind) {
+		case "M":
+		case "L": return {
+			kind: command.kind,
+			x: canonicalNumber(width - command.x),
+			y: command.y
+		};
+		case "C": return {
+			kind: "C",
+			x1: canonicalNumber(width - command.x1),
+			y1: command.y1,
+			x2: canonicalNumber(width - command.x2),
+			y2: command.y2,
+			x: canonicalNumber(width - command.x),
+			y: command.y
+		};
+		case "Q": return {
+			kind: "Q",
+			x1: canonicalNumber(width - command.x1),
+			y1: command.y1,
+			x: canonicalNumber(width - command.x),
+			y: command.y
+		};
+		case "Z": return { kind: "Z" };
+	}
+};
+const mirrorPath = (path, width) => path.map((command) => mirrorCommand(command, width));
+const deepFreeze = (value) => {
+	if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
+		for (const nested of Object.values(value)) deepFreeze(nested);
+		Object.freeze(value);
+	}
+	return value;
+};
+
+//#endregion
+//#region src/core/utf8.ts
+const Encoder = globalThis.TextEncoder;
+const encoder = new Encoder();
+const encodeUtf8 = (value) => encoder.encode(value);
+
+//#endregion
+//#region src/core/courtyard.ts
+const DEFAULT_INSET = 8;
+const DEFAULT_STROKE_WIDTH = 2;
+const DEFAULT_DENSITY = .55;
+const DEFAULT_CURVATURE = .65;
+const normalizeDimensions$1 = (dimensions) => {
+	const { width, height } = dimensions;
+	if (!Number.isFinite(width) || !Number.isFinite(height)) throw new TypeError("Gate dimensions must be finite numbers");
+	if (width < 160 || width > 1600 || height < 96 || height > 1200) throw new RangeError("Gate dimensions are outside the supported range");
+	const aspectRatio = width / height;
+	if (aspectRatio < .5 || aspectRatio > 6) throw new RangeError("Gate dimensions have an unsupported aspect ratio");
+	return {
+		width: canonicalNumber(width),
+		height: canonicalNumber(height)
+	};
+};
+const normalizeSeed$1 = (seed) => {
+	if (typeof seed === "number") {
+		if (!Number.isFinite(seed)) throw new TypeError("Gate seed numbers must be finite");
+		return Object.is(seed, -0) ? 0 : seed;
+	}
+	if (typeof seed !== "string") throw new TypeError("Gate seeds must be strings or finite numbers");
+	if (seed.length === 0) throw new TypeError("Gate seed strings must not be empty");
+	return seed;
+};
+const validateGenerationOptions = (options) => {
+	if (options.family !== "courtyard") throw new TypeError("GF-01 requires family: \"courtyard\"");
+	if (options.generationVersion !== void 0 && options.generationVersion !== 1) throw new TypeError("GF-01 supports only generationVersion 1");
+};
+const normalizeShapeControl = (value, fallback, name) => {
+	const normalized = value === void 0 ? fallback : value;
+	if (!Number.isFinite(normalized)) throw new TypeError(`${name} must be a finite number`);
+	if (normalized < 0 || normalized > 1) throw new RangeError(`${name} must be between 0 and 1 inclusive`);
+	return canonicalNumber(normalized);
+};
+const hashByte = (hash, byte) => Math.imul(hash ^ byte, 16777619) >>> 0;
+const hashUtf8 = (value) => {
+	let hash = 2166136261;
+	for (const byte of encodeUtf8(value)) hash = hashByte(hash, byte);
+	return hash;
+};
+const seedState = (seed) => hashUtf8(`${typeof seed === "number" ? "number" : "string"}:${String(seed)}`);
+const nextUint32 = (state) => {
+	let next = state || 1831565813;
+	next ^= next << 13;
+	next ^= next >>> 17;
+	next ^= next << 5;
+	return next >>> 0;
+};
+function generateGate$1(dimensions, options) {
+	validateGenerationOptions(options);
+	const { width, height } = normalizeDimensions$1(dimensions);
+	const seed = normalizeSeed$1(options.seed);
+	const density = normalizeShapeControl(options.density, DEFAULT_DENSITY, "density");
+	const curvature = normalizeShapeControl(options.curvature, DEFAULT_CURVATURE, "curvature");
+	const edge = canonicalNumber(9);
+	const railY = canonicalNumber(Math.max(edge + 24, height * .275));
+	const bottomY = canonicalNumber(height - edge);
+	const frameBand = canonicalNumber(Math.max(12, Math.min(24, Math.min(width, height) * .06)));
+	const safeLeft = canonicalNumber(edge + frameBand);
+	const safeRight = canonicalNumber(width - safeLeft);
+	const safeTop = canonicalNumber(railY + frameBand);
+	const safeBottom = canonicalNumber(bottomY - frameBand);
+	const centerX = canonicalNumber(width / 2);
+	const surfacePath = [
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: bottomY
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: bottomY
+		},
+		{ kind: "Z" },
+		{
+			kind: "M",
+			x: safeLeft,
+			y: safeTop
+		},
+		{
+			kind: "L",
+			x: safeLeft,
+			y: safeBottom
+		},
+		{
+			kind: "L",
+			x: safeRight,
+			y: safeBottom
+		},
+		{
+			kind: "L",
+			x: safeRight,
+			y: safeTop
+		},
+		{ kind: "Z" }
+	];
+	const structuralPath = [
+		{
+			kind: "M",
+			x: edge,
+			y: bottomY
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: bottomY
+		},
+		{ kind: "Z" }
+	];
+	const seedVariation = nextUint32(seedState(seed)) / 4294967295;
+	const availableScrollLift = canonicalNumber(railY - edge - 4);
+	const scrollLift = canonicalNumber(Math.min(availableScrollLift, 27 + seedVariation * 6));
+	const scrollStart = safeLeft;
+	const availableScrollReach = canonicalNumber(centerX - 24 - scrollStart);
+	const baseScrollReach = Math.min(width * .22, 66 + seedVariation * 8, availableScrollReach);
+	const scrollReach = canonicalNumber(baseScrollReach * (.86 + density * .14));
+	const scrollEnd = canonicalNumber(scrollStart + scrollReach);
+	const curvatureScale = .8 + curvature * .3;
+	const leftScroll = [
+		{
+			kind: "M",
+			x: scrollStart,
+			y: railY
+		},
+		{
+			kind: "C",
+			x1: scrollStart + 5 * curvatureScale,
+			y1: railY - 20 * curvatureScale,
+			x2: scrollEnd - 18 * curvatureScale,
+			y2: railY - scrollLift,
+			x: scrollEnd,
+			y: railY - scrollLift
+		},
+		{
+			kind: "C",
+			x1: scrollEnd + 18 * curvatureScale,
+			y1: railY - scrollLift,
+			x2: scrollEnd + 22 * curvatureScale,
+			y2: railY - 9 * curvatureScale,
+			x: scrollEnd + 10,
+			y: railY - 6
+		},
+		{
+			kind: "C",
+			x1: scrollEnd,
+			y1: railY - 3,
+			x2: scrollEnd - 8 * curvatureScale,
+			y2: railY - 10 * curvatureScale,
+			x: scrollEnd - 3,
+			y: railY - 16
+		}
+	];
+	const spear = [
+		{
+			kind: "M",
+			x: centerX,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: centerX,
+			y: edge + 18
+		},
+		{
+			kind: "M",
+			x: centerX,
+			y: edge
+		},
+		{
+			kind: "L",
+			x: centerX + 7,
+			y: edge + 12
+		},
+		{
+			kind: "L",
+			x: centerX,
+			y: edge + 19
+		},
+		{
+			kind: "L",
+			x: centerX - 7,
+			y: edge + 12
+		},
+		{ kind: "Z" }
+	];
+	const geometry = {
+		schemaVersion: 1,
+		generationVersion: 1,
+		seed,
+		dimensions: {
+			width,
+			height
+		},
+		viewBox: {
+			minX: 0,
+			minY: 0,
+			width,
+			height
+		},
+		options: {
+			generationVersion: 1,
+			family: "courtyard",
+			density,
+			curvature,
+			symmetry: 1,
+			crest: "spear",
+			inset: DEFAULT_INSET,
+			strokeWidth: DEFAULT_STROKE_WIDTH
+		},
+		bounds: {
+			left: edge,
+			right: canonicalNumber(width - edge),
+			railY,
+			bottomY
+		},
+		contentInsets: {
+			top: safeTop,
+			right: canonicalNumber(width - safeRight),
+			bottom: canonicalNumber(height - safeBottom),
+			left: safeLeft
+		},
+		surfacePath: canonicalizePath(surfacePath),
+		structuralPaths: [canonicalizePath(structuralPath)],
+		decorativePaths: [
+			canonicalizePath(leftScroll),
+			mirrorPath(canonicalizePath(leftScroll), width),
+			canonicalizePath(spear)
+		]
+	};
+	return deepFreeze(geometry);
+}
+
+//#endregion
+//#region src/core/labelled-sampler.ts
+function createLabelledSampler(version) {
+	const UINT32_RANGE = 4294967296;
+	const SAMPLE_DOMAIN = `gate-frame/v${version}/sample\0`;
+	const LABEL_PATTERN = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*(?:\/[a-z][a-z0-9]*(?:-[a-z0-9]+)*)*$/;
+	const pushUint32Le = (bytes, value) => {
+		bytes.push(value & 255, value >>> 8 & 255, value >>> 16 & 255, value >>> 24);
+	};
+	function sampleKeyBytes(seed, label, index) {
+		if (typeof seed === "number" && !Number.isFinite(seed)) throw new TypeError("Sample seed numbers must be finite");
+		if (typeof seed !== "string" && typeof seed !== "number") throw new TypeError("Sample seeds must be strings or finite numbers");
+		if (!LABEL_PATTERN.test(label)) throw new TypeError(`Sample labels must use the generation-v${version} labelled domain`);
+		if (index !== void 0 && (!Number.isInteger(index) || index < 0 || index > 4294967295)) throw new RangeError("Sample indices must be unsigned 32-bit integers");
+		const normalizedSeed = typeof seed === "number" && Object.is(seed, -0) ? 0 : seed;
+		const seedBytes = encodeUtf8(String(normalizedSeed));
+		const labelBytes = encodeUtf8(label);
+		const bytes = Array.from(encodeUtf8(SAMPLE_DOMAIN));
+		bytes.push(typeof normalizedSeed === "number" ? 110 : 115);
+		pushUint32Le(bytes, seedBytes.length);
+		bytes.push(...seedBytes);
+		pushUint32Le(bytes, labelBytes.length);
+		bytes.push(...labelBytes);
+		bytes.push(index === void 0 ? 0 : 1);
+		if (index !== void 0) pushUint32Le(bytes, index);
+		return Uint8Array.from(bytes);
+	}
+	function sampleUint32(seed, label, index) {
+		let hash = 2166136261;
+		for (const byte of sampleKeyBytes(seed, label, index)) hash = Math.imul(hash ^ byte, 16777619) >>> 0;
+		hash ^= hash >>> 16;
+		hash = Math.imul(hash, 2246822507) >>> 0;
+		hash ^= hash >>> 13;
+		hash = Math.imul(hash, 3266489909) >>> 0;
+		hash ^= hash >>> 16;
+		return hash >>> 0;
+	}
+	function sampleScalar(seed, label, index) {
+		return sampleUint32(seed, label, index) / UINT32_RANGE;
+	}
+	function sampleIndex(seed, label, count, index) {
+		if (!Number.isInteger(count) || count < 1 || count > 65536) throw new RangeError("Sample counts must be integers from 1 through 65536");
+		return Math.floor(sampleUint32(seed, label, index) * count / UINT32_RANGE);
+	}
+	return {
+		sampleKeyBytes,
+		sampleUint32,
+		sampleScalar,
+		sampleIndex
+	};
+}
+
+//#endregion
+//#region src/core/v2/sampler.ts
+const sampler$1 = createLabelledSampler(2);
+const sampleKeyBytes$1 = sampler$1.sampleKeyBytes;
+const sampleUint32$1 = sampler$1.sampleUint32;
+const sampleScalar$1 = sampler$1.sampleScalar;
+const sampleIndex$1 = sampler$1.sampleIndex;
+
+//#endregion
+//#region src/core/v3/sampler.ts
+const sampler = createLabelledSampler(3);
+const sampleKeyBytes = sampler.sampleKeyBytes;
+const sampleUint32 = sampler.sampleUint32;
+const sampleScalar = sampler.sampleScalar;
+const sampleIndex = sampler.sampleIndex;
+
+//#endregion
+//#region src/core/family-options.ts
+const INSET = 8;
+const STROKE_WIDTH = 2;
+const FAMILY_ORDER = [
+	"courtyard",
+	"fleuron",
+	"arcade",
+	"vine",
+	"fan",
+	"volute"
+];
+const SPEAR_DIAMOND_CRESTS = [
+	"spear",
+	"diamond",
+	"none"
+];
+const FLEUR_SPEAR_CRESTS = [
+	"fleur",
+	"spear",
+	"none"
+];
+const DIAMOND_SPEAR_CRESTS = [
+	"diamond",
+	"spear",
+	"none"
+];
+const FLEUR_DIAMOND_CRESTS = [
+	"fleur",
+	"diamond",
+	"none"
+];
+const isGateFamily = (value) => typeof value === "string" && FAMILY_ORDER.includes(value);
+const compatibleCrestsForFamily = (family) => family === "courtyard" ? SPEAR_DIAMOND_CRESTS : family === "vine" ? FLEUR_DIAMOND_CRESTS : family === "arcade" || family === "fan" ? DIAMOND_SPEAR_CRESTS : FLEUR_SPEAR_CRESTS;
+const isCompatibleCrest = (family, crest) => isGateFamily(family) && compatibleCrestsForFamily(family).includes(crest);
+const FAMILY_OPTION_KEYS = /* @__PURE__ */ new Set([
+	"seed",
+	"generationVersion",
+	"family",
+	"density",
+	"curvature",
+	"symmetry",
+	"peakHeight",
+	"sideComplexity",
+	"crest"
+]);
+const requirePlainObject$1 = (value, version) => {
+	if (value === null || typeof value !== "object" || Array.isArray(value)) throw new TypeError(`generation-v${version} options must be a plain object`);
+	return value;
+};
+const ownValue = (input, key) => Object.hasOwn(input, key) ? input[key] : void 0;
+const normalizeDimensions = (dimensions) => {
+	if (dimensions === null || typeof dimensions !== "object") throw new TypeError("Gate dimensions must be a plain object");
+	const { width, height } = dimensions;
+	if (!Number.isFinite(width) || !Number.isFinite(height)) throw new TypeError("Gate dimensions must be finite numbers");
+	if (width < 160 || width > 1600 || height < 96 || height > 1200) throw new RangeError("Gate dimensions are outside the supported range");
+	const aspectRatio = width / height;
+	if (aspectRatio < .5 || aspectRatio > 6) throw new RangeError("Gate dimensions have an unsupported aspect ratio");
+	return {
+		width: canonicalNumber(width),
+		height: canonicalNumber(height)
+	};
+};
+const normalizeSeed = (value) => {
+	if (typeof value === "number") {
+		if (!Number.isFinite(value)) throw new TypeError("Gate seed numbers must be finite");
+		return Object.is(value, -0) ? 0 : value;
+	}
+	if (typeof value !== "string" || value.length === 0) throw new TypeError("Gate seeds must be non-empty strings or finite numbers");
+	return value;
+};
+const normalizeControl = (value, fallback, name) => {
+	const candidate = value === void 0 ? fallback : value;
+	if (typeof candidate !== "number" || !Number.isFinite(candidate)) throw new TypeError(`${name} must be a finite number`);
+	if (candidate < 0 || candidate > 1) throw new RangeError(`${name} must be between 0 and 1 inclusive`);
+	return canonicalNumber(candidate);
+};
+function normalizeFamilyOptions(value, version) {
+	const sampleIndex$2 = version === 2 ? sampleIndex$1 : sampleIndex;
+	const input = requirePlainObject$1(value, version);
+	const unsupportedKeys = Reflect.ownKeys(input).filter((key) => typeof key !== "string" || !FAMILY_OPTION_KEYS.has(key)).map(String).sort();
+	if (unsupportedKeys.length > 0) throw new TypeError(`Unsupported generation-v${version} option keys: ${unsupportedKeys.join(", ")}`);
+	if (ownValue(input, "generationVersion") !== version) throw new TypeError(`generation-v${version} options require generationVersion ${version}`);
+	const seed = normalizeSeed(ownValue(input, "seed"));
+	const familyInput = ownValue(input, "family");
+	const requestedFamily = familyInput === void 0 ? "auto" : familyInput;
+	if (requestedFamily !== "auto" && !isGateFamily(requestedFamily)) throw new TypeError(`generation-v${version} family is invalid`);
+	const family = requestedFamily === "auto" ? FAMILY_ORDER[sampleIndex$2(seed, "family", FAMILY_ORDER.length)] : requestedFamily;
+	const density = normalizeControl(ownValue(input, "density"), .55, "density");
+	const curvature = normalizeControl(ownValue(input, "curvature"), .65, "curvature");
+	const symmetry = normalizeControl(ownValue(input, "symmetry"), 1, "symmetry");
+	const peakHeight = normalizeControl(ownValue(input, "peakHeight"), .35, "peakHeight");
+	const sideComplexity = normalizeControl(ownValue(input, "sideComplexity"), .5, "sideComplexity");
+	const requestedCrest = ownValue(input, "crest");
+	const compatibleCrests = compatibleCrestsForFamily(family);
+	if (requestedCrest !== void 0 && (typeof requestedCrest !== "string" || !compatibleCrests.includes(requestedCrest))) throw new TypeError(`crest is incompatible with generation-v${version} family ${family}`);
+	return {
+		seed,
+		options: {
+			generationVersion: version,
+			family,
+			density,
+			curvature,
+			symmetry,
+			peakHeight,
+			sideComplexity,
+			crest: requestedCrest === void 0 ? compatibleCrests[version === 3 ? 0 : sampleIndex$2(seed, `${family}/crest`, compatibleCrests.length)] : requestedCrest,
+			inset: INSET,
+			strokeWidth: STROKE_WIDTH
+		}
+	};
+}
+
+//#endregion
+//#region src/core/v2/generate.ts
+const COORDINATE_SCALE = 1e4;
+const centerPairForWidth = (width) => {
+	const widthLatticeUnits = Math.round(width * COORDINATE_SCALE);
+	const leftLatticeUnits = Math.floor(widthLatticeUnits / 2);
+	return {
+		left: leftLatticeUnits / COORDINATE_SCALE,
+		right: (widthLatticeUnits - leftLatticeUnits) / COORDINATE_SCALE
+	};
+};
+const pairedCenteredPaths = (path, width) => {
+	const centerPair = centerPairForWidth(width);
+	return centerPair.left === centerPair.right ? [path] : [path, mirrorPath(path, width)];
+};
+const displaceInteriorY = (path, displacement) => canonicalizePath(path.map((command, index) => {
+	if (command.kind === "C") return {
+		...command,
+		y1: command.y1 + displacement,
+		y2: command.y2 + displacement
+	};
+	if (command.kind === "Q") return {
+		...command,
+		y1: command.y1 + displacement
+	};
+	if (command.kind === "L" && index < path.length - 1) return {
+		...command,
+		y: command.y + displacement
+	};
+	return command;
+}));
+const quantizedSymmetryDisplacement = (symmetry, signedSample, maximumSpan) => {
+	if (symmetry === 1) return 0;
+	const maximumLatticeUnits = Math.max(1, Math.floor(maximumSpan * COORDINATE_SCALE / 2));
+	const sampledLatticeUnits = Math.round((1 - symmetry) * signedSample * maximumSpan * COORDINATE_SCALE);
+	return (signedSample < 0 ? -1 : 1) * Math.min(maximumLatticeUnits, Math.max(1, Math.abs(sampledLatticeUnits))) / COORDINATE_SCALE;
+};
+const createCrestPath = (crest, centerX, edge, railY, peakHeight) => {
+	if (crest === "none") return;
+	const upperHeight = railY - edge;
+	const tipY = edge;
+	const shoulderY = canonicalNumber(edge + Math.min(18, upperHeight * (.28 + peakHeight * .16)));
+	const halfWidth = canonicalNumber(Math.min(8, upperHeight * .18));
+	if (crest === "spear") return canonicalizePath([
+		{
+			kind: "M",
+			x: centerX,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: centerX,
+			y: tipY
+		},
+		{
+			kind: "M",
+			x: centerX,
+			y: tipY
+		},
+		{
+			kind: "L",
+			x: centerX + halfWidth,
+			y: shoulderY
+		},
+		{
+			kind: "L",
+			x: centerX,
+			y: shoulderY + halfWidth
+		},
+		{
+			kind: "L",
+			x: centerX - halfWidth,
+			y: shoulderY
+		},
+		{ kind: "Z" }
+	]);
+	if (crest === "fleur") {
+		const crestHeight = canonicalNumber(upperHeight * (.44 + peakHeight * .04));
+		const crestTopY = canonicalNumber(railY - crestHeight);
+		const sidePetalHalfWidth = canonicalNumber(crestHeight * .39);
+		const collarHalfWidth = canonicalNumber(crestHeight * .26);
+		const centralPetalHalfWidth = canonicalNumber(crestHeight * .18);
+		const lowerSepalHalfWidth = canonicalNumber(crestHeight * .37);
+		const sidePetalY = canonicalNumber(crestTopY + crestHeight * .38);
+		const collarY = canonicalNumber(crestTopY + crestHeight * .7);
+		const centralPetal = canonicalizePath([
+			{
+				kind: "M",
+				x: centerX,
+				y: collarY
+			},
+			{
+				kind: "C",
+				x1: centerX - centralPetalHalfWidth,
+				y1: crestTopY + crestHeight * .52,
+				x2: centerX - centralPetalHalfWidth,
+				y2: crestTopY + crestHeight * .16,
+				x: centerX,
+				y: crestTopY
+			},
+			{
+				kind: "C",
+				x1: centerX + centralPetalHalfWidth,
+				y1: crestTopY + crestHeight * .16,
+				x2: centerX + centralPetalHalfWidth,
+				y2: crestTopY + crestHeight * .52,
+				x: centerX,
+				y: collarY
+			},
+			{ kind: "Z" }
+		]);
+		const leftSidePetal = canonicalizePath([
+			{
+				kind: "M",
+				x: centerX,
+				y: collarY
+			},
+			{
+				kind: "C",
+				x1: centerX - collarHalfWidth * .35,
+				y1: crestTopY + crestHeight * .56,
+				x2: centerX - sidePetalHalfWidth * .72,
+				y2: crestTopY + crestHeight * .23,
+				x: centerX - sidePetalHalfWidth,
+				y: sidePetalY
+			},
+			{
+				kind: "C",
+				x1: centerX - sidePetalHalfWidth * 1.02,
+				y1: crestTopY + crestHeight * .52,
+				x2: centerX - collarHalfWidth * 1.25,
+				y2: crestTopY + crestHeight * .66,
+				x: centerX - collarHalfWidth,
+				y: collarY
+			}
+		]);
+		const leftSepal = canonicalizePath([{
+			kind: "M",
+			x: centerX - collarHalfWidth,
+			y: collarY
+		}, {
+			kind: "C",
+			x1: centerX - lowerSepalHalfWidth,
+			y1: crestTopY + crestHeight * .79,
+			x2: centerX - lowerSepalHalfWidth,
+			y2: crestTopY + crestHeight * .91,
+			x: centerX,
+			y: railY
+		}]);
+		return canonicalizePath([
+			{
+				kind: "M",
+				x: centerX,
+				y: railY
+			},
+			{
+				kind: "L",
+				x: centerX,
+				y: collarY
+			},
+			...leftSidePetal,
+			...mirrorPath(leftSidePetal, centerX * 2),
+			{
+				kind: "M",
+				x: centerX - collarHalfWidth,
+				y: collarY
+			},
+			{
+				kind: "L",
+				x: centerX + collarHalfWidth,
+				y: collarY
+			},
+			...leftSepal,
+			...mirrorPath(leftSepal, centerX * 2),
+			...centralPetal
+		]);
+	}
+	return canonicalizePath([
+		{
+			kind: "M",
+			x: centerX,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: centerX,
+			y: tipY
+		},
+		{
+			kind: "M",
+			x: centerX,
+			y: tipY
+		},
+		{
+			kind: "L",
+			x: centerX + halfWidth,
+			y: shoulderY
+		},
+		{
+			kind: "L",
+			x: centerX,
+			y: shoulderY + halfWidth * 2
+		},
+		{
+			kind: "L",
+			x: centerX - halfWidth,
+			y: shoulderY
+		},
+		{ kind: "Z" }
+	]);
+};
+const composeCourtyard = (seed, options, layout) => {
+	const { width, edge, railY, bottomY, frameBand, safeLeft } = layout;
+	const composition = sampleIndex$1(seed, "courtyard/composition", 3);
+	const motifLevel = Math.min(2, Math.floor(3 * options.density + sampleScalar$1(seed, "courtyard/motif-count")));
+	const sideLevel = Math.min(2, Math.floor(3 * options.sideComplexity + sampleScalar$1(seed, "courtyard/sides")));
+	const scrollPairs = [
+		1,
+		2,
+		3
+	][motifLevel];
+	const upperHeight = railY - edge;
+	const halfSpan = width / 2 - edge;
+	const scrollReach = canonicalNumber(halfSpan * (.42 + .26 * sampleScalar$1(seed, "courtyard/anchor/scroll-reach")));
+	const lift = canonicalNumber(upperHeight * (.42 + options.curvature * .18 + options.peakHeight * .12));
+	const structural = [];
+	if (composition === 1) {
+		const bayWidth = (width - edge * 2) / 3;
+		for (let index = 0; index < 3; index += 1) {
+			const left = canonicalNumber(edge + bayWidth * index);
+			const right = canonicalNumber(edge + bayWidth * (index + 1));
+			const bayLift = canonicalNumber(lift * (index === 1 ? 1 : .72));
+			const bayPath = canonicalizePath([{
+				kind: "M",
+				x: left,
+				y: railY
+			}, {
+				kind: "Q",
+				x1: (left + right) / 2,
+				y1: railY - bayLift,
+				x: right,
+				y: railY
+			}]);
+			structural.push(...index === 1 ? pairedCenteredPaths(bayPath, width) : [bayPath]);
+		}
+		const centerPair = centerPairForWidth(width);
+		if (centerPair.left !== centerPair.right) {
+			const leftBay = structural[0];
+			structural[structural.length - 1] = mirrorPath(leftBay, width);
+		}
+	} else if (composition === 2) {
+		const shoulder = canonicalNumber(width / 2 - Math.min(scrollReach * .38, halfSpan * .34));
+		const crownY = canonicalNumber(edge + upperHeight * (.28 - options.peakHeight * .08));
+		const bridgePath = canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "L",
+				x: shoulder,
+				y: railY - lift * .48
+			},
+			{
+				kind: "Q",
+				x1: width / 2,
+				y1: crownY,
+				x: width - shoulder,
+				y: railY - lift * .48
+			},
+			{
+				kind: "L",
+				x: width - edge,
+				y: railY
+			}
+		]);
+		structural.push(...pairedCenteredPaths(bridgePath, width));
+		const centerStem = canonicalizePath([{
+			kind: "M",
+			x: width / 2,
+			y: railY
+		}, {
+			kind: "L",
+			x: width / 2,
+			y: crownY
+		}]);
+		structural.push(...pairedCenteredPaths(centerStem, width));
+	}
+	for (let index = 0; index < scrollPairs; index += 1) {
+		const nesting = 1 - index * .17;
+		const startX = canonicalNumber(edge + index * Math.min(5, frameBand * .22));
+		const endX = canonicalNumber(edge + scrollReach * nesting);
+		const scrollLift = canonicalNumber(lift * nesting);
+		const leftScroll = canonicalizePath([
+			{
+				kind: "M",
+				x: startX,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: startX + (endX - startX) * .18,
+				y1: railY - scrollLift * .52,
+				x2: startX + (endX - startX) * .54,
+				y2: railY - scrollLift,
+				x: endX,
+				y: railY - scrollLift * .58
+			},
+			{
+				kind: "C",
+				x1: endX + (endX - startX) * .08,
+				y1: railY - scrollLift * .26,
+				x2: endX - (endX - startX) * .12,
+				y2: railY - scrollLift * .08,
+				x: endX - (endX - startX) * .28,
+				y: railY
+			}
+		]);
+		const rightDisplacement = quantizedSymmetryDisplacement(options.symmetry, sampleScalar$1(seed, "courtyard/detail", index) - .5, lift * .08);
+		structural.push(leftScroll, displaceInteriorY(mirrorPath(leftScroll, width), rightDisplacement));
+	}
+	const sideMiddle = canonicalNumber((railY + bottomY) / 2);
+	const sideReach = canonicalNumber(safeLeft - edge - 1.0001);
+	const leftSide = sideLevel === 0 ? canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: edge + sideReach * .52,
+			y: sideMiddle
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: bottomY
+		}
+	]) : canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: railY + (sideMiddle - railY) * .42,
+			x2: edge + sideReach,
+			y2: sideMiddle - frameBand * .35,
+			x: edge + sideReach * .5,
+			y: sideMiddle
+		},
+		{
+			kind: "C",
+			x1: edge,
+			y1: sideMiddle + frameBand * .35,
+			x2: edge,
+			y2: bottomY - (bottomY - sideMiddle) * .42,
+			x: edge,
+			y: bottomY
+		}
+	]);
+	return {
+		structural,
+		decorative: [leftSide, mirrorPath(leftSide, width)]
+	};
+};
+const composeFleuron = (seed, options, layout) => {
+	const { width, edge, railY, bottomY, frameBand, safeLeft } = layout;
+	const composition = sampleIndex$1(seed, "fleuron/composition", 3);
+	const motifLevel = Math.min(2, Math.floor(3 * options.density + sampleScalar$1(seed, "fleuron/motif-count")));
+	const sideLevel = Math.min(2, Math.floor(3 * options.sideComplexity + sampleScalar$1(seed, "fleuron/sides")));
+	const clusterCount = [
+		1,
+		2,
+		3
+	][motifLevel];
+	const upperHeight = railY - edge;
+	const upperRight = canonicalNumber(width - edge);
+	const upperWidth = canonicalNumber(upperRight - edge);
+	const petalSpan = canonicalNumber(upperWidth * (.12 + .1 * sampleScalar$1(seed, "fleuron/proportion/petal-span")));
+	const lift = canonicalNumber(upperHeight * (.5 + options.curvature * .16 + options.peakHeight * .16));
+	const centerX = width / 2;
+	const structural = [];
+	const clusterTier = (index) => Math.min(index, clusterCount - 1 - index) % 2;
+	if (composition === 0) {
+		const leftBrace = canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: edge + petalSpan * .3,
+				y1: railY - lift * .5,
+				x2: centerX - petalSpan,
+				y2: railY - lift,
+				x: centerX,
+				y: railY - lift * .58
+			},
+			{
+				kind: "C",
+				x1: centerX - petalSpan * .3,
+				y1: railY - lift * .34,
+				x2: centerX - petalSpan * .18,
+				y2: railY - lift * .12,
+				x: centerX,
+				y: railY
+			}
+		]);
+		structural.push(leftBrace, mirrorPath(leftBrace, width));
+		const centerStem = canonicalizePath([{
+			kind: "M",
+			x: centerX,
+			y: railY
+		}, {
+			kind: "L",
+			x: centerX,
+			y: edge + upperHeight * .2
+		}]);
+		structural.push(...pairedCenteredPaths(centerStem, width));
+	} else if (composition === 1) {
+		const heartPath = canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: edge + petalSpan * .55,
+				y1: railY - lift * .58,
+				x2: centerX - petalSpan * .72,
+				y2: railY - lift,
+				x: centerX,
+				y: railY - lift * .42
+			},
+			{
+				kind: "C",
+				x1: centerX + petalSpan * .72,
+				y1: railY - lift,
+				x2: width - edge - petalSpan * .55,
+				y2: railY - lift * .58,
+				x: width - edge,
+				y: railY
+			}
+		]);
+		structural.push(...pairedCenteredPaths(heartPath, width));
+	}
+	const decorative = [];
+	const stemPairSources = /* @__PURE__ */ new Map();
+	const petalPairSources = /* @__PURE__ */ new Map();
+	for (let index = 0; index < clusterCount; index += 1) {
+		const mirrorIndex = clusterCount - 1 - index;
+		if (index > mirrorIndex) {
+			const stemSource = stemPairSources.get(mirrorIndex);
+			const source = petalPairSources.get(mirrorIndex);
+			structural.push(mirrorPath(stemSource, width));
+			decorative.push(mirrorPath(source, width));
+			continue;
+		}
+		const offset = (index - (clusterCount - 1) / 2) * petalSpan * .72;
+		const rootX = canonicalNumber(centerX + offset * 1.45);
+		const flowerX = canonicalNumber(centerX + offset);
+		const flowerY = canonicalNumber(railY - lift * (.58 + (clusterTier(index) === 0 ? .16 : 0)));
+		const halfPetal = canonicalNumber(Math.min(petalSpan * .22, upperHeight * .2));
+		const stemPath = canonicalizePath([{
+			kind: "M",
+			x: rootX,
+			y: railY
+		}, {
+			kind: "Q",
+			x1: rootX + (flowerX - rootX) * .35,
+			y1: railY - lift * .36,
+			x: flowerX,
+			y: flowerY + halfPetal
+		}]);
+		const petalPath = canonicalizePath([
+			{
+				kind: "M",
+				x: flowerX,
+				y: flowerY + halfPetal
+			},
+			{
+				kind: "Q",
+				x1: flowerX - halfPetal,
+				y1: flowerY,
+				x: flowerX,
+				y: flowerY - halfPetal
+			},
+			{
+				kind: "Q",
+				x1: flowerX + halfPetal,
+				y1: flowerY,
+				x: flowerX,
+				y: flowerY + halfPetal
+			},
+			{ kind: "Z" }
+		]);
+		if (index === mirrorIndex) {
+			structural.push(...pairedCenteredPaths(stemPath, width));
+			decorative.push(...pairedCenteredPaths(petalPath, width));
+		} else {
+			stemPairSources.set(index, stemPath);
+			petalPairSources.set(index, petalPath);
+			structural.push(stemPath);
+			decorative.push(petalPath);
+		}
+	}
+	const sideMiddle = canonicalNumber((railY + bottomY) / 2);
+	const sideReach = canonicalNumber(safeLeft - edge - 1.0001);
+	const leftSide = sideLevel === 0 ? canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: bottomY
+		},
+		{
+			kind: "L",
+			x: edge + sideReach * .72,
+			y: sideMiddle
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: railY
+		}
+	]) : sideLevel === 1 ? canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: sideMiddle + frameBand * .42
+		},
+		{
+			kind: "Q",
+			x1: edge + sideReach,
+			y1: sideMiddle,
+			x: edge,
+			y: sideMiddle - frameBand * .42
+		},
+		{
+			kind: "Q",
+			x1: edge + sideReach * .45,
+			y1: sideMiddle,
+			x: edge,
+			y: sideMiddle + frameBand * .42
+		},
+		{ kind: "Z" }
+	]) : canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: railY + (sideMiddle - railY) * .34,
+			x2: edge + sideReach,
+			y2: sideMiddle - frameBand * .28,
+			x: edge + sideReach * .35,
+			y: sideMiddle
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: sideMiddle + frameBand * .28,
+			x2: edge + sideReach,
+			y2: bottomY - (bottomY - sideMiddle) * .34,
+			x: edge,
+			y: bottomY
+		}
+	]);
+	const rightSideDisplacement = quantizedSymmetryDisplacement(options.symmetry, sampleScalar$1(seed, "fleuron/detail", clusterCount) - .5, frameBand * .12);
+	decorative.push(leftSide, displaceInteriorY(mirrorPath(leftSide, width), rightSideDisplacement));
+	return {
+		structural,
+		decorative
+	};
+};
+const composeVine = (seed, options, layout) => {
+	const { width, edge, railY, bottomY, frameBand, safeLeft } = layout;
+	const composition = sampleIndex$1(seed, "vine/composition", 3);
+	const motifLevel = Math.min(2, Math.floor(3 * options.density + sampleScalar$1(seed, "vine/motif-count")));
+	const sideLevel = Math.min(2, Math.floor(3 * options.sideComplexity + sampleScalar$1(seed, "vine/sides")));
+	const leafPairs = [
+		2,
+		4,
+		6
+	][motifLevel];
+	const curlPairCount = [
+		1,
+		1,
+		2
+	][motifLevel];
+	const upperHeight = railY - edge;
+	const halfSpan = width / 2 - edge;
+	const leafNode = .22 + .56 * sampleScalar$1(seed, "vine/anchor/leaf-node");
+	const lift = canonicalNumber(upperHeight * (.52 + options.curvature * .16 + options.peakHeight * .14));
+	const structural = [];
+	if (composition === 0) {
+		const leftStem = canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: edge + halfSpan * .12,
+				y1: railY - lift * .28,
+				x2: edge + halfSpan * .28,
+				y2: railY - lift * .78,
+				x: edge + halfSpan * .62,
+				y: railY - lift
+			},
+			{
+				kind: "C",
+				x1: edge + halfSpan * .78,
+				y1: railY - lift * .96,
+				x2: width / 2 - halfSpan * .08,
+				y2: railY - lift * .5,
+				x: width / 2,
+				y: railY
+			}
+		]);
+		structural.push(leftStem, mirrorPath(leftStem, width));
+	} else if (composition === 1) {
+		const leftCanopy = canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: edge + halfSpan * .18,
+				y1: railY - lift * .72,
+				x2: edge + halfSpan * .52,
+				y2: railY - lift,
+				x: width / 2,
+				y: railY - lift * .62
+			},
+			{
+				kind: "C",
+				x1: width / 2 + halfSpan * .18,
+				y1: railY - lift * .38,
+				x2: width / 2 + halfSpan * .3,
+				y2: railY - lift * .82,
+				x: width / 2 + halfSpan * .48,
+				y: railY - lift * .54
+			},
+			{
+				kind: "C",
+				x1: width / 2 + halfSpan * .62,
+				y1: railY - lift * .3,
+				x2: width - edge - halfSpan * .08,
+				y2: railY - lift * .16,
+				x: width - edge,
+				y: railY
+			}
+		]);
+		structural.push(leftCanopy, mirrorPath(leftCanopy, width));
+	} else {
+		const leftBranch = canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: edge + halfSpan * .08,
+				y1: railY - lift * .22,
+				x2: edge + halfSpan * .2,
+				y2: railY - lift * .86,
+				x: edge + halfSpan * .48,
+				y: railY - lift * .82
+			},
+			{
+				kind: "C",
+				x1: edge + halfSpan * .7,
+				y1: railY - lift * .78,
+				x2: width / 2 - halfSpan * .12,
+				y2: railY - lift * .34,
+				x: width / 2,
+				y: railY - lift * .56
+			},
+			{
+				kind: "C",
+				x1: width / 2 - halfSpan * .04,
+				y1: railY - lift * .28,
+				x2: width / 2 - halfSpan * .02,
+				y2: railY - lift * .12,
+				x: width / 2,
+				y: railY
+			}
+		]);
+		structural.push(leftBranch, mirrorPath(leftBranch, width));
+		const centerStem = canonicalizePath([{
+			kind: "M",
+			x: width / 2,
+			y: railY
+		}, {
+			kind: "L",
+			x: width / 2,
+			y: railY - lift * .56
+		}]);
+		structural.push(...pairedCenteredPaths(centerStem, width));
+	}
+	for (let index = 0; index < curlPairCount; index += 1) {
+		const rootX = canonicalNumber(edge + halfSpan * (.16 + index * .11));
+		const reach = canonicalNumber(halfSpan * (.28 - index * .06));
+		const curlLift = canonicalNumber(lift * (.68 - index * .12));
+		const leftCurl = canonicalizePath([
+			{
+				kind: "M",
+				x: rootX,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: rootX + reach * .12,
+				y1: railY - curlLift * .48,
+				x2: rootX + reach * .54,
+				y2: railY - curlLift,
+				x: rootX + reach * .82,
+				y: railY - curlLift * .72
+			},
+			{
+				kind: "C",
+				x1: rootX + reach * 1.08,
+				y1: railY - curlLift * .52,
+				x2: rootX + reach,
+				y2: railY - curlLift * .18,
+				x: rootX + reach * .76,
+				y: railY - curlLift * .28
+			},
+			{
+				kind: "C",
+				x1: rootX + reach * .56,
+				y1: railY - curlLift * .38,
+				x2: rootX + reach * .6,
+				y2: railY - curlLift * .58,
+				x: rootX + reach * .73,
+				y: railY - curlLift * .5
+			}
+		]);
+		const rightDisplacement = quantizedSymmetryDisplacement(options.symmetry, sampleScalar$1(seed, "vine/detail", leafPairs * 2 + index) - .5, curlLift * .06);
+		structural.push(leftCurl, displaceInteriorY(mirrorPath(leftCurl, width), rightDisplacement));
+	}
+	const decorative = [];
+	const leafHalfWidth = canonicalNumber(Math.min(halfSpan * .035, upperHeight * .12));
+	const leafHalfHeight = canonicalNumber(Math.min(upperHeight * .075, 7));
+	for (let index = 0; index < leafPairs; index += 1) {
+		const detail = sampleScalar$1(seed, "vine/detail", index);
+		const along = .18 + .64 * (index + leafNode) / (leafPairs + 1);
+		const leafX = canonicalNumber(edge + halfSpan * along);
+		const leftLeafDisplacement = quantizedSymmetryDisplacement(options.symmetry, .5 - detail, lift * .08);
+		const leafY = canonicalNumber(railY - lift * (.28 + along * .56) + leftLeafDisplacement);
+		const leftLeaf = canonicalizePath([
+			{
+				kind: "M",
+				x: leafX,
+				y: leafY + leafHalfHeight
+			},
+			{
+				kind: "Q",
+				x1: leafX - leafHalfWidth,
+				y1: leafY,
+				x: leafX,
+				y: leafY - leafHalfHeight
+			},
+			{
+				kind: "Q",
+				x1: leafX + leafHalfWidth,
+				y1: leafY,
+				x: leafX,
+				y: leafY + leafHalfHeight
+			},
+			{ kind: "Z" }
+		]);
+		const leftTwig = canonicalizePath([{
+			kind: "M",
+			x: leafX,
+			y: railY
+		}, {
+			kind: "Q",
+			x1: leafX + (index % 2 === 0 ? -leafHalfWidth : leafHalfWidth),
+			y1: (railY + leafY) / 2,
+			x: leafX,
+			y: leafY + leafHalfHeight
+		}]);
+		const rightLeafDisplacement = quantizedSymmetryDisplacement(options.symmetry, sampleScalar$1(seed, "vine/detail", index + leafPairs) - .5, leafHalfHeight * .24);
+		structural.push(leftTwig, mirrorPath(leftTwig, width));
+		decorative.push(leftLeaf, displaceInteriorY(mirrorPath(leftLeaf, width), rightLeafDisplacement));
+	}
+	const sideMiddle = canonicalNumber((railY + bottomY) / 2);
+	const sideReach = canonicalNumber(safeLeft - edge - 1.0001);
+	const leftSide = sideLevel === 0 ? canonicalizePath([{
+		kind: "M",
+		x: edge,
+		y: bottomY
+	}, {
+		kind: "L",
+		x: edge + sideReach * .62,
+		y: railY
+	}]) : sideLevel === 1 ? canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: bottomY
+		},
+		{
+			kind: "Q",
+			x1: edge + sideReach,
+			y1: sideMiddle,
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: edge + sideReach * .72,
+			y: sideMiddle
+		}
+	]) : canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: bottomY
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: bottomY - (bottomY - sideMiddle) * .46,
+			x2: edge,
+			y2: sideMiddle + frameBand * .3,
+			x: edge + sideReach * .58,
+			y: sideMiddle
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: sideMiddle - frameBand * .3,
+			x2: edge,
+			y2: railY + (sideMiddle - railY) * .46,
+			x: edge,
+			y: railY
+		}
+	]);
+	decorative.push(leftSide, mirrorPath(leftSide, width));
+	return {
+		structural,
+		decorative
+	};
+};
+const composeFan = (seed, options, layout) => {
+	const { width, edge, railY, bottomY, frameBand, safeLeft } = layout;
+	const composition = sampleIndex$1(seed, "fan/composition", 3);
+	const motifLevel = Math.min(2, Math.floor(3 * options.density + sampleScalar$1(seed, "fan/motif-count")));
+	const sideLevel = Math.min(2, Math.floor(3 * options.sideComplexity + sampleScalar$1(seed, "fan/sides")));
+	const raysPerHalf = [
+		3,
+		5,
+		7
+	][motifLevel];
+	const upperHeight = railY - edge;
+	const halfSpan = width / 2 - edge;
+	const originRatio = .58 + .24 * sampleScalar$1(seed, "fan/anchor/origin-height");
+	const originY = canonicalNumber(railY + (bottomY - railY) * originRatio);
+	const lift = canonicalNumber(upperHeight * (.48 + options.peakHeight * .22 + options.curvature * .1));
+	const structural = [];
+	for (let index = 0; index < raysPerHalf; index += 1) {
+		const fraction = (index + 1) / (raysPerHalf + 1);
+		const detail = sampleScalar$1(seed, "fan/detail", index);
+		const targetX = canonicalNumber(edge + halfSpan * fraction);
+		const leftTargetDisplacement = quantizedSymmetryDisplacement(options.symmetry, .5 - detail, lift * .06);
+		const targetY = canonicalNumber(railY - lift * (.34 + fraction * .62) + leftTargetDisplacement);
+		const leftRay = composition === 0 ? canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: originY
+			},
+			{
+				kind: "L",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "L",
+				x: targetX,
+				y: targetY
+			}
+		]) : composition === 1 ? canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: originY
+			},
+			{
+				kind: "L",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "L",
+				x: edge + halfSpan * fraction * .24,
+				y: railY + frameBand * (.72 - fraction * .24)
+			},
+			{
+				kind: "L",
+				x: edge + halfSpan * fraction * .58,
+				y: railY - lift * fraction * .34
+			},
+			{
+				kind: "L",
+				x: targetX,
+				y: targetY
+			}
+		]) : canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: originY
+			},
+			{
+				kind: "L",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "Q",
+				x1: edge + halfSpan * fraction * .38,
+				y1: railY - lift * fraction * .18,
+				x: targetX,
+				y: targetY
+			},
+			{
+				kind: "L",
+				x: width / 2,
+				y: railY
+			}
+		]);
+		const mirroredRightRay = mirrorPath(leftRay, width);
+		const rightTargetIndex = composition === 2 ? mirroredRightRay.length - 2 : mirroredRightRay.length - 1;
+		const rightTargetDisplacement = quantizedSymmetryDisplacement(options.symmetry, sampleScalar$1(seed, "fan/detail", index + raysPerHalf) - .5, lift * .05);
+		const rightRay = canonicalizePath(mirroredRightRay.map((command, commandIndex) => commandIndex === rightTargetIndex && (command.kind === "L" || command.kind === "Q") ? {
+			...command,
+			y: command.y + rightTargetDisplacement
+		} : command));
+		structural.push(leftRay, rightRay);
+	}
+	const decorative = [];
+	const sideMiddle = canonicalNumber((railY + bottomY) / 2);
+	const sideReach = canonicalNumber(safeLeft - edge - 1.0001);
+	const leftSide = sideLevel === 0 ? canonicalizePath([{
+		kind: "M",
+		x: edge + sideReach * .32,
+		y: railY
+	}, {
+		kind: "L",
+		x: edge + sideReach * .32,
+		y: bottomY
+	}]) : sideLevel === 1 ? canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: edge + sideReach * .42,
+			y: sideMiddle - frameBand * .48
+		},
+		{
+			kind: "L",
+			x: edge + sideReach,
+			y: sideMiddle
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: bottomY
+		}
+	]) : canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: edge + sideReach * .72,
+			y: sideMiddle
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: bottomY
+		}
+	]);
+	decorative.push(leftSide, mirrorPath(leftSide, width));
+	return {
+		structural,
+		decorative
+	};
+};
+const composeVolute = (seed, options, layout) => {
+	const { width, edge, railY, bottomY, frameBand, safeLeft } = layout;
+	const composition = sampleIndex$1(seed, "volute/composition", 3);
+	const motifLevel = Math.min(2, Math.floor(3 * options.density + sampleScalar$1(seed, "volute/motif-count")));
+	const sideLevel = Math.min(2, Math.floor(3 * options.sideComplexity + sampleScalar$1(seed, "volute/sides")));
+	const pairCount = [
+		1,
+		2,
+		3
+	][motifLevel];
+	const upperHeight = railY - edge;
+	const halfSpan = width / 2 - edge;
+	const upperRight = canonicalNumber(width - edge);
+	const upperWidth = canonicalNumber(upperRight - edge);
+	const coilRadius = canonicalNumber(upperWidth * (.1 + .08 * sampleScalar$1(seed, "volute/proportion/coil-radius")));
+	const lift = canonicalNumber(upperHeight * (.5 + options.curvature * .2 + options.peakHeight * .14));
+	const structural = [];
+	if (composition === 0) for (let index = 0; index < pairCount; index += 1) {
+		const nesting = 1 - index * .18;
+		const startX = canonicalNumber(edge + index * Math.min(5, frameBand * .2));
+		const centerX = canonicalNumber(edge + Math.min(halfSpan * .78, coilRadius * (1.3 + index * .2)));
+		const coilLift = canonicalNumber(lift * nesting);
+		const leftVolute = canonicalizePath([
+			{
+				kind: "M",
+				x: startX,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: startX + coilRadius * .18,
+				y1: railY - coilLift * .54,
+				x2: centerX - coilRadius * .5,
+				y2: railY - coilLift,
+				x: centerX,
+				y: railY - coilLift * .66
+			},
+			{
+				kind: "C",
+				x1: centerX + coilRadius * .32,
+				y1: railY - coilLift * .4,
+				x2: centerX + coilRadius * .16,
+				y2: railY - coilLift * .18,
+				x: centerX - coilRadius * .08,
+				y: railY - coilLift * .28
+			},
+			{
+				kind: "C",
+				x1: centerX - coilRadius * .2,
+				y1: railY - coilLift * .36,
+				x2: centerX - coilRadius * .24,
+				y2: railY - coilLift * .1,
+				x: centerX - coilRadius * .42,
+				y: railY
+			}
+		]);
+		structural.push(leftVolute, mirrorPath(leftVolute, width));
+	}
+	else if (composition === 1) {
+		const crownPath = canonicalizePath([
+			{
+				kind: "M",
+				x: edge,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: edge + coilRadius * .4,
+				y1: railY - lift * .66,
+				x2: width / 2 - coilRadius * 1.15,
+				y2: railY - lift,
+				x: width / 2 - coilRadius * .42,
+				y: railY - lift * .6
+			},
+			{
+				kind: "C",
+				x1: width / 2 - coilRadius * .08,
+				y1: railY - lift * .36,
+				x2: width / 2 - coilRadius * .28,
+				y2: railY - lift * .14,
+				x: width / 2,
+				y: railY - lift * .72
+			},
+			{
+				kind: "C",
+				x1: width / 2 + coilRadius * .28,
+				y1: railY - lift * .14,
+				x2: width / 2 + coilRadius * .08,
+				y2: railY - lift * .36,
+				x: width / 2 + coilRadius * .42,
+				y: railY - lift * .6
+			},
+			{
+				kind: "C",
+				x1: width / 2 + coilRadius * 1.15,
+				y1: railY - lift,
+				x2: width - edge - coilRadius * .4,
+				y2: railY - lift * .66,
+				x: width - edge,
+				y: railY
+			}
+		]);
+		structural.push(...pairedCenteredPaths(crownPath, width));
+		for (let index = 0; index < pairCount; index += 1) {
+			const spread = canonicalNumber(coilRadius * (.45 + index * .32));
+			const bracePath = canonicalizePath([{
+				kind: "M",
+				x: width / 2 - spread,
+				y: railY
+			}, {
+				kind: "Q",
+				x1: width / 2,
+				y1: railY - lift * (.28 + index * .08),
+				x: width / 2 + spread,
+				y: railY
+			}]);
+			structural.push(...pairedCenteredPaths(bracePath, width));
+		}
+	} else {
+		for (let index = 0; index < pairCount; index += 1) {
+			const nesting = 1 - index * .16;
+			const startX = canonicalNumber(edge + index * Math.min(6, frameBand * .22));
+			const reach = canonicalNumber(Math.min(halfSpan * .86, coilRadius * (1.25 + index * .28)));
+			const cascadeLift = canonicalNumber(lift * nesting);
+			const leftCascade = canonicalizePath([
+				{
+					kind: "M",
+					x: startX,
+					y: railY
+				},
+				{
+					kind: "C",
+					x1: startX + reach * .22,
+					y1: railY - cascadeLift * .84,
+					x2: startX + reach * .68,
+					y2: railY - cascadeLift,
+					x: startX + reach,
+					y: railY - cascadeLift * .54
+				},
+				{
+					kind: "C",
+					x1: startX + reach * .88,
+					y1: railY - cascadeLift * .22,
+					x2: startX + reach * .58,
+					y2: railY - cascadeLift * .14,
+					x: startX + reach * .42,
+					y: railY
+				}
+			]);
+			structural.push(leftCascade, mirrorPath(leftCascade, width));
+		}
+		const centerStem = canonicalizePath([{
+			kind: "M",
+			x: width / 2,
+			y: railY
+		}, {
+			kind: "L",
+			x: width / 2,
+			y: railY - lift * .64
+		}]);
+		structural.push(...pairedCenteredPaths(centerStem, width));
+	}
+	const decorative = [];
+	const sideMiddle = canonicalNumber((railY + bottomY) / 2);
+	const sideReach = canonicalNumber(safeLeft - edge - 1.0001);
+	const leftSide = sideLevel === 0 ? canonicalizePath([{
+		kind: "M",
+		x: edge,
+		y: railY
+	}, {
+		kind: "C",
+		x1: edge + sideReach,
+		y1: railY + (sideMiddle - railY) * .42,
+		x2: edge + sideReach,
+		y2: sideMiddle - frameBand * .24,
+		x: edge,
+		y: sideMiddle
+	}]) : sideLevel === 1 ? canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: railY + (sideMiddle - railY) * .38,
+			x2: edge,
+			y2: sideMiddle - frameBand * .28,
+			x: edge + sideReach * .62,
+			y: sideMiddle
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: sideMiddle + frameBand * .28,
+			x2: edge,
+			y2: bottomY - (bottomY - sideMiddle) * .38,
+			x: edge,
+			y: bottomY
+		}
+	]) : canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: railY + (sideMiddle - railY) * .28,
+			x2: edge + sideReach,
+			y2: sideMiddle - frameBand * .4,
+			x: edge + sideReach * .46,
+			y: sideMiddle - frameBand * .18
+		},
+		{
+			kind: "C",
+			x1: edge,
+			y1: sideMiddle,
+			x2: edge + sideReach,
+			y2: sideMiddle + frameBand * .12,
+			x: edge + sideReach * .68,
+			y: sideMiddle + frameBand * .3
+		},
+		{
+			kind: "C",
+			x1: edge + sideReach,
+			y1: sideMiddle + frameBand * .5,
+			x2: edge,
+			y2: bottomY - (bottomY - sideMiddle) * .28,
+			x: edge,
+			y: bottomY
+		}
+	]);
+	const rightSideDisplacement = quantizedSymmetryDisplacement(options.symmetry, sampleScalar$1(seed, "volute/detail", pairCount) - .5, frameBand * .12);
+	decorative.push(leftSide, displaceInteriorY(mirrorPath(leftSide, width), rightSideDisplacement));
+	return {
+		structural,
+		decorative
+	};
+};
+function generateGateV2(dimensionsInput, optionsInput) {
+	const dimensions = normalizeDimensions(dimensionsInput);
+	const { seed, options } = normalizeFamilyOptions(optionsInput, 2);
+	const { width, height } = dimensions;
+	const edge = canonicalNumber(9);
+	const railY = canonicalNumber(Math.max(edge + 32, height * .3));
+	const bottomY = canonicalNumber(height - edge);
+	const frameBand = canonicalNumber(Math.max(12, Math.min(24, Math.min(width, height) * .06)));
+	const safeLeft = canonicalNumber(edge + frameBand);
+	const safeRight = canonicalNumber(width - safeLeft);
+	const safeTop = canonicalNumber(railY + frameBand);
+	const safeBottom = canonicalNumber(bottomY - frameBand);
+	const centerX = canonicalNumber(width / 2);
+	const surfacePath = canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: bottomY
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: bottomY
+		},
+		{ kind: "Z" },
+		{
+			kind: "M",
+			x: safeLeft,
+			y: safeTop
+		},
+		{
+			kind: "L",
+			x: safeLeft,
+			y: safeBottom
+		},
+		{
+			kind: "L",
+			x: safeRight,
+			y: safeBottom
+		},
+		{
+			kind: "L",
+			x: safeRight,
+			y: safeTop
+		},
+		{ kind: "Z" }
+	]);
+	const framePath = canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: bottomY
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: width - edge,
+			y: bottomY
+		},
+		{ kind: "Z" }
+	]);
+	if (options.family === "courtyard" || options.family === "fleuron" || options.family === "vine" || options.family === "fan" || options.family === "volute") {
+		const familyLayout = {
+			width,
+			edge,
+			railY,
+			bottomY,
+			frameBand,
+			safeLeft
+		};
+		const composed = options.family === "courtyard" ? composeCourtyard(seed, options, familyLayout) : options.family === "fleuron" ? composeFleuron(seed, options, familyLayout) : options.family === "vine" ? composeVine(seed, options, familyLayout) : options.family === "fan" ? composeFan(seed, options, familyLayout) : composeVolute(seed, options, familyLayout);
+		const decorativePaths = [...composed.decorative];
+		const crestPath = createCrestPath(options.crest, centerX, edge, railY, options.peakHeight);
+		if (crestPath !== void 0) decorativePaths.push(...pairedCenteredPaths(crestPath, width));
+		return deepFreeze({
+			schemaVersion: 1,
+			generationVersion: 2,
+			seed,
+			dimensions,
+			viewBox: {
+				minX: 0,
+				minY: 0,
+				width,
+				height
+			},
+			options,
+			bounds: {
+				left: edge,
+				right: canonicalNumber(width - edge),
+				railY,
+				bottomY
+			},
+			contentInsets: {
+				top: safeTop,
+				right: canonicalNumber(width - safeRight),
+				bottom: canonicalNumber(height - safeBottom),
+				left: safeLeft
+			},
+			surfacePath,
+			structuralPaths: [framePath, ...composed.structural],
+			decorativePaths
+		});
+	}
+	const composition = sampleIndex$1(seed, "arcade/composition", 3);
+	const motifLevel = Math.min(2, Math.floor(3 * options.density + sampleScalar$1(seed, "arcade/motif-count")));
+	const sideLevel = Math.min(2, Math.floor(3 * options.sideComplexity + sampleScalar$1(seed, "arcade/sides")));
+	const bayCount = [
+		2,
+		3,
+		5
+	][motifLevel];
+	const span = width - edge * 2;
+	const upperHeight = railY - edge;
+	const springRatio = .32 + .26 * sampleScalar$1(seed, "arcade/anchor/spring-height");
+	const archLift = canonicalNumber(upperHeight * springRatio * (.72 + options.curvature * .28) * (.78 + options.peakHeight * .22));
+	const boundaries = Array.from({ length: bayCount + 1 }, (_, index) => canonicalNumber(edge + span * index / bayCount));
+	const arches = [];
+	for (let index = 0; index < bayCount; index += 1) {
+		const left = boundaries[index];
+		const right = boundaries[index + 1];
+		const detail = sampleScalar$1(seed, "arcade/detail", index);
+		const displacement = quantizedSymmetryDisplacement(options.symmetry, detail - .5, (right - left) * .16);
+		const roundBay = canonicalizePath([{
+			kind: "M",
+			x: left,
+			y: railY
+		}, {
+			kind: "Q",
+			x1: (left + right) / 2 + displacement,
+			y1: railY - archLift,
+			x: right,
+			y: railY
+		}]);
+		const center = (left + right) / 2;
+		const pointedBay = canonicalizePath([
+			{
+				kind: "M",
+				x: left,
+				y: railY
+			},
+			{
+				kind: "C",
+				x1: left + (right - left) * .2 + displacement,
+				y1: railY - archLift * .42,
+				x2: center - (right - left) * .12 + displacement,
+				y2: railY - archLift,
+				x: center + displacement,
+				y: railY - archLift
+			},
+			{
+				kind: "C",
+				x1: center + (right - left) * .12 + displacement,
+				y1: railY - archLift,
+				x2: right - (right - left) * .2 + displacement,
+				y2: railY - archLift * .42,
+				x: right,
+				y: railY
+			}
+		]);
+		const mirroredPairIndex = Math.min(index, bayCount - 1 - index);
+		arches.push(composition === 0 || composition === 2 && mirroredPairIndex % 2 === 0 ? roundBay : pointedBay);
+	}
+	const centerPair = centerPairForWidth(width);
+	if (centerPair.left !== centerPair.right) {
+		if (options.symmetry === 1) for (let index = 0; index < Math.floor(bayCount / 2); index += 1) {
+			const leftBay = arches[index];
+			arches[bayCount - 1 - index] = mirrorPath(leftBay, width);
+		}
+		if (bayCount % 2 === 1) {
+			const middleIndex = Math.floor(bayCount / 2);
+			const middleBay = arches[middleIndex];
+			arches.splice(middleIndex + 1, 0, mirrorPath(middleBay, width));
+		}
+	}
+	const decorativePaths = [];
+	const crestPath = createCrestPath(options.crest, centerX, edge, railY, options.peakHeight);
+	if (crestPath !== void 0) decorativePaths.push(...pairedCenteredPaths(crestPath, width));
+	const sideCenterY = canonicalNumber((railY + bottomY) / 2);
+	const sideReach = canonicalNumber(safeLeft - edge - 2);
+	const leftSide = sideLevel === 0 ? canonicalizePath([{
+		kind: "M",
+		x: edge + sideReach * .34,
+		y: railY
+	}, {
+		kind: "L",
+		x: edge + sideReach * .34,
+		y: bottomY
+	}]) : sideLevel === 1 ? canonicalizePath([{
+		kind: "M",
+		x: edge,
+		y: railY
+	}, {
+		kind: "Q",
+		x1: edge + sideReach * (.65 + options.curvature * .25),
+		y1: sideCenterY,
+		x: edge,
+		y: bottomY
+	}]) : canonicalizePath([
+		{
+			kind: "M",
+			x: edge,
+			y: railY
+		},
+		{
+			kind: "L",
+			x: edge + sideReach * .55,
+			y: sideCenterY - frameBand * .5
+		},
+		{
+			kind: "L",
+			x: edge + sideReach,
+			y: sideCenterY
+		},
+		{
+			kind: "L",
+			x: edge + sideReach * .55,
+			y: sideCenterY + frameBand * .5
+		},
+		{
+			kind: "L",
+			x: edge,
+			y: bottomY
+		}
+	]);
+	decorativePaths.push(leftSide, mirrorPath(leftSide, width));
+	return deepFreeze({
+		schemaVersion: 1,
+		generationVersion: 2,
+		seed,
+		dimensions,
+		viewBox: {
+			minX: 0,
+			minY: 0,
+			width,
+			height
+		},
+		options,
+		bounds: {
+			left: edge,
+			right: canonicalNumber(width - edge),
+			railY,
+			bottomY
+		},
+		contentInsets: {
+			top: safeTop,
+			right: canonicalNumber(width - safeRight),
+			bottom: canonicalNumber(height - safeBottom),
+			left: safeLeft
+		},
+		surfacePath,
+		structuralPaths: [framePath, ...arches],
+		decorativePaths
+	});
+}
+
+//#endregion
+//#region src/core/v3/generate.ts
+function generateGateV3(dimensions, optionsInput) {
+	const { seed, options } = normalizeFamilyOptions(optionsInput, 3);
+	dimensions = normalizeDimensions(dimensions);
+	const { width, height } = dimensions;
+	const edge = 9;
+	const railY = canonicalNumber(Math.max(41, height * .3));
+	const bottomY = canonicalNumber(height - edge);
+	const frameBand = canonicalNumber(Math.max(12, Math.min(24, Math.min(width, height) * .06)));
+	const safeLeft = canonicalNumber(edge + frameBand);
+	const safeRight = canonicalNumber(width - safeLeft);
+	const safeTop = canonicalNumber(railY + frameBand);
+	const safeBottom = canonicalNumber(bottomY - frameBand);
+	const source = {
+		seed,
+		options,
+		dimensions,
+		bounds: {
+			left: edge,
+			right: canonicalNumber(width - edge),
+			railY,
+			bottomY
+		},
+		contentInsets: {
+			left: safeLeft,
+			right: canonicalNumber(width - safeRight),
+			top: safeTop,
+			bottom: canonicalNumber(height - safeBottom)
+		},
+		surfacePath: canonicalizePath([
+			m(edge, railY),
+			l(width - edge, railY),
+			l(width - edge, bottomY),
+			l(edge, bottomY),
+			z,
+			m(safeLeft, safeTop),
+			l(safeLeft, safeBottom),
+			l(safeRight, safeBottom),
+			l(safeRight, safeTop),
+			z
+		]),
+		structuralPaths: [canonicalizePath([
+			m(edge, bottomY),
+			l(edge, railY),
+			l(width - edge, railY),
+			l(width - edge, bottomY),
+			z
+		])]
+	};
+	const { railY: rail, bottomY: bottom } = source.bounds;
+	const { family, crest, density, curvature, peakHeight, sideComplexity } = source.options;
+	const upper = (rail - edge) * (.94 + peakHeight * .06);
+	const center = width / 2;
+	const half = center - edge;
+	const band = source.contentInsets.left - edge;
+	const structure = [source.structuralPaths[0]];
+	const ornaments = [];
+	const fine = [];
+	const solid = [];
+	const centered = (collection, paths) => {
+		for (const path of paths) {
+			const canonical = canonicalizePath(path);
+			collection.push(canonical);
+			if (Math.round(width * 1e4) % 2 === 1) collection.push(mirrorPath(canonical, width));
+		}
+	};
+	const rightHeightFactor = 1 - (1 - options.symmetry) * (.06 + .04 * sampleScalar(seed, `${family}/proportion/right-lift`));
+	const pair = (collection, path) => {
+		const canonical = canonicalizePath(path);
+		const right = mirrorPath(canonical, width);
+		const isUpper = path.every((command) => Object.entries(command).every(([key, value]) => !key.startsWith("y") || Number(value) <= rail));
+		collection.push(canonical, isUpper && options.symmetry < 1 ? place(right, 0, rail * (1 - rightHeightFactor), 1, rightHeightFactor) : right);
+	};
+	const barX = edge + Math.min(7, band * .36);
+	pair(fine, [m(barX, rail), l(barX, bottom)]);
+	fine.push(canonicalizePath([m(edge, bottom - 7), l(width - edge, bottom - 7)]));
+	for (const fraction of sideComplexity > .65 ? [
+		.2,
+		.5,
+		.8
+	] : [.28, .72]) {
+		const y = rail + (bottom - rail) * fraction;
+		pair(solid, [
+			m(edge, y - 1.5),
+			l(barX + 2, y - 1.5),
+			l(barX + 2, y + 1.5),
+			l(edge, y + 1.5),
+			z
+		]);
+	}
+	const crestHeight = Math.min(upper * (.7 + peakHeight * .12), width * .29);
+	const crestTop = rail - crestHeight - 4;
+	const reserve = crest === "fleur" ? crestHeight * .44 + 7 : crest === "none" ? 9 : 16;
+	if (crest === "fleur") {
+		const fleurHeight = crestHeight * .84;
+		const [crown, collar, foot] = fleurDeLys(center, rail - fleurHeight - 4, fleurHeight);
+		centered(fine, [crown, foot]);
+		centered(solid, [collar]);
+		centered(structure, [[m(center, rail), l(center, rail - 4)]]);
+	} else if (crest !== "none") {
+		const capHeight = Math.min(22, crestHeight * .35);
+		const capWidth = capHeight * (crest === "diamond" ? .32 : .22);
+		centered(solid, [placeEmblem([
+			m(0, 0),
+			l(capWidth, capHeight * .58),
+			l(0, capHeight),
+			l(-capWidth, capHeight * .58),
+			z
+		], center, crestTop, 1)]);
+		centered(structure, [[m(center, crestTop + capHeight), l(center, rail)]]);
+		centered(fine, [canonicalizePath([m(center - 4, crestTop + capHeight + 4), l(center + 4, crestTop + capHeight + 4)])]);
+	}
+	const usable = half - reserve - 9;
+	const variation = sampleScalar(source.seed, `${family}/proportion/study-lift`);
+	const count = Math.max(1, Math.min(family === "arcade" ? 2 + Math.round(density * 2) : 1 + Math.round(density * 2), Math.floor(usable / 46)));
+	const cell = usable / count;
+	if (family === "fan") {
+		const span = half - reserve;
+		const lift = Math.min(upper * (.6 + variation * .12) * (.86 + curvature * .14), span * .9);
+		const a = {
+			x: edge,
+			y: rail
+		};
+		const b = {
+			x: edge + span * .2,
+			y: rail - lift * .7
+		};
+		const d = {
+			x: edge + span,
+			y: rail - lift
+		};
+		const p = {
+			x: edge + span * .65,
+			y: rail - lift
+		};
+		pair(structure, [
+			m(a.x, a.y),
+			c(b.x, b.y, p.x, p.y, d.x, d.y),
+			l(d.x, rail)
+		]);
+		const rays = Math.min(3 + Math.round(density * 3), Math.max(2, Math.floor(span / 16)));
+		for (let index = 1; index < rays; index++) {
+			const tip = cubicPoint(a, b, p, d, index / rays);
+			pair(ornaments, [m(edge + span, rail), l(tip.x, tip.y)]);
+		}
+	} else if (family === "arcade") for (let index = 0; index < count; index++) {
+		const x = 16 + cell * index;
+		const w = cell - 9;
+		const h = Math.min(upper * (.6 + variation * .1 + .1 * index / count) * (.86 + curvature * .14), w * 1.15);
+		const shoulder = rail - h * .5;
+		pair(ornaments, [
+			m(x, rail),
+			l(x, shoulder),
+			c(x, rail - h * .82, x + w * .22, rail - h, x + w * .5, rail - h),
+			c(x + w * .78, rail - h, x + w, rail - h * .82, x + w, shoulder),
+			l(x + w, rail)
+		]);
+	}
+	else if (family !== "vine") {
+		const span = half - reserve;
+		const coilWidth = Math.min(span * .57, upper * (family === "volute" ? 1.12 : .9));
+		const coilX = edge + span - coilWidth;
+		const height = Math.min(upper * (family === "courtyard" ? .61 : family === "fleuron" ? .79 : .88) * (.94 + curvature * .06 + variation * .035), coilWidth * 1.25);
+		const top = rail - height;
+		const curl = scroll(coilX, top, coilWidth, height);
+		pair(ornaments, [
+			m(edge, rail),
+			c(edge, rail - height * .72, coilX + coilWidth * .18, top, coilX + coilWidth * .53, top),
+			...curl.slice(2, coilWidth < 34 ? 5 : void 0)
+		]);
+		if (span > 120 && density > .25) {
+			const smallWidth = Math.min(upper * .49, span * .25);
+			const smallHeight = height * (family === "volute" ? .36 : .29);
+			pair(fine, scroll(edge + span * .24, rail - smallHeight, smallWidth, smallHeight).slice(0, 5));
+		}
+	} else for (let index = 0; index < count; index++) {
+		const w = Math.min(cell - 10, upper * .94);
+		const x = 16 + cell * index + (cell - 10 - w) / 2;
+		const hierarchy = count === 1 ? .78 : .54 + .24 * index / (count - 1);
+		const h = Math.min(upper * hierarchy * (.88 + curvature * .12 + variation * .08), w * 1.25);
+		const top = rail - h;
+		const curl = scroll(x, top, w, h);
+		pair(ornaments, w < 34 ? curl.slice(0, 5) : curl);
+		if (family === "vine") for (const t of w > 50 ? [.24, .45] : [.34]) {
+			const node = cubicPoint({
+				x,
+				y: rail
+			}, {
+				x,
+				y: top + h * .48
+			}, {
+				x: x + w * .18,
+				y: top
+			}, {
+				x: x + w * .53,
+				y: top
+			}, t);
+			const size = Math.min(11, w * .16);
+			pair(solid, [
+				m(node.x, node.y),
+				c(node.x - size * .6, node.y - size * .05, node.x - size, node.y - size * .75, node.x - size * .7, node.y - size * 1.5),
+				c(node.x - size * .05, node.y - size, node.x + size * .12, node.y - size * .5, node.x, node.y),
+				z
+			]);
+		}
+	}
+	return deepFreeze({
+		schemaVersion: 1,
+		generationVersion: 3,
+		seed,
+		options,
+		dimensions,
+		viewBox: {
+			minX: 0,
+			minY: 0,
+			width,
+			height
+		},
+		bounds: source.bounds,
+		contentInsets: source.contentInsets,
+		surfacePath: source.surfacePath,
+		structuralPaths: structure,
+		finePaths: fine,
+		decorativePaths: ornaments,
+		solidPaths: solid
+	});
+}
+const cubicPoint = (a, b, c, d, t) => {
+	const u = 1 - t;
+	return {
+		x: u ** 3 * a.x + 3 * u ** 2 * t * b.x + 3 * u * t ** 2 * c.x + t ** 3 * d.x,
+		y: u ** 3 * a.y + 3 * u ** 2 * t * b.y + 3 * u * t ** 2 * c.y + t ** 3 * d.y
+	};
+};
+const m = (x, y) => ({
+	kind: "M",
+	x,
+	y
+});
+const l = (x, y) => ({
+	kind: "L",
+	x,
+	y
+});
+const c = (x1, y1, x2, y2, x, y) => ({
+	kind: "C",
+	x1,
+	y1,
+	x2,
+	y2,
+	x,
+	y
+});
+const z = { kind: "Z" };
+const place = (path, x, y, sx, sy = sx) => canonicalizePath(path.map((command) => {
+	if (command.kind === "Z") return command;
+	const point = {
+		x: x + command.x * sx,
+		y: y + command.y * sy
+	};
+	if (command.kind === "C") return {
+		kind: "C",
+		...point,
+		x1: x + command.x1 * sx,
+		y1: y + command.y1 * sy,
+		x2: x + command.x2 * sx,
+		y2: y + command.y2 * sy
+	};
+	if (command.kind === "Q") return {
+		kind: "Q",
+		...point,
+		x1: x + command.x1 * sx,
+		y1: y + command.y1 * sy
+	};
+	return {
+		kind: command.kind,
+		...point
+	};
+}));
+/** Heraldic silhouette selected in ART-01. */
+const placeEmblem = (path, center, top, scale) => {
+	const centerUnits = Math.round(center * 1e4);
+	return canonicalizePath(path.map((command) => Object.fromEntries(Object.entries(command).map(([key, value]) => [key, key.startsWith("x") ? (centerUnits + Math.sign(Number(value)) * Math.round(Math.abs(Number(value)) * scale * 1e4)) / 1e4 : key.startsWith("y") ? top + Number(value) * scale : value]))));
+};
+function fleurDeLys(x, top, height) {
+	const crown = [
+		m(-.12, .682),
+		c(-.14, .55, -.25, .39, -.3, .44),
+		c(-.35, .49, -.3, .55, -.25, .5),
+		c(-.28, .68, -.47, .55, -.36, .36),
+		c(-.29, .25, -.15, .32, -.055, .51),
+		c(-.13, .3, -.14, .16, 0, 0),
+		c(.14, .16, .13, .3, .055, .51),
+		c(.15, .32, .29, .25, .36, .36),
+		c(.47, .55, .28, .68, .25, .5),
+		c(.3, .55, .35, .49, .3, .44),
+		c(.25, .39, .14, .55, .12, .682),
+		l(-.12, .682),
+		z
+	];
+	const collar = [
+		m(-.13, .682),
+		l(.13, .682),
+		l(.13, .708),
+		l(-.13, .708),
+		z
+	];
+	const foot = [
+		m(-.075, .708),
+		c(-.08, .81, -.14, .85, -.2, .86),
+		c(-.14, .93, -.07, .91, -.035, .86),
+		c(-.04, .93, -.03, .97, 0, 1),
+		c(.03, .97, .04, .93, .035, .86),
+		c(.07, .91, .14, .93, .2, .86),
+		c(.14, .85, .08, .81, .075, .708),
+		l(-.075, .708),
+		z
+	];
+	return [
+		placeEmblem(crown, x, top, height),
+		placeEmblem(collar, x, top, height),
+		placeEmblem(foot, x, top, height)
+	];
+}
+function scroll(x, top, width, height) {
+	return place([
+		m(0, 1),
+		c(0, .48, .18, 0, .53, 0),
+		c(.82, 0, 1, .18, 1, .44),
+		c(1, .68, .83, .83, .65, .83),
+		c(.49, .83, .39, .72, .39, .6),
+		c(.39, .49, .47, .42, .56, .42),
+		c(.64, .42, .69, .48, .69, .54)
+	], x, top, width, height);
+}
+
+//#endregion
+//#region src/core/dispatch.ts
+const V2_ONLY_OPTION_KEYS = [
+	"symmetry",
+	"peakHeight",
+	"sideComplexity",
+	"crest"
+];
+function generateGate(dimensions, options) {
+	if (options !== null && typeof options === "object" && Object.hasOwn(options, "generationVersion") && options.generationVersion === 3) return generateGateV3(dimensions, options);
+	if (options !== null && typeof options === "object" && Object.hasOwn(options, "generationVersion") && options.generationVersion === 2) return generateGateV2(dimensions, options);
+	if (options !== null && typeof options === "object") {
+		for (const key of V2_ONLY_OPTION_KEYS) if (Object.hasOwn(options, key)) throw new TypeError(`${key} requires generationVersion 2`);
+	}
+	return generateGate$1(dimensions, options);
+}
+
+//#endregion
+//#region src/core/svg.ts
+const HEX_COLOR = /^#(?:[0-9a-f]{3}|[0-9a-f]{4}|[0-9a-f]{6}|[0-9a-f]{8})$/i;
+const COLOR_KEYWORD = /^(?:transparent|currentcolor)$/i;
+const FUNCTION_COLOR = /^(rgb|rgba|hsl|hsla)\((.*)\)$/i;
+const DECIMAL_NUMBER = /^[+-]?(?:\d+(?:\.\d+)?|\.\d+)$/;
+const XML_DELIMITER = /[&<>"']/;
+const sourceDimensions = (dimensions) => {
+	const { width, height } = dimensions;
+	for (const sourceWidth of [
+		width,
+		width - 499e-7,
+		width + 499e-7
+	]) for (const sourceHeight of [
+		height,
+		height - 499e-7,
+		height + 499e-7
+	]) {
+		const ratio = sourceWidth / sourceHeight;
+		if (ratio >= .5 && ratio <= 6) return {
+			width: sourceWidth,
+			height: sourceHeight
+		};
+	}
+	return dimensions;
+};
+const requirePlainObject = (value, name) => {
+	if (value === null || typeof value !== "object") throw new TypeError(`${name} must be a plain object`);
+	const prototype = Object.getPrototypeOf(value);
+	if (prototype !== Object.prototype && prototype !== null) throw new TypeError(`${name} must be a plain object`);
+	return value;
+};
+const structurallyEqual = (left, right) => {
+	if (left === right) return true;
+	if (Array.isArray(left) || Array.isArray(right)) return Array.isArray(left) && Array.isArray(right) && left.length === right.length && left.every((value, index) => structurallyEqual(value, right[index]));
+	if (left === null || right === null || typeof left !== "object" || typeof right !== "object") return false;
+	const leftRecord = left;
+	const rightRecord = right;
+	const leftKeys = Reflect.ownKeys(leftRecord);
+	const rightKeys = Reflect.ownKeys(rightRecord);
+	return leftKeys.length === rightKeys.length && leftKeys.every((key) => Object.hasOwn(rightRecord, key) && structurallyEqual(Reflect.get(leftRecord, key), Reflect.get(rightRecord, key)));
+};
+const regenerateGeometry = (geometry, sourceDimensions) => {
+	const options = geometry.options;
+	if (geometry.generationVersion === 1) {
+		const publicOptions = {
+			generationVersion: 1,
+			seed: geometry.seed,
+			family: "courtyard",
+			density: options.density,
+			curvature: options.curvature
+		};
+		return generateGate(sourceDimensions, publicOptions);
+	}
+	const publicOptions = {
+		generationVersion: geometry.generationVersion === 3 ? 3 : 2,
+		seed: geometry.seed,
+		family: options.family,
+		density: options.density,
+		curvature: options.curvature,
+		symmetry: options.symmetry,
+		peakHeight: options.peakHeight,
+		sideComplexity: options.sideComplexity,
+		crest: options.crest
+	};
+	return generateGate(sourceDimensions, publicOptions);
+};
+const validateGeometryForSerialization = (value) => {
+	const geometry = requirePlainObject(value, "geometry");
+	const dimensions = requirePlainObject(geometry.dimensions, "geometry.dimensions");
+	const canonicalGeometry = regenerateGeometry(geometry, sourceDimensions(dimensions));
+	if (!structurallyEqual(geometry, canonicalGeometry)) throw new TypeError("geometry must exactly match canonical generated geometry");
+	return canonicalGeometry;
+};
+const hasXmlBreakingCharacter = (value) => {
+	if (XML_DELIMITER.test(value)) return true;
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value.charCodeAt(index);
+		if (codeUnit <= 8 || codeUnit === 11 || codeUnit === 12 || codeUnit >= 14 && codeUnit <= 31) return true;
+		if (codeUnit === 127) return true;
+	}
+	return false;
+};
+const parseChannel = (token, maximum, percentOnly = false) => {
+	const percent = token.endsWith("%");
+	const numberText = percent ? token.slice(0, -1) : token;
+	if (percentOnly && !percent || !DECIMAL_NUMBER.test(numberText)) return false;
+	const value = Number(numberText);
+	const upperBound = percent ? 100 : maximum;
+	return Number.isFinite(value) && value >= 0 && value <= upperBound;
+};
+const isFunctionalColor = (paint) => {
+	const match = FUNCTION_COLOR.exec(paint);
+	if (match === null) return false;
+	const functionName = match[1]?.toLowerCase();
+	const channels = match[2]?.split(",").map((channel) => channel.trim()) ?? [];
+	const hasAlpha = functionName === "rgba" || functionName === "hsla";
+	if (channels.length !== (hasAlpha ? 4 : 3) || channels.some((channel) => channel === "")) return false;
+	if (functionName === "rgb" || functionName === "rgba") {
+		if (!channels.slice(0, 3).every((channel) => parseChannel(channel, 255))) return false;
+	} else {
+		const [hue, saturation, lightness] = channels;
+		if (hue === void 0 || saturation === void 0 || lightness === void 0 || !DECIMAL_NUMBER.test(hue) || !Number.isFinite(Number(hue)) || !parseChannel(saturation, 100, true) || !parseChannel(lightness, 100, true)) return false;
+	}
+	const alpha = channels[3];
+	return alpha === void 0 || parseChannel(alpha, 1);
+};
+const normalizePaint = (value, name) => {
+	if (typeof value !== "string") throw new TypeError(`${name} paint must be a string`);
+	const paint = value.trim();
+	if (paint.length === 0 || hasXmlBreakingCharacter(paint) || !HEX_COLOR.test(paint) && !COLOR_KEYWORD.test(paint) && !isFunctionalColor(paint)) throw new TypeError(`${name} paint must be a safe literal CSS color`);
+	return paint;
+};
+const escapeXmlAttribute = (value) => value.replaceAll("&", "&amp;").replaceAll("\"", "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll("'", "&apos;");
+const serializeCommand = (command) => {
+	switch (command.kind) {
+		case "M":
+		case "L": return `${command.kind}${command.x} ${command.y}`;
+		case "C": return `C${command.x1} ${command.y1} ${command.x2} ${command.y2} ${command.x} ${command.y}`;
+		case "Q": return `Q${command.x1} ${command.y1} ${command.x} ${command.y}`;
+		case "Z": return "Z";
+	}
+};
+const serializePath = (path) => path.map(serializeCommand).join(" ");
+function renderGateSVG(geometry, paint = {}) {
+	const canonicalGeometry = validateGeometryForSerialization(geometry);
+	const stroke = escapeXmlAttribute(normalizePaint(paint.stroke ?? "currentColor", "stroke"));
+	const surface = escapeXmlAttribute(normalizePaint(paint.surface ?? "transparent", "surface"));
+	const { width, height } = canonicalGeometry.dimensions;
+	const viewBox = canonicalGeometry.viewBox;
+	const surfacePath = `<path d="${serializePath(canonicalGeometry.surfacePath)}" fill="${surface}" fill-rule="evenodd" stroke="none"/>`;
+	if (canonicalGeometry.generationVersion === 3) {
+		const paths = (items) => items.map((path) => `<path d="${serializePath(path)}"/>`).join("");
+		return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${viewBox.minX} ${viewBox.minY} ${viewBox.width} ${viewBox.height}" data-gate-frame-generation-version="3">${surfacePath}<g stroke="${stroke}" fill="none" stroke-linecap="round" stroke-linejoin="round"><g stroke-width="2">${paths(canonicalGeometry.structuralPaths)}</g><g stroke-width="1.8">${paths(canonicalGeometry.decorativePaths)}</g><g stroke-width="1.2">${paths(canonicalGeometry.finePaths)}</g><g stroke-width="0.8" fill="${stroke}">${paths(canonicalGeometry.solidPaths)}</g></g></svg>`;
+	}
+	const ironPaths = [...canonicalGeometry.structuralPaths.map((path) => `<path d="${serializePath(path)}" fill="none"/>`), ...canonicalGeometry.decorativePaths.map((path) => `<path d="${serializePath(path)}" fill="none"/>`)].join("");
+	return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="${height}" viewBox="${viewBox.minX} ${viewBox.minY} ${viewBox.width} ${viewBox.height}" data-gate-frame-generation-version="${canonicalGeometry.generationVersion}">${surfacePath}<g stroke="${stroke}" stroke-width="${canonicalGeometry.options.strokeWidth}" stroke-linecap="round" stroke-linejoin="round">${ironPaths}</g></svg>`;
+}
+
+//#endregion
+export { isGateFamily as i, generateGate as n, isCompatibleCrest as r, renderGateSVG as t };
+//# sourceMappingURL=core-DzM1ds_q.js.map