card-gate-frame 1.0.0

package/dist/index.js

@@ -0,0 +1,728 @@
+import { i as isGateFamily, n as generateGate, r as isCompatibleCrest, t as renderGateSVG } from "./core-DzM1ds_q.js";
+
+//#region src/dom/index.ts
+const freezeContext = (context) => {
+	for (const value of Object.values(context)) if (value !== null && typeof value === "object" && !Object.isFrozen(value)) freezeContext(value);
+	return Object.freeze(context);
+};
+var GateFrameError = class extends Error {
+	constructor(code, message, context = {}, name = "GateFrameError") {
+		super(message);
+		Object.defineProperties(this, {
+			name: {
+				value: name,
+				enumerable: false
+			},
+			code: {
+				value: code,
+				enumerable: true
+			},
+			context: {
+				value: freezeContext(context),
+				enumerable: true
+			}
+		});
+	}
+};
+var GateFrameInvalidSelectorError = class extends GateFrameError {
+	constructor(selector) {
+		super("INVALID_SELECTOR", "Gate Frame received an invalid selector", { selector }, "GateFrameInvalidSelectorError");
+	}
+};
+var GateFrameTargetNotFoundError = class extends GateFrameError {
+	constructor(selector) {
+		super("TARGET_NOT_FOUND", "Gate Frame could not find a target for the selector", { selector }, "GateFrameTargetNotFoundError");
+	}
+};
+var GateFrameTargetNotHTMLElementError = class extends GateFrameError {
+	constructor(context) {
+		super("TARGET_NOT_HTML_ELEMENT", "Gate Frame targets must be HTML elements", { ...context }, "GateFrameTargetNotHTMLElementError");
+	}
+};
+var GateFrameAlreadyMountedError = class extends GateFrameError {
+	constructor(target) {
+		super("ALREADY_MOUNTED", "Gate Frame is already mounted on this target", { tagName: target.localName }, "GateFrameAlreadyMountedError");
+	}
+};
+var GateFrameUnsupportedTargetError = class extends GateFrameError {
+	constructor(target, reason, details = {}) {
+		super("UNSUPPORTED_TARGET", "Gate Frame does not support this target", {
+			tagName: target.localName,
+			reason,
+			...details
+		}, "GateFrameUnsupportedTargetError");
+	}
+};
+var GateFramePositioningConflictError = class extends GateFrameError {
+	constructor(target, descendant) {
+		super("POSITIONING_CONFLICT", "Gate Frame will not change the containing block of an absolute descendant", {
+			tagName: target.localName,
+			descendantTagName: descendant.localName
+		}, "GateFramePositioningConflictError");
+	}
+};
+var GateFrameInvalidOptionsError = class extends GateFrameError {
+	constructor(context) {
+		super("INVALID_OPTIONS", "Gate Frame received invalid options", context.category === void 0 ? {
+			optionKeys: [...context.optionKeys],
+			reason: context.reason
+		} : {
+			category: context.category,
+			optionKeys: [...context.optionKeys],
+			reason: context.reason
+		}, "GateFrameInvalidOptionsError");
+	}
+};
+var GateFrameUnsupportedDimensionsError = class extends GateFrameError {
+	constructor(dimensions) {
+		super("UNSUPPORTED_DIMENSIONS", "Gate Frame cannot generate geometry for the measured dimensions", { dimensions: { ...dimensions } }, "GateFrameUnsupportedDimensionsError");
+	}
+};
+var GateFrameInsufficientSpaceError = class extends GateFrameError {
+	constructor(measured, required) {
+		super("INSUFFICIENT_CONTENT_SPACE", "Gate Frame requires more existing target padding", {
+			measured: { ...measured },
+			required: { ...required }
+		}, "GateFrameInsufficientSpaceError");
+	}
+};
+var GateFrameNotReadyError = class extends GateFrameError {
+	constructor() {
+		super("NOT_READY", "Gate Frame has not committed a render", {}, "GateFrameNotReadyError");
+	}
+};
+var GateFrameDestroyedError = class extends GateFrameError {
+	constructor() {
+		super("DESTROYED", "Gate Frame controller is destroyed", {}, "GateFrameDestroyedError");
+	}
+};
+const PENDING_STATUS = Object.freeze({ state: "pending" });
+const DESTROYED_STATUS = Object.freeze({ state: "destroyed" });
+const mountedTargets = /* @__PURE__ */ new WeakMap();
+const REPLACED_TAGS = /* @__PURE__ */ new Set([
+	"AUDIO",
+	"CANVAS",
+	"EMBED",
+	"IFRAME",
+	"IMG",
+	"OBJECT",
+	"VIDEO"
+]);
+const RESTRICTED_FORM_TAGS = /* @__PURE__ */ new Set([
+	"BUTTON",
+	"INPUT",
+	"METER",
+	"OPTION",
+	"PROGRESS",
+	"SELECT",
+	"TEXTAREA"
+]);
+const TABLE_TAGS = /* @__PURE__ */ new Set([
+	"CAPTION",
+	"COL",
+	"COLGROUP",
+	"TABLE",
+	"TBODY",
+	"TD",
+	"TFOOT",
+	"TH",
+	"THEAD",
+	"TR"
+]);
+const SUPPORTED_TARGET_TAGS = /* @__PURE__ */ new Set([
+	"ARTICLE",
+	"ASIDE",
+	"DIV",
+	"SECTION"
+]);
+const SUPPORTED_DISPLAYS = /* @__PURE__ */ new Set([
+	"block",
+	"flex",
+	"grid",
+	"inline-block",
+	"none"
+]);
+const V1_OPTION_KEYS = /* @__PURE__ */ new Set([
+	"seed",
+	"family",
+	"generationVersion",
+	"density",
+	"curvature",
+	"stroke",
+	"surface",
+	"responsive"
+]);
+const V2_OPTION_KEYS = /* @__PURE__ */ new Set([
+	...V1_OPTION_KEYS,
+	"symmetry",
+	"peakHeight",
+	"sideComplexity",
+	"crest"
+]);
+const classifyTarget = (target, style) => {
+	const display = style.display || target.style.display || "block";
+	const writingMode = style.writingMode || target.style.writingMode || "horizontal-tb";
+	const columnCountValue = style.columnCount || target.style.columnCount || "auto";
+	const columnWidth = style.columnWidth || target.style.columnWidth || "auto";
+	if (target.shadowRoot !== null) throw new GateFrameUnsupportedTargetError(target, "shadow-host");
+	if (RESTRICTED_FORM_TAGS.has(target.tagName)) throw new GateFrameUnsupportedTargetError(target, "restricted-form-control");
+	if (TABLE_TAGS.has(target.tagName)) throw new GateFrameUnsupportedTargetError(target, "table-internal");
+	if (REPLACED_TAGS.has(target.tagName)) throw new GateFrameUnsupportedTargetError(target, "replaced-element");
+	if (display === "inline") throw new GateFrameUnsupportedTargetError(target, "display-inline", { display });
+	if (display === "contents") throw new GateFrameUnsupportedTargetError(target, "display-contents", { display });
+	if (!SUPPORTED_DISPLAYS.has(display)) throw new GateFrameUnsupportedTargetError(target, "unsupported-display", { display });
+	if (!SUPPORTED_TARGET_TAGS.has(target.tagName)) throw new GateFrameUnsupportedTargetError(target, "content-model");
+	if (!writingMode.startsWith("horizontal")) throw new GateFrameUnsupportedTargetError(target, "writing-mode", { writingMode });
+	const columnCount = Number.parseInt(columnCountValue, 10);
+	if (columnCountValue !== "auto" && Number.isFinite(columnCount) && columnCount > 1 || columnWidth !== "auto") throw new GateFrameUnsupportedTargetError(target, "fragmented", {
+		columnCount: columnCountValue,
+		columnWidth
+	});
+};
+const createRandomSeed = () => {
+	const bytes = /* @__PURE__ */ new Uint8Array(16);
+	crypto.getRandomValues(bytes);
+	return Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+};
+const invalidOptions = (options, reason) => {
+	const optionKeys = options !== null && typeof options === "object" && !Array.isArray(options) ? Object.keys(options).sort() : [];
+	return new GateFrameInvalidOptionsError({
+		optionKeys,
+		reason
+	});
+};
+const assertV1OptionKeys = (options) => {
+	const unsupportedKeys = Reflect.ownKeys(options).filter((key) => typeof key !== "string" || !V1_OPTION_KEYS.has(key)).map(String).sort();
+	if (unsupportedKeys.length > 0) throw new GateFrameInvalidOptionsError({
+		optionKeys: unsupportedKeys,
+		reason: "unsupported option keys"
+	});
+};
+const invalidV2Options = (category, optionKeys, reason) => new GateFrameInvalidOptionsError({
+	category,
+	optionKeys: [...optionKeys].sort(),
+	reason
+});
+const assertV2OptionShape = (options) => {
+	if (options === null || typeof options !== "object" || Array.isArray(options)) throw invalidV2Options("shape", [], "options must be a plain object");
+	const record = options;
+	const unsupportedKeys = Reflect.ownKeys(record).filter((key) => typeof key !== "string" || !V2_OPTION_KEYS.has(key)).map(String).sort();
+	if (unsupportedKeys.length > 0) throw invalidV2Options("unknown-key", unsupportedKeys, "unsupported option keys");
+	return record;
+};
+const ownValue = (record, key, fallback) => !Object.hasOwn(record, key) || record[key] === void 0 ? fallback : record[key];
+const isGateSeed = (value) => typeof value === "string" && value.length > 0 || typeof value === "number" && Number.isFinite(value);
+const isUnitControl = (value) => typeof value === "number" && Number.isFinite(value) && value >= 0 && value <= 1;
+const EXPECTED_CORE_OPTION_ERROR = /^(?:GF-01 requires family: "courtyard"|GF-01 supports only generationVersion 1|Gate seed numbers must be finite|Gate seeds must be strings or finite numbers|Gate seed strings must not be empty|(?:density|curvature) must be (?:a finite number|between 0 and 1 inclusive)|(?:stroke|surface) paint must be (?:a string|a safe literal CSS color))$/;
+const normalizeV1ControllerOptions = (options, fallbackSeed) => {
+	if (options === null || typeof options !== "object" || Array.isArray(options)) throw invalidOptions(options, "options must be a plain object");
+	const optionRecord = options;
+	assertV1OptionKeys(optionRecord);
+	const optionOr = (name, fallback) => optionRecord[name] === void 0 ? fallback : optionRecord[name];
+	const responsive = optionOr("responsive", true);
+	if (typeof responsive !== "boolean") throw invalidOptions(options, "responsive must be a boolean");
+	const generationOptions = {
+		seed: optionOr("seed", optionRecord.seed === void 0 && fallbackSeed === void 0 ? createRandomSeed() : fallbackSeed),
+		family: optionOr("family", "courtyard"),
+		generationVersion: optionOr("generationVersion", 1),
+		density: optionOr("density", .55),
+		curvature: optionOr("curvature", .65)
+	};
+	const stroke = optionOr("stroke", "currentColor");
+	const surface = optionOr("surface", "transparent");
+	let validationGeometry;
+	try {
+		validationGeometry = generateGate({
+			width: 160,
+			height: 160
+		}, generationOptions);
+		renderGateSVG(validationGeometry, {
+			stroke,
+			surface
+		});
+	} catch (cause) {
+		if ((cause instanceof TypeError || cause instanceof RangeError) && EXPECTED_CORE_OPTION_ERROR.test(cause.message)) throw invalidOptions(options, cause.message);
+		throw cause;
+	}
+	const normalizedStroke = stroke.trim();
+	const normalizedSurface = surface.trim();
+	if (!CSS.supports("color", normalizedStroke) || !CSS.supports("color", normalizedSurface)) throw invalidOptions(options, "paint must be supported CSS color syntax");
+	return Object.freeze({
+		seed: validationGeometry.seed,
+		family: validationGeometry.options.family,
+		generationVersion: validationGeometry.generationVersion,
+		density: validationGeometry.options.density,
+		curvature: validationGeometry.options.curvature,
+		stroke: normalizedStroke,
+		surface: normalizedSurface,
+		responsive
+	});
+};
+const normalizeFamilyControllerOptions = (options, fallbackSeed) => {
+	const optionRecord = assertV2OptionShape(options);
+	const responsive = ownValue(optionRecord, "responsive", true);
+	if (typeof responsive !== "boolean") throw invalidV2Options("responsive", ["responsive"], "responsive must be a boolean");
+	const generationVersion = ownValue(optionRecord, "generationVersion", 2);
+	if (generationVersion !== 2 && generationVersion !== 3) throw invalidV2Options("version", ["generationVersion"], "generationVersion must be 2 or 3");
+	const requestedFamily = ownValue(optionRecord, "family", "auto");
+	if (requestedFamily !== "auto" && !isGateFamily(requestedFamily)) throw invalidV2Options("family", ["family"], "family must be auto or a supported family");
+	const suppliedSeed = ownValue(optionRecord, "seed", void 0);
+	const defaultSeed = suppliedSeed === void 0 && fallbackSeed === void 0 ? createRandomSeed() : fallbackSeed;
+	const requestedSeed = suppliedSeed === void 0 ? defaultSeed : suppliedSeed;
+	if (!isGateSeed(requestedSeed)) throw invalidV2Options("seed", ["seed"], "seed must be a non-empty string or finite number");
+	const controls = [
+		["density", .55],
+		["curvature", .65],
+		["symmetry", 1],
+		["peakHeight", .35],
+		["sideComplexity", .5]
+	];
+	const normalizedControls = {
+		density: .55,
+		curvature: .65,
+		symmetry: 1,
+		peakHeight: .35,
+		sideComplexity: .5
+	};
+	for (const [key, fallback] of controls) {
+		const value = ownValue(optionRecord, key, fallback);
+		if (!isUnitControl(value)) throw invalidV2Options("value", [key], `${key} must be between 0 and 1 inclusive`);
+		normalizedControls[key] = value;
+	}
+	const requestedCrest = ownValue(optionRecord, "crest", void 0);
+	if (requestedCrest !== void 0 && ![
+		"spear",
+		"fleur",
+		"diamond",
+		"none"
+	].includes(requestedCrest)) throw invalidV2Options("crest", ["crest"], "crest must be a supported crest");
+	const generationOptions = {
+		generationVersion,
+		seed: requestedSeed,
+		family: requestedFamily,
+		density: normalizedControls.density,
+		curvature: normalizedControls.curvature,
+		symmetry: normalizedControls.symmetry,
+		peakHeight: normalizedControls.peakHeight,
+		sideComplexity: normalizedControls.sideComplexity,
+		...requestedCrest === void 0 ? {} : { crest: requestedCrest }
+	};
+	let validationGeometry;
+	try {
+		validationGeometry = generateGate({
+			width: 160,
+			height: 160
+		}, generationOptions);
+	} catch (cause) {
+		if (cause instanceof TypeError || cause instanceof RangeError) throw invalidV2Options("crest", ["crest"], cause.message);
+		throw cause;
+	}
+	if (requestedCrest !== void 0 && !isCompatibleCrest(validationGeometry.options.family, requestedCrest)) throw invalidV2Options("crest", ["crest"], `crest is incompatible with generation-v2 family ${validationGeometry.options.family}`);
+	const stroke = ownValue(optionRecord, "stroke", "currentColor");
+	const surface = ownValue(optionRecord, "surface", "transparent");
+	try {
+		renderGateSVG(validationGeometry, {
+			stroke,
+			surface
+		});
+	} catch (cause) {
+		if (cause instanceof TypeError || cause instanceof RangeError) {
+			const key = typeof stroke !== "string" || cause.message.startsWith("stroke") ? "stroke" : "surface";
+			throw invalidV2Options("paint", [key], cause.message);
+		}
+		throw cause;
+	}
+	const normalizedStroke = stroke.trim();
+	const normalizedSurface = surface.trim();
+	if (!CSS.supports("color", normalizedStroke)) throw invalidV2Options("paint", ["stroke"], "paint must be supported CSS color syntax");
+	if (!CSS.supports("color", normalizedSurface)) throw invalidV2Options("paint", ["surface"], "paint must be supported CSS color syntax");
+	return Object.freeze({
+		seed: validationGeometry.seed,
+		generationVersion,
+		family: requestedFamily,
+		density: validationGeometry.options.density,
+		curvature: validationGeometry.options.curvature,
+		symmetry: validationGeometry.options.symmetry,
+		peakHeight: validationGeometry.options.peakHeight,
+		sideComplexity: validationGeometry.options.sideComplexity,
+		crest: requestedCrest,
+		stroke: normalizedStroke,
+		surface: normalizedSurface,
+		responsive
+	});
+};
+const normalizeControllerOptions = (options, fallbackSeed, oracleVersion) => {
+	const optionRecord = options;
+	const version = oracleVersion ?? (options !== null && typeof options === "object" && !Array.isArray(options) && Object.hasOwn(optionRecord, "generationVersion") && (optionRecord.generationVersion === 2 || optionRecord.generationVersion === 3) ? optionRecord.generationVersion : 1);
+	return version === 2 || version === 3 ? normalizeFamilyControllerOptions(options, fallbackSeed) : normalizeV1ControllerOptions(options, fallbackSeed);
+};
+const mergeControllerOptions = (current, updates) => {
+	const updateRecord = updates;
+	const suppliedVersion = updates !== null && typeof updates === "object" && !Array.isArray(updates) && Object.hasOwn(updateRecord, "generationVersion") ? updateRecord.generationVersion : void 0;
+	const targetVersion = suppliedVersion === void 0 ? current.generationVersion : suppliedVersion;
+	if ((targetVersion === 1 ? 1 : current.generationVersion !== 1 || targetVersion === 2 || targetVersion === 3 ? 2 : 1) === 2) {
+		const checkedUpdates = assertV2OptionShape(updates);
+		const responsive = ownValue(checkedUpdates, "responsive", void 0);
+		if (responsive !== void 0 && typeof responsive !== "boolean") throw invalidV2Options("responsive", ["responsive"], "responsive must be a boolean");
+		if (targetVersion !== 2 && targetVersion !== 3) throw invalidV2Options("version", ["generationVersion"], "generationVersion must be 1, 2 or 3");
+	} else {
+		if (updates === null || typeof updates !== "object" || Array.isArray(updates)) throw invalidOptions(updates, "options must be a plain object");
+		assertV1OptionKeys(updateRecord);
+	}
+	const candidate = targetVersion === current.generationVersion ? { ...current } : Object.fromEntries([
+		"seed",
+		"family",
+		"density",
+		"curvature",
+		"stroke",
+		"surface",
+		"responsive",
+		...current.generationVersion !== 1 && (targetVersion === 2 || targetVersion === 3) ? [
+			"symmetry",
+			"peakHeight",
+			"sideComplexity",
+			"crest"
+		] : []
+	].map((key) => [key, current[key]]));
+	candidate.generationVersion = targetVersion;
+	for (const [key, value] of Object.entries(updates)) if (value !== void 0) candidate[key] = value;
+	return {
+		options: candidate,
+		version: targetVersion
+	};
+};
+const measuredBorderBox = (entry) => {
+	return entry.borderBoxSize[0];
+};
+const physicalBorderWidth = (style, side) => {
+	const value = Number.parseFloat(style.getPropertyValue(`border-${side}-width`));
+	return Number.isFinite(value) ? value : 0;
+};
+const physicalPadding = (style) => {
+	const read = (side) => {
+		const value = Number.parseFloat(style.getPropertyValue(`padding-${side}`));
+		return Number.isFinite(value) ? value : 0;
+	};
+	return {
+		top: read("top"),
+		right: read("right"),
+		bottom: read("bottom"),
+		left: read("left")
+	};
+};
+const hasRequiredPadding = (measured, required) => measured.top >= required.top && measured.right >= required.right && measured.bottom >= required.bottom && measured.left >= required.left;
+const supportsDimensions = (dimensions) => {
+	const { width, height } = dimensions;
+	const aspectRatio = width / height;
+	return Number.isFinite(width) && Number.isFinite(height) && width >= 160 && width <= 1600 && height >= 96 && height <= 1200 && aspectRatio >= .5 && aspectRatio <= 6;
+};
+const parseOverlay = (standaloneSvg) => {
+	const parsedRoot = new DOMParser().parseFromString(standaloneSvg, "image/svg+xml").documentElement;
+	if (parsedRoot.localName !== "svg" || parsedRoot.namespaceURI !== "http://www.w3.org/2000/svg") throw new Error("Gate Frame core returned an invalid SVG document");
+	return document.importNode(parsedRoot, true);
+};
+function gateFrame(targetValue, options = {}) {
+	let target;
+	if (typeof targetValue === "string") {
+		let resolvedTarget;
+		try {
+			resolvedTarget = document.querySelector(targetValue);
+		} catch (cause) {
+			if (cause instanceof DOMException && cause.name === "SyntaxError") throw new GateFrameInvalidSelectorError(targetValue);
+			throw cause;
+		}
+		if (resolvedTarget === null) throw new GateFrameTargetNotFoundError(targetValue);
+		if (!(resolvedTarget instanceof HTMLElement)) throw new GateFrameTargetNotHTMLElementError({
+			source: "selector",
+			selector: targetValue,
+			tagName: resolvedTarget.localName
+		});
+		target = resolvedTarget;
+	} else {
+		const directTarget = targetValue;
+		if (!(directTarget instanceof HTMLElement)) throw new GateFrameTargetNotHTMLElementError(directTarget instanceof Element ? {
+			source: "direct",
+			tagName: directTarget.localName
+		} : {
+			source: "direct",
+			valueType: directTarget === null ? "null" : typeof directTarget
+		});
+		target = directTarget;
+	}
+	if (mountedTargets.has(target)) throw new GateFrameAlreadyMountedError(target);
+	const initialStyle = getComputedStyle(target);
+	classifyTarget(target, initialStyle);
+	let currentOptions = normalizeControllerOptions(options);
+	const computedPosition = initialStyle.position || target.style.position || "static";
+	const previousPosition = target.style.getPropertyValue("position");
+	const previousPositionPriority = target.style.getPropertyPriority("position");
+	const ownsPosition = computedPosition === "static";
+	if (ownsPosition) {
+		const absoluteDescendant = Array.from(target.querySelectorAll("*")).find((descendant) => getComputedStyle(descendant).position === "absolute");
+		if (absoluteDescendant !== void 0) throw new GateFramePositioningConflictError(target, absoluteDescendant);
+		target.style.setProperty("position", "relative");
+	}
+	let seed = currentOptions.seed;
+	let paint = Object.freeze({
+		stroke: currentOptions.stroke,
+		surface: currentOptions.surface
+	});
+	let currentStatus = PENDING_STATUS;
+	let currentSnapshot = null;
+	let standaloneSvg = null;
+	let overlay = null;
+	let animationFrame = null;
+	let generation = 0;
+	let destroyed = false;
+	let destroyError = null;
+	let observing = false;
+	let observedBorderBoxDimensions = null;
+	let measuredDimensions = null;
+	const readyWaiters = [];
+	const hasNonzeroLayout = () => target.offsetWidth > 0 && target.offsetHeight > 0;
+	const invalidateMeasurement = () => {
+		if (destroyed) return;
+		measuredDimensions = null;
+		currentStatus = PENDING_STATUS;
+		generation += 1;
+		if (animationFrame !== null) {
+			cancelAnimationFrame(animationFrame);
+			animationFrame = null;
+		}
+	};
+	const publishRenderError = (error) => {
+		generation += 1;
+		if (animationFrame !== null) {
+			cancelAnimationFrame(animationFrame);
+			animationFrame = null;
+		}
+		overlay?.remove();
+		overlay = null;
+		currentStatus = Object.freeze({
+			state: "error",
+			error
+		});
+		for (const waiter of readyWaiters.splice(0)) waiter.reject(error);
+	};
+	const scheduleRender = () => {
+		if (destroyed || measuredDimensions === null) return;
+		currentStatus = PENDING_STATUS;
+		const token = ++generation;
+		if (animationFrame !== null) {
+			cancelAnimationFrame(animationFrame);
+			animationFrame = null;
+		}
+		const frameId = requestAnimationFrame(() => {
+			if (animationFrame === frameId) animationFrame = null;
+			if (destroyed || token !== generation || measuredDimensions === null) return;
+			if (!target.isConnected || !hasNonzeroLayout()) {
+				invalidateMeasurement();
+				return;
+			}
+			const style = getComputedStyle(target);
+			try {
+				classifyTarget(target, style);
+			} catch (cause) {
+				if (cause instanceof GateFrameUnsupportedTargetError) {
+					publishRenderError(cause);
+					return;
+				}
+				throw cause;
+			}
+			if (!supportsDimensions(measuredDimensions)) {
+				publishRenderError(new GateFrameUnsupportedDimensionsError(measuredDimensions));
+				return;
+			}
+			const generationOptions = currentOptions.generationVersion === 1 ? {
+				seed,
+				family: "courtyard",
+				generationVersion: 1,
+				density: currentOptions.density,
+				curvature: currentOptions.curvature
+			} : {
+				seed,
+				generationVersion: currentOptions.generationVersion,
+				family: currentOptions.family,
+				density: currentOptions.density,
+				curvature: currentOptions.curvature,
+				symmetry: currentOptions.symmetry,
+				peakHeight: currentOptions.peakHeight,
+				sideComplexity: currentOptions.sideComplexity,
+				...currentOptions.crest === void 0 ? {} : { crest: currentOptions.crest }
+			};
+			const geometry = generateGate(measuredDimensions, generationOptions);
+			const measuredPadding = physicalPadding(style);
+			if (!hasRequiredPadding(measuredPadding, geometry.contentInsets)) {
+				publishRenderError(new GateFrameInsufficientSpaceError(measuredPadding, geometry.contentInsets));
+				return;
+			}
+			const nextStandaloneSvg = renderGateSVG(geometry, paint);
+			const nextOverlay = parseOverlay(nextStandaloneSvg);
+			if (destroyed || token !== generation) return;
+			nextOverlay.setAttribute("data-gate-frame-overlay", "");
+			nextOverlay.setAttribute("aria-hidden", "true");
+			nextOverlay.setAttribute("focusable", "false");
+			nextOverlay.style.position = "absolute";
+			nextOverlay.style.inset = "0";
+			nextOverlay.style.width = "100%";
+			nextOverlay.style.height = "100%";
+			nextOverlay.style.pointerEvents = "none";
+			const nextSnapshot = geometry.generationVersion === 1 ? Object.freeze({
+				seed: geometry.seed,
+				generationVersion: 1,
+				geometry,
+				paint
+			}) : geometry.generationVersion === 2 ? Object.freeze({
+				seed: geometry.seed,
+				generationVersion: 2,
+				geometry,
+				paint
+			}) : Object.freeze({
+				seed: geometry.seed,
+				generationVersion: 3,
+				geometry,
+				paint
+			});
+			if (overlay === null) target.append(nextOverlay);
+			else overlay.replaceWith(nextOverlay);
+			if (currentOptions.responsive === false && observing) {
+				observer.disconnect();
+				observing = false;
+			}
+			overlay = nextOverlay;
+			standaloneSvg = nextStandaloneSvg;
+			currentSnapshot = nextSnapshot;
+			currentStatus = Object.freeze({
+				state: "ready",
+				snapshot: nextSnapshot
+			});
+			for (const waiter of readyWaiters.splice(0)) waiter.resolve(nextSnapshot);
+		});
+		animationFrame = frameId;
+	};
+	const observer = new ResizeObserver((entries) => {
+		const entry = entries.find((candidate) => candidate.target === target);
+		const borderBox = entry === void 0 ? void 0 : measuredBorderBox(entry);
+		if (borderBox === void 0 || !target.isConnected || !hasNonzeroLayout()) {
+			invalidateMeasurement();
+			return;
+		}
+		const style = getComputedStyle(target);
+		observedBorderBoxDimensions = {
+			width: borderBox.inlineSize,
+			height: borderBox.blockSize
+		};
+		const width = observedBorderBoxDimensions.width - physicalBorderWidth(style, "left") - physicalBorderWidth(style, "right");
+		const height = observedBorderBoxDimensions.height - physicalBorderWidth(style, "top") - physicalBorderWidth(style, "bottom");
+		if (width <= 0 || height <= 0) {
+			invalidateMeasurement();
+			return;
+		}
+		const measurementChanged = measuredDimensions?.width !== width || measuredDimensions.height !== height;
+		measuredDimensions = {
+			width,
+			height
+		};
+		try {
+			classifyTarget(target, style);
+		} catch (cause) {
+			if (cause instanceof GateFrameUnsupportedTargetError) {
+				publishRenderError(cause);
+				return;
+			}
+			throw cause;
+		}
+		if (!measurementChanged) return;
+		scheduleRender();
+	});
+	const controller = {
+		status: () => currentStatus,
+		whenReady: () => {
+			if (destroyed) return Promise.reject(destroyError ?? new GateFrameDestroyedError());
+			if (currentStatus.state === "ready") return Promise.resolve(currentStatus.snapshot);
+			if (currentStatus.state === "error") return Promise.reject(currentStatus.error);
+			return new Promise((resolve, reject) => readyWaiters.push({
+				resolve,
+				reject
+			}));
+		},
+		update: (nextOptions) => {
+			if (destroyed) throw destroyError ?? new GateFrameDestroyedError();
+			const merged = mergeControllerOptions(currentOptions, nextOptions);
+			const candidateOptions = normalizeControllerOptions(merged.options, currentOptions.seed, merged.version);
+			if (observedBorderBoxDimensions !== null) {
+				const style = getComputedStyle(target);
+				const width = observedBorderBoxDimensions.width - physicalBorderWidth(style, "left") - physicalBorderWidth(style, "right");
+				const height = observedBorderBoxDimensions.height - physicalBorderWidth(style, "top") - physicalBorderWidth(style, "bottom");
+				if (width <= 0 || height <= 0) invalidateMeasurement();
+				else measuredDimensions = {
+					width,
+					height
+				};
+			}
+			const wasResponsive = currentOptions.responsive !== false;
+			currentOptions = candidateOptions;
+			seed = candidateOptions.seed;
+			paint = Object.freeze({
+				stroke: currentOptions.stroke,
+				surface: currentOptions.surface
+			});
+			if (wasResponsive === false && currentOptions.responsive !== false && !observing) {
+				observer.observe(target, { box: "border-box" });
+				observing = true;
+			}
+			scheduleRender();
+			return controller;
+		},
+		randomize: (explicitSeed) => {
+			if (destroyed) throw destroyError ?? new GateFrameDestroyedError();
+			const requestedSeed = explicitSeed === void 0 ? createRandomSeed() : explicitSeed;
+			const merged = mergeControllerOptions(currentOptions, { seed: requestedSeed });
+			const candidateOptions = normalizeControllerOptions(merged.options, currentOptions.seed, merged.version);
+			currentOptions = candidateOptions;
+			seed = candidateOptions.seed;
+			scheduleRender();
+			return seed;
+		},
+		snapshot: () => {
+			if (destroyed) throw destroyError ?? new GateFrameDestroyedError();
+			return currentSnapshot;
+		},
+		toSVG: () => {
+			if (destroyed) throw destroyError ?? new GateFrameDestroyedError();
+			if (standaloneSvg === null) throw new GateFrameNotReadyError();
+			return standaloneSvg;
+		},
+		destroy: () => {
+			if (destroyed) return;
+			destroyed = true;
+			destroyError = new GateFrameDestroyedError();
+			generation += 1;
+			if (animationFrame !== null) {
+				cancelAnimationFrame(animationFrame);
+				animationFrame = null;
+			}
+			observer.disconnect();
+			observing = false;
+			overlay?.remove();
+			overlay = null;
+			for (const waiter of readyWaiters.splice(0)) waiter.reject(destroyError);
+			if (ownsPosition && target.style.getPropertyValue("position") === "relative" && target.style.getPropertyPriority("position") === "") {
+				if (previousPosition === "") target.style.removeProperty("position");
+				else target.style.setProperty("position", previousPosition, previousPositionPriority);
+			}
+			mountedTargets.delete(target);
+			currentSnapshot = null;
+			standaloneSvg = null;
+			currentStatus = DESTROYED_STATUS;
+		}
+	};
+	mountedTargets.set(target, controller);
+	observer.observe(target, { box: "border-box" });
+	observing = true;
+	return controller;
+}
+
+//#endregion
+export { GateFrameAlreadyMountedError, GateFrameDestroyedError, GateFrameError, GateFrameInsufficientSpaceError, GateFrameInvalidOptionsError, GateFrameInvalidSelectorError, GateFrameNotReadyError, GateFramePositioningConflictError, GateFrameTargetNotFoundError, GateFrameTargetNotHTMLElementError, GateFrameUnsupportedDimensionsError, GateFrameUnsupportedTargetError, gateFrame };
+//# sourceMappingURL=index.js.map