@fluid-app/widget-runtime 0.1.0

package/dist/remote-dom-renderer-DUQf80Nu.cjs

@@ -0,0 +1,2116 @@
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+const require_Thread = require("./Thread-0eUyc0Hw.cjs");
+const require_remote_dom_values = require("./remote-dom-values-DbgIedSg.cjs");
+let _remote_dom_core = require("@remote-dom/core");
+let _remote_dom_core_elements = require("@remote-dom/core/elements");
+let _remote_dom_core_receivers = require("@remote-dom/core/receivers");
+let postcss_lib_parse = require("postcss/lib/parse");
+postcss_lib_parse = __toESM(postcss_lib_parse);
+let postcss_value_parser = require("postcss-value-parser");
+postcss_value_parser = __toESM(postcss_value_parser);
+//#region src/remote-dom-sanitizer.ts
+const REMOTE_DOM_DENIED_TAG_NAMES = new Set([
+	"applet",
+	"base",
+	"body",
+	"embed",
+	"frame",
+	"frameset",
+	"head",
+	"html",
+	"iframe",
+	"link",
+	"meta",
+	"noscript",
+	"object",
+	"portal",
+	"script",
+	"slot",
+	"style",
+	"template",
+	"title"
+]);
+const REMOTE_DOM_ALLOWED_TAG_NAME_SET = new Set(require_remote_dom_values.REMOTE_DOM_ALLOWED_TAG_NAMES);
+const GLOBAL_ALLOWED_ATTRIBUTES = new Set([
+	"aria-activedescendant",
+	"aria-atomic",
+	"aria-autocomplete",
+	"aria-braillelabel",
+	"aria-brailleroledescription",
+	"aria-busy",
+	"aria-checked",
+	"aria-colcount",
+	"aria-colindex",
+	"aria-colindextext",
+	"aria-colspan",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"aria-description",
+	"aria-details",
+	"aria-disabled",
+	"aria-errormessage",
+	"aria-expanded",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-keyshortcuts",
+	"aria-label",
+	"aria-labelledby",
+	"aria-level",
+	"aria-live",
+	"aria-modal",
+	"aria-multiline",
+	"aria-multiselectable",
+	"aria-orientation",
+	"aria-owns",
+	"aria-placeholder",
+	"aria-posinset",
+	"aria-pressed",
+	"aria-readonly",
+	"aria-required",
+	"aria-roledescription",
+	"aria-rowcount",
+	"aria-rowindex",
+	"aria-rowindextext",
+	"aria-rowspan",
+	"aria-selected",
+	"aria-setsize",
+	"aria-sort",
+	"aria-valuemax",
+	"aria-valuemin",
+	"aria-valuenow",
+	"aria-valuetext",
+	"class",
+	"dir",
+	"hidden",
+	"id",
+	"inert",
+	"lang",
+	"role",
+	"tabindex",
+	"title",
+	"translate"
+]);
+const TAG_ALLOWED_ATTRIBUTES = {
+	a: new Set([
+		"download",
+		"href",
+		"hreflang",
+		"rel",
+		"target",
+		"type"
+	]),
+	audio: new Set([
+		"autoplay",
+		"controls",
+		"loop",
+		"muted",
+		"preload",
+		"src"
+	]),
+	blockquote: new Set(["cite"]),
+	button: new Set([
+		"disabled",
+		"name",
+		"type",
+		"value"
+	]),
+	col: new Set(["span"]),
+	colgroup: new Set(["span"]),
+	data: new Set(["value"]),
+	del: new Set(["cite", "datetime"]),
+	details: new Set(["open"]),
+	dialog: new Set(["open"]),
+	form: new Set(["autocomplete", "name"]),
+	img: new Set([
+		"alt",
+		"decoding",
+		"height",
+		"loading",
+		"src",
+		"width"
+	]),
+	input: new Set([
+		"accept",
+		"autocomplete",
+		"checked",
+		"disabled",
+		"max",
+		"maxlength",
+		"min",
+		"minlength",
+		"name",
+		"pattern",
+		"placeholder",
+		"readonly",
+		"required",
+		"step",
+		"type",
+		"value"
+	]),
+	ins: new Set(["cite", "datetime"]),
+	label: new Set(["for"]),
+	meter: new Set([
+		"high",
+		"low",
+		"max",
+		"min",
+		"optimum",
+		"value"
+	]),
+	optgroup: new Set(["disabled", "label"]),
+	option: new Set([
+		"disabled",
+		"label",
+		"selected",
+		"value"
+	]),
+	output: new Set(["for", "name"]),
+	progress: new Set(["max", "value"]),
+	q: new Set(["cite"]),
+	select: new Set([
+		"autocomplete",
+		"disabled",
+		"multiple",
+		"name",
+		"required",
+		"size"
+	]),
+	source: new Set([
+		"height",
+		"media",
+		"sizes",
+		"src",
+		"type",
+		"width"
+	]),
+	td: new Set([
+		"colspan",
+		"headers",
+		"rowspan"
+	]),
+	textarea: new Set([
+		"autocomplete",
+		"cols",
+		"disabled",
+		"maxlength",
+		"minlength",
+		"name",
+		"placeholder",
+		"readonly",
+		"required",
+		"rows",
+		"value",
+		"wrap"
+	]),
+	th: new Set([
+		"abbr",
+		"colspan",
+		"headers",
+		"rowspan",
+		"scope"
+	]),
+	time: new Set(["datetime"]),
+	track: new Set([
+		"default",
+		"kind",
+		"label",
+		"src",
+		"srclang"
+	]),
+	video: new Set([
+		"autoplay",
+		"controls",
+		"height",
+		"loop",
+		"muted",
+		"playsinline",
+		"poster",
+		"preload",
+		"src",
+		"width"
+	])
+};
+const BOOLEAN_ATTRIBUTES = new Set([
+	"autoplay",
+	"checked",
+	"controls",
+	"default",
+	"disabled",
+	"hidden",
+	"inert",
+	"loop",
+	"multiple",
+	"muted",
+	"open",
+	"playsinline",
+	"readonly",
+	"required",
+	"selected"
+]);
+const SAFE_INPUT_TYPES = new Set([
+	"button",
+	"checkbox",
+	"color",
+	"date",
+	"datetime-local",
+	"email",
+	"file",
+	"hidden",
+	"month",
+	"number",
+	"password",
+	"radio",
+	"range",
+	"reset",
+	"search",
+	"submit",
+	"tel",
+	"text",
+	"time",
+	"url",
+	"week"
+]);
+const SAFE_BUTTON_TYPES = new Set([
+	"button",
+	"reset",
+	"submit"
+]);
+const SAFE_LOADING_VALUES = new Set(["eager", "lazy"]);
+const SAFE_DECODING_VALUES = new Set([
+	"async",
+	"auto",
+	"sync"
+]);
+const SAFE_PRELOAD_VALUES = new Set([
+	"auto",
+	"metadata",
+	"none"
+]);
+const SAFE_TRACK_KIND_VALUES = new Set([
+	"captions",
+	"chapters",
+	"descriptions",
+	"metadata",
+	"subtitles"
+]);
+const URL_VALUED_ATTRIBUTES = new Set([
+	"cite",
+	"href",
+	"poster",
+	"src"
+]);
+const MEDIA_SOURCE_TAGS = new Set([
+	"audio",
+	"img",
+	"source",
+	"track",
+	"video"
+]);
+const SUPPORTED_REMOTE_DOM_EVENT_SET = new Set(require_remote_dom_values.SUPPORTED_REMOTE_DOM_EVENTS);
+const REMOTE_DOM_SEARCH_SORT_EVENT_SET = new Set(require_remote_dom_values.REMOTE_DOM_SEARCH_SORT_EVENTS);
+function sanitizeRemoteDomTagName(tagName) {
+	if (typeof tagName !== "string") return void 0;
+	const normalizedTagName = tagName.trim().toLowerCase();
+	if (normalizedTagName.length === 0 || REMOTE_DOM_DENIED_TAG_NAMES.has(normalizedTagName) || !REMOTE_DOM_ALLOWED_TAG_NAME_SET.has(normalizedTagName)) return;
+	return normalizedTagName;
+}
+function sanitizeRemoteDomAttributes(tagName, attributes, options = {}) {
+	if (!isObjectRecord$1(attributes)) return [];
+	const sanitizedAttributes = [];
+	for (const [rawName, rawValue] of Object.entries(attributes)) {
+		const attribute = sanitizeRemoteDomAttribute(tagName, rawName, rawValue, options);
+		if (attribute) sanitizedAttributes.push(attribute);
+	}
+	return sanitizedAttributes;
+}
+function sanitizeRemoteDomProperty(tagName, rawName, rawValue) {
+	if (typeof rawName !== "string") return void 0;
+	const normalizedTagName = tagName.trim().toLowerCase();
+	const name = rawName.trim().toLowerCase();
+	if (!require_remote_dom_values.isSafeRemoteDomPropertyKey(name)) return;
+	if (normalizedTagName === "input") {
+		if (name === "checked" && typeof rawValue === "boolean") return {
+			name,
+			value: rawValue
+		};
+		if (name === "value" && typeof rawValue === "string") return {
+			name,
+			value: rawValue
+		};
+	}
+	if (normalizedTagName === "fluid-ui-search-sort") {
+		if (name === "searchvalue" && typeof rawValue === "string") return {
+			name: "searchValue",
+			value: rawValue
+		};
+		if (name === "placeholder") return typeof rawValue === "string" || rawValue === void 0 ? {
+			name: "placeholder",
+			value: rawValue
+		} : void 0;
+		if (name === "sortoptions") {
+			const value = sanitizeSearchSortOptions(rawValue);
+			return value === void 0 && rawValue !== void 0 ? void 0 : {
+				name: "sortOptions",
+				value
+			};
+		}
+		if (name === "sortvalue") return typeof rawValue === "string" || rawValue === void 0 ? {
+			name: "sortValue",
+			value: rawValue
+		} : void 0;
+	}
+	if (normalizedTagName === "fluid-spacer-widget") {
+		if (name === "customheight") return typeof rawValue === "string" || rawValue === void 0 ? {
+			name: "customHeight",
+			value: rawValue
+		} : void 0;
+		if (name === "previewmode" && typeof rawValue === "boolean") return {
+			name: "previewMode",
+			value: rawValue
+		};
+	}
+}
+function isRemoteDomPropertyName(tagName, rawName) {
+	const normalizedTagName = tagName.trim().toLowerCase();
+	const name = rawName.trim().toLowerCase();
+	if (normalizedTagName === "input") return name === "checked" || name === "value";
+	if (normalizedTagName === "fluid-ui-search-sort") return name === "searchvalue" || name === "placeholder" || name === "sortoptions" || name === "sortvalue";
+	if (normalizedTagName === "fluid-spacer-widget") return name === "customheight" || name === "previewmode";
+	return false;
+}
+function sanitizeRemoteDomAttribute(tagName, rawName, rawValue, options = {}) {
+	if (typeof rawName !== "string") return void 0;
+	const normalizedTagName = tagName.trim().toLowerCase();
+	const name = rawName.trim().toLowerCase();
+	if (!require_remote_dom_values.isSafeRemoteDomPropertyKey(name)) return void 0;
+	if (!isAllowedAttributeName(normalizedTagName, name)) return void 0;
+	if (name === "type" && normalizedTagName === "input") {
+		const value = stringifyAttributeValue(rawValue).toLowerCase();
+		return SAFE_INPUT_TYPES.has(value) ? {
+			name,
+			value
+		} : void 0;
+	}
+	if (name === "type" && normalizedTagName === "button") {
+		const value = stringifyAttributeValue(rawValue).toLowerCase();
+		return SAFE_BUTTON_TYPES.has(value) ? {
+			name,
+			value
+		} : void 0;
+	}
+	if (URL_VALUED_ATTRIBUTES.has(name)) {
+		const value = sanitizeUrlValuedAttribute(normalizedTagName, name, rawValue, options.urlOriginPolicy);
+		return value ? {
+			name,
+			value
+		} : void 0;
+	}
+	if (name === "target") {
+		const value = stringifyAttributeValue(rawValue);
+		return value === "_blank" || value === "_self" ? {
+			name,
+			value
+		} : void 0;
+	}
+	if (name === "rel") {
+		const value = sanitizeTokenList(rawValue);
+		return value.length > 0 ? {
+			name,
+			value
+		} : void 0;
+	}
+	if (name === "loading") return sanitizeEnumAttribute(name, rawValue, SAFE_LOADING_VALUES);
+	if (name === "decoding") return sanitizeEnumAttribute(name, rawValue, SAFE_DECODING_VALUES);
+	if (name === "preload") return sanitizeEnumAttribute(name, rawValue, SAFE_PRELOAD_VALUES);
+	if (name === "kind" && normalizedTagName === "track") return sanitizeEnumAttribute(name, rawValue, SAFE_TRACK_KIND_VALUES);
+	if (BOOLEAN_ATTRIBUTES.has(name)) return rawValue === true || rawValue === "" || rawValue === name ? {
+		name,
+		value: ""
+	} : void 0;
+	const value = stringifyAttributeValue(rawValue);
+	if (value.length === 0 && rawValue !== "") return void 0;
+	const sanitizedValue = sanitizeCssComponentValueUrlReferences(value, options.urlOriginPolicy);
+	if (sanitizedValue === void 0) return;
+	return {
+		name,
+		value: sanitizedValue
+	};
+}
+function sanitizeRemoteDomUrl(value, options) {
+	if (typeof value !== "string") return void 0;
+	const trimmedValue = value.trim();
+	if (trimmedValue.length === 0 || trimmedValue !== value || hasControlCharacter(trimmedValue) || trimmedValue.includes("\\") || trimmedValue.startsWith("//")) return;
+	if (trimmedValue.startsWith("#")) return options.allowHashOnly === true ? trimmedValue : void 0;
+	if (isRelativeUrl(trimmedValue)) {
+		if (!options.allowRelative) return void 0;
+		const parsedRelativeUrl = resolveRemoteDomRelativeUrl(trimmedValue, options.originPolicy, options.relativeUrlBase ?? "artifact");
+		if (!parsedRelativeUrl) return void 0;
+		return isAllowedHttpOrigin(parsedRelativeUrl.origin, options.originPolicy, options.allowedHttpOriginGroups ?? []) ? parsedRelativeUrl.href : void 0;
+	}
+	let parsedUrl;
+	try {
+		parsedUrl = new URL(trimmedValue);
+	} catch {
+		return;
+	}
+	if (parsedUrl.protocol === "http:" || parsedUrl.protocol === "https:") return isAllowedHttpOrigin(parsedUrl.origin, options.originPolicy, options.allowedHttpOriginGroups ?? []) ? trimmedValue : void 0;
+	if (options.allowMailTo && parsedUrl.protocol === "mailto:") return trimmedValue;
+	if (options.allowTel && parsedUrl.protocol === "tel:") return trimmedValue;
+}
+function sanitizeRemoteDomCssUrlReferences(value, options = {}) {
+	if (typeof value !== "string") return void 0;
+	return sanitizeCssTextUrlReferences(value, options.urlOriginPolicy);
+}
+function isSupportedRemoteDomEventName(eventName, tagName) {
+	if (SUPPORTED_REMOTE_DOM_EVENT_SET.has(eventName)) return true;
+	return tagName?.trim().toLowerCase() === "fluid-ui-search-sort" && REMOTE_DOM_SEARCH_SORT_EVENT_SET.has(eventName);
+}
+function serializeRemoteDomEvent(event, targetId, currentTargetId, currentTargetTagName) {
+	if (!isSupportedRemoteDomEventName(event.type, currentTargetTagName)) return;
+	const inputState = readInputState(event.target);
+	return {
+		type: event.type,
+		targetId,
+		currentTargetId,
+		bubbles: event.bubbles,
+		cancelable: event.cancelable,
+		defaultPrevented: event.defaultPrevented,
+		...inputState,
+		...readKeyboardState(event),
+		...readPointerState(event),
+		...readMouseState(event),
+		...readCustomEventDetail(event)
+	};
+}
+function sanitizeSearchSortOptions(value) {
+	if (!Array.isArray(value)) return void 0;
+	const options = [];
+	for (const option of value) {
+		if (!isObjectRecord$1(option) || typeof option.label !== "string" || typeof option.value !== "string") return;
+		options.push({
+			label: option.label,
+			value: option.value
+		});
+	}
+	return options;
+}
+function readCustomEventDetail(event) {
+	if (!(event instanceof CustomEvent) || !REMOTE_DOM_SEARCH_SORT_EVENT_SET.has(event.type)) return {};
+	if (!require_remote_dom_values.isRemoteDomSerializableValue(event.detail)) return {};
+	try {
+		const detailJson = JSON.stringify(event.detail);
+		return typeof detailJson === "string" ? { detailJson } : {};
+	} catch {
+		return {};
+	}
+}
+function sanitizeUrlValuedAttribute(tagName, name, value, originPolicy) {
+	if (name === "href") return sanitizeRemoteDomUrl(value, {
+		allowHashOnly: true,
+		allowMailTo: true,
+		allowRelative: true,
+		allowTel: true,
+		allowedHttpOriginGroups: [
+			"artifact",
+			"media",
+			"navigation"
+		],
+		originPolicy,
+		relativeUrlBase: "navigation"
+	});
+	if (name === "src" && MEDIA_SOURCE_TAGS.has(tagName)) return sanitizeRemoteDomUrl(value, {
+		allowHashOnly: false,
+		allowMailTo: false,
+		allowRelative: true,
+		allowTel: false,
+		allowedHttpOriginGroups: ["artifact", "media"],
+		originPolicy,
+		relativeUrlBase: "artifact"
+	});
+	if (name === "poster" && tagName === "video") return sanitizeRemoteDomUrl(value, {
+		allowHashOnly: false,
+		allowMailTo: false,
+		allowRelative: true,
+		allowTel: false,
+		allowedHttpOriginGroups: ["artifact", "media"],
+		originPolicy,
+		relativeUrlBase: "artifact"
+	});
+	return sanitizeRemoteDomUrl(value, {
+		allowHashOnly: false,
+		allowMailTo: false,
+		allowRelative: true,
+		allowTel: false,
+		allowedHttpOriginGroups: ["artifact", "media"],
+		originPolicy,
+		relativeUrlBase: "artifact"
+	});
+}
+function sanitizeEnumAttribute(name, rawValue, safeValues) {
+	const value = stringifyAttributeValue(rawValue).toLowerCase();
+	return safeValues.has(value) ? {
+		name,
+		value
+	} : void 0;
+}
+function hasControlCharacter(value) {
+	for (let index = 0; index < value.length; index += 1) {
+		const codePoint = value.charCodeAt(index);
+		if (codePoint < 32 || codePoint >= 127 && codePoint <= 159) return true;
+	}
+	return false;
+}
+function isAllowedAttributeName(tagName, name) {
+	if (name.length === 0 || name.startsWith("on") || name === "style" || name === "srcdoc" || name.includes(":") || !/^[a-z][a-z0-9_.-]*$/u.test(name)) return false;
+	if (name.startsWith("data-")) return true;
+	if (GLOBAL_ALLOWED_ATTRIBUTES.has(name)) return true;
+	return TAG_ALLOWED_ATTRIBUTES[tagName]?.has(name) === true;
+}
+function stringifyAttributeValue(value) {
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "boolean") return String(value);
+	return "";
+}
+function sanitizeTokenList(value) {
+	return stringifyAttributeValue(value).split(/\s+/u).filter((token) => /^[a-z0-9_-]+$/iu.test(token)).join(" ");
+}
+function escapeCssString(value) {
+	return value.replace(/\\/gu, "\\\\").replace(/"/gu, "\\\"");
+}
+const CSS_URL_FUNCTION_NAME = "url";
+const CSS_IMPORT_RULE_NAME = "import";
+const CSS_REJECTED_URL_FUNCTION_NAMES = new Set(["image-set", "-webkit-image-set"]);
+function sanitizeCssTextUrlReferences(cssText, originPolicy) {
+	let stylesheet;
+	try {
+		stylesheet = (0, postcss_lib_parse.default)(cssText);
+	} catch {
+		return;
+	}
+	let valid = true;
+	stylesheet.walkAtRules((atRule) => {
+		if (!valid) return;
+		const decodedName = decodeCssEscapes(atRule.name)?.toLowerCase();
+		if (!decodedName) {
+			valid = false;
+			return;
+		}
+		const sanitizedParams = decodedName === CSS_IMPORT_RULE_NAME ? sanitizeCssImportParameters(atRule.params, originPolicy) : sanitizeCssComponentValueUrlReferences(atRule.params, originPolicy);
+		if (sanitizedParams === void 0) {
+			valid = false;
+			return;
+		}
+		if (decodedName === CSS_IMPORT_RULE_NAME) atRule.name = decodedName;
+		atRule.params = sanitizedParams;
+	});
+	stylesheet.walkDecls((declaration) => {
+		if (!valid) return;
+		const sanitizedValue = sanitizeCssComponentValueUrlReferences(declaration.value, originPolicy);
+		if (sanitizedValue === void 0) {
+			valid = false;
+			return;
+		}
+		declaration.value = sanitizedValue;
+	});
+	return valid ? stylesheet.toString() : void 0;
+}
+function sanitizeCssImportParameters(params, originPolicy) {
+	const parsed = (0, postcss_value_parser.default)(params);
+	const firstToken = parsed.nodes.find((node) => node.type !== "space" && node.type !== "comment");
+	if (!firstToken) return void 0;
+	if (firstToken.type === "string") {
+		const decodedUrl = decodeCssEscapes(firstToken.value);
+		const sanitizedUrl = decodedUrl === void 0 ? void 0 : sanitizeCssUrlToken(decodedUrl, originPolicy);
+		if (!sanitizedUrl) return void 0;
+		firstToken.quote = "\"";
+		firstToken.value = escapeCssString(sanitizedUrl);
+	} else if (firstToken.type !== "function" || decodeCssEscapes(firstToken.value)?.toLowerCase() !== CSS_URL_FUNCTION_NAME) return;
+	return sanitizeParsedCssValue(parsed.nodes, originPolicy) ? postcss_value_parser.default.stringify(parsed.nodes) : void 0;
+}
+function sanitizeCssComponentValueUrlReferences(cssValue, originPolicy) {
+	const parsed = (0, postcss_value_parser.default)(cssValue);
+	return sanitizeParsedCssValue(parsed.nodes, originPolicy) ? postcss_value_parser.default.stringify(parsed.nodes) : void 0;
+}
+function sanitizeParsedCssValue(nodes, originPolicy) {
+	for (const node of nodes) {
+		if ("unclosed" in node && node.unclosed === true) return false;
+		if (node.type !== "function") continue;
+		const decodedFunctionName = decodeCssEscapes(node.value);
+		if (decodedFunctionName === void 0) return false;
+		const functionName = decodedFunctionName.toLowerCase();
+		if (CSS_REJECTED_URL_FUNCTION_NAMES.has(functionName)) return false;
+		if (functionName === CSS_URL_FUNCTION_NAME) {
+			if (!sanitizeCssUrlFunctionNode(node, originPolicy)) return false;
+			continue;
+		}
+		if (!sanitizeParsedCssValue(node.nodes, originPolicy)) return false;
+	}
+	return true;
+}
+function sanitizeCssUrlFunctionNode(node, originPolicy) {
+	const tokens = node.nodes.filter((child) => child.type !== "space" && child.type !== "comment");
+	if (tokens.length !== 1) return false;
+	const token = tokens[0];
+	if (!token || token.type !== "word" && token.type !== "string") return false;
+	if ("unclosed" in token && token.unclosed === true) return false;
+	const decodedUrl = decodeCssEscapes(token.value);
+	const sanitizedUrl = decodedUrl === void 0 ? void 0 : sanitizeCssUrlToken(decodedUrl, originPolicy);
+	if (!sanitizedUrl) return false;
+	node.value = CSS_URL_FUNCTION_NAME;
+	node.before = "";
+	node.after = "";
+	node.nodes = [{
+		type: "string",
+		quote: "\"",
+		value: escapeCssString(sanitizedUrl),
+		sourceIndex: token.sourceIndex,
+		sourceEndIndex: token.sourceEndIndex
+	}];
+	return true;
+}
+/** Decodes CSS escapes after the maintained parser has identified a token. */
+function decodeCssEscapes(value) {
+	let decoded = "";
+	for (let index = 0; index < value.length; index += 1) {
+		const codeUnit = value[index];
+		if (codeUnit !== "\\") {
+			decoded += codeUnit;
+			continue;
+		}
+		index += 1;
+		const escaped = value[index];
+		if (escaped === void 0 || escaped === "\n" || escaped === "\r" || escaped === "\f") return;
+		if (!/^[0-9a-f]$/iu.test(escaped)) {
+			decoded += escaped;
+			continue;
+		}
+		const hexStart = index;
+		while (index + 1 < value.length && index + 1 - hexStart < 6 && /^[0-9a-f]$/iu.test(value[index + 1] ?? "")) index += 1;
+		const codePoint = Number.parseInt(value.slice(hexStart, index + 1), 16);
+		decoded += codePoint === 0 || codePoint > 1114111 || codePoint >= 55296 && codePoint <= 57343 ? "�" : String.fromCodePoint(codePoint);
+		if (/^[ \n\r\t\f]$/u.test(value[index + 1] ?? "")) index += 1;
+	}
+	return decoded;
+}
+function sanitizeCssUrlToken(rawUrl, originPolicy) {
+	return sanitizeRemoteDomUrl(rawUrl.trim().replace(/^(["'])(.*)\1$/u, "$2"), {
+		allowHashOnly: false,
+		allowMailTo: false,
+		allowRelative: true,
+		allowTel: false,
+		allowedHttpOriginGroups: ["artifact", "media"],
+		originPolicy,
+		relativeUrlBase: "artifact"
+	});
+}
+function resolveRemoteDomRelativeUrl(value, originPolicy, base) {
+	const baseUrl = base === "navigation" ? originPolicy?.navigationOrigin : originPolicy?.artifactBaseUrl;
+	if (!baseUrl) return void 0;
+	try {
+		const resolvedUrl = new URL(value, baseUrl);
+		return resolvedUrl.protocol === "http:" || resolvedUrl.protocol === "https:" ? resolvedUrl : void 0;
+	} catch {
+		return;
+	}
+}
+function isAllowedHttpOrigin(origin, originPolicy, allowedGroups) {
+	if (allowedGroups.length === 0 || !originPolicy) return false;
+	for (const group of allowedGroups) {
+		if (group === "artifact" && originPolicy.artifactOrigins.includes(origin)) return true;
+		if (group === "media" && originPolicy.mediaOrigins.includes(origin)) return true;
+		if (group === "navigation" && originPolicy.navigationOrigin === origin) return true;
+	}
+	return false;
+}
+function isRelativeUrl(value) {
+	return !/^[a-z][a-z0-9+.-]*:/iu.test(value);
+}
+function readInputState(target) {
+	if (target instanceof HTMLInputElement || target instanceof HTMLTextAreaElement || target instanceof HTMLSelectElement) {
+		const inputState = { value: target.value };
+		if (target instanceof HTMLInputElement) inputState.checked = target.checked;
+		return inputState;
+	}
+	return {};
+}
+function readKeyboardState(event) {
+	if (!(event instanceof KeyboardEvent)) return {};
+	return {
+		altKey: event.altKey,
+		code: event.code,
+		ctrlKey: event.ctrlKey,
+		key: event.key,
+		metaKey: event.metaKey,
+		shiftKey: event.shiftKey
+	};
+}
+function readMouseState(event) {
+	if (!(event instanceof MouseEvent)) return {};
+	return {
+		altKey: event.altKey,
+		button: event.button,
+		buttons: event.buttons,
+		clientX: event.clientX,
+		clientY: event.clientY,
+		ctrlKey: event.ctrlKey,
+		metaKey: event.metaKey,
+		shiftKey: event.shiftKey
+	};
+}
+function readPointerState(event) {
+	if (!isObjectRecord$1(event) || typeof PointerEvent === "undefined") return {};
+	if (!(event instanceof PointerEvent)) return {};
+	return {
+		isPrimary: event.isPrimary,
+		pointerId: event.pointerId,
+		pointerType: event.pointerType
+	};
+}
+function isObjectRecord$1(value) {
+	return typeof value === "object" && value !== null;
+}
+//#endregion
+//#region src/remote-dom-sanitizing-connection.ts
+var RemoteDomConnectionCallDeniedError = class extends Error {
+	constructor(method) {
+		super(`Remote DOM element method "${method}" was blocked; host method calls are denied.`);
+		this.name = "RemoteDomConnectionCallDeniedError";
+	}
+};
+function createSanitizingRemoteConnection(options) {
+	const state = { nodes: new Map([[_remote_dom_core.ROOT_ID, {
+		kind: "element",
+		localName: "",
+		childIds: []
+	}]]) };
+	function reset() {
+		state.nodes.clear();
+		state.nodes.set(_remote_dom_core.ROOT_ID, {
+			kind: "element",
+			localName: "",
+			childIds: []
+		});
+	}
+	function mutate(records) {
+		if (records.length > options.maxMutationBatchSize) {
+			options.onInvalidRecord?.("Remote DOM mutation batch exceeded maxMutationBatchSize");
+			return;
+		}
+		const normalizedRecords = [];
+		const pendingEventListenerUpdates = [];
+		const workingState = cloneSanitizingState(state);
+		for (const rawRecord of records) {
+			const record = parseRemoteMutationRecord(rawRecord);
+			if (!record) {
+				options.onInvalidRecord?.("Remote DOM worker sent an invalid upstream mutation record");
+				return;
+			}
+			const normalized = normalizeMutationRecordForHost(options, workingState, record, pendingEventListenerUpdates);
+			if (!normalized.ok) {
+				if (normalized.message === NODE_LIMIT_MESSAGE) options.onNodeLimitExceeded?.();
+				else options.onInvalidRecord?.(normalized.message);
+				return;
+			}
+			if (normalized.record) normalizedRecords.push(normalized.record);
+		}
+		try {
+			if (normalizedRecords.length > 0) options.connection.mutate(normalizedRecords);
+		} catch (error) {
+			options.onMutateError?.(error);
+			return;
+		}
+		commitSanitizingState(state, workingState);
+		for (const update of pendingEventListenerUpdates) options.onEventListenerUpdate?.(update.targetId, update.eventName, update.listener);
+	}
+	return {
+		mutate,
+		call(_id, method) {
+			throw new RemoteDomConnectionCallDeniedError(method);
+		},
+		reset
+	};
+}
+function cloneSanitizingState(state) {
+	const nodes = /* @__PURE__ */ new Map();
+	for (const [id, node] of state.nodes) nodes.set(id, node.kind === "element" ? {
+		...node,
+		childIds: [...node.childIds]
+	} : { kind: "text" });
+	return { nodes };
+}
+function commitSanitizingState(state, workingState) {
+	state.nodes.clear();
+	for (const [id, node] of workingState.nodes) state.nodes.set(id, node);
+}
+const NODE_LIMIT_MESSAGE = "Remote DOM mutation exceeded node limit.";
+function normalizeMutationRecordForHost(options, state, mutation, pendingEventListenerUpdates) {
+	switch (mutation[0]) {
+		case _remote_dom_core.MUTATION_TYPE_INSERT_CHILD: {
+			const [, parentId, child, index] = mutation;
+			const parent = state.nodes.get(parentId);
+			if (!parent || parent.kind !== "element") return {
+				ok: false,
+				message: `Remote DOM mutation referenced missing insertChild parent node "${parentId}".`
+			};
+			if (!Number.isInteger(index) || index < 0 || index > parent.childIds.length) return {
+				ok: false,
+				message: "Remote DOM insertChild index was invalid."
+			};
+			const normalized = normalizeRemoteNodeForHost(options, state, child, new Set(state.nodes.keys()), pendingEventListenerUpdates);
+			if (!normalized.ok) return normalized;
+			if (Math.max(0, state.nodes.size - 1) + normalized.nodeCount > options.maxDomNodeCount) return {
+				ok: false,
+				message: NODE_LIMIT_MESSAGE
+			};
+			registerSimulatedRemoteNode(state, normalized.node);
+			parent.childIds.splice(index, 0, normalized.node.id);
+			return {
+				ok: true,
+				record: [
+					_remote_dom_core.MUTATION_TYPE_INSERT_CHILD,
+					parentId,
+					normalized.node,
+					index
+				]
+			};
+		}
+		case _remote_dom_core.MUTATION_TYPE_REMOVE_CHILD: {
+			const [, parentId, index] = mutation;
+			const parent = state.nodes.get(parentId);
+			if (!parent || parent.kind !== "element") return {
+				ok: false,
+				message: `Remote DOM mutation referenced missing removeChild parent node "${parentId}".`
+			};
+			if (!Number.isInteger(index) || index < 0 || index >= parent.childIds.length) return {
+				ok: false,
+				message: "Remote DOM removeChild index was invalid."
+			};
+			const [removedId] = parent.childIds.splice(index, 1);
+			if (!removedId) return {
+				ok: false,
+				message: "Remote DOM removeChild index was invalid."
+			};
+			removeSimulatedRemoteNode(state, removedId);
+			return {
+				ok: true,
+				record: mutation
+			};
+		}
+		case _remote_dom_core.MUTATION_TYPE_UPDATE_TEXT: {
+			const [, id] = mutation;
+			const target = state.nodes.get(id);
+			if (!target || target.kind !== "text") return {
+				ok: false,
+				message: `Remote DOM mutation referenced missing updateText target node "${id}".`
+			};
+			return {
+				ok: true,
+				record: mutation
+			};
+		}
+		case _remote_dom_core.MUTATION_TYPE_UPDATE_PROPERTY: return normalizeUpdatePropertyRecordForHost(options, state, mutation, pendingEventListenerUpdates);
+	}
+}
+function normalizeUpdatePropertyRecordForHost(options, state, mutation, pendingEventListenerUpdates) {
+	const [, id, property, value, updateType] = mutation;
+	if (!require_remote_dom_values.isSafeRemoteDomPropertyKey(property)) return {
+		ok: false,
+		message: `Remote DOM mutation used an unsafe property key "${property}".`
+	};
+	const node = state.nodes.get(id);
+	if (!node || node.kind !== "element") return {
+		ok: false,
+		message: `Remote DOM mutation referenced missing updateProperty target node "${id}".`
+	};
+	if (updateType === _remote_dom_core.UPDATE_PROPERTY_TYPE_EVENT_LISTENER) {
+		if (!isSupportedRemoteDomEventName(property, node.localName)) return { ok: true };
+		const listener = typeof value === "function" ? value : null;
+		pendingEventListenerUpdates.push({
+			targetId: id,
+			eventName: property,
+			listener
+		});
+		return { ok: true };
+	}
+	if (value !== void 0 && !require_remote_dom_values.isRemoteDomSerializableValue(value)) return {
+		ok: false,
+		message: `Remote DOM mutation property "${property}" was not serializable.`
+	};
+	if (updateType === _remote_dom_core.UPDATE_PROPERTY_TYPE_PROPERTY) {
+		const sanitizedProperty = sanitizeRemoteDomProperty(node.localName, property, value);
+		if (sanitizedProperty) return {
+			ok: true,
+			record: [
+				_remote_dom_core.MUTATION_TYPE_UPDATE_PROPERTY,
+				id,
+				sanitizedProperty.name,
+				sanitizedProperty.value,
+				_remote_dom_core.UPDATE_PROPERTY_TYPE_PROPERTY
+			]
+		};
+		if (isRemoteDomPropertyName(node.localName, property)) return {
+			ok: false,
+			message: `Remote DOM property "${property}" had an invalid value for "${node.localName}".`
+		};
+	}
+	const [attribute] = sanitizeRemoteDomAttributes(node.localName, { [property]: value }, { urlOriginPolicy: options.urlOriginPolicy });
+	if (attribute) return {
+		ok: true,
+		record: [
+			_remote_dom_core.MUTATION_TYPE_UPDATE_PROPERTY,
+			id,
+			attribute.name,
+			attribute.value,
+			_remote_dom_core.UPDATE_PROPERTY_TYPE_ATTRIBUTE
+		]
+	};
+	const normalizedAttributeName = property.trim().toLowerCase();
+	if (!/^[a-z][a-z0-9_.-]*$/u.test(normalizedAttributeName)) return {
+		ok: false,
+		message: `Remote DOM mutation used an invalid attribute removal name "${property}".`
+	};
+	return {
+		ok: true,
+		record: [
+			_remote_dom_core.MUTATION_TYPE_UPDATE_PROPERTY,
+			id,
+			normalizedAttributeName,
+			void 0,
+			_remote_dom_core.UPDATE_PROPERTY_TYPE_ATTRIBUTE
+		]
+	};
+}
+function normalizeRemoteNodeForHost(options, state, value, seen, pendingEventListenerUpdates) {
+	if (!isObjectRecord(value)) return {
+		ok: false,
+		message: "Remote DOM render payload was not a node."
+	};
+	if (value.type === _remote_dom_core.NODE_TYPE_TEXT && typeof value.id === "string" && typeof value.data === "string") {
+		const idValidation = validateRemoteNodeId(value.id, seen);
+		if (!idValidation.ok) return idValidation;
+		return {
+			ok: true,
+			node: {
+				id: value.id,
+				type: _remote_dom_core.NODE_TYPE_TEXT,
+				data: value.data
+			},
+			nodeCount: 1
+		};
+	}
+	if (value.type !== _remote_dom_core.NODE_TYPE_ELEMENT || typeof value.id !== "string" || typeof value.element !== "string") return {
+		ok: false,
+		message: "Remote DOM render payload was not a valid node."
+	};
+	const idValidation = validateRemoteNodeId(value.id, seen);
+	if (!idValidation.ok) return idValidation;
+	const properties = readRemoteNodeProperties(value);
+	if (!properties) return {
+		ok: false,
+		message: `Remote DOM element "${value.id}" contained non-serializable properties.`
+	};
+	const tagName = sanitizeRemoteDomTagName(value.element);
+	if (!tagName) return {
+		ok: false,
+		message: `Remote DOM element "${value.id}" used an unsupported tag name.`
+	};
+	queueRemoteNodeEventListeners(value.id, tagName, value.eventListeners, pendingEventListenerUpdates);
+	if (!Array.isArray(value.children)) return {
+		ok: false,
+		message: `Remote DOM element "${value.id}" did not contain a valid children array.`
+	};
+	const children = [];
+	let nodeCount = 1;
+	for (const child of value.children) {
+		const normalized = normalizeRemoteNodeForHost(options, state, child, seen, pendingEventListenerUpdates);
+		if (!normalized.ok) return normalized;
+		children.push(normalized.node);
+		nodeCount += normalized.nodeCount;
+	}
+	const remoteProperties = {};
+	let attributeProperties = properties;
+	if (isObjectRecord(value.properties)) {
+		const mutableAttributeProperties = { ...properties };
+		attributeProperties = mutableAttributeProperties;
+		for (const [rawName, rawValue] of Object.entries(value.properties)) {
+			const property = sanitizeRemoteDomProperty(tagName, rawName, rawValue);
+			if (property) {
+				remoteProperties[property.name] = property.value;
+				delete mutableAttributeProperties[rawName];
+				continue;
+			}
+			if (isRemoteDomPropertyName(tagName, rawName)) return {
+				ok: false,
+				message: `Remote DOM property "${rawName}" had an invalid value for "${tagName}".`
+			};
+		}
+	}
+	const attributes = sanitizeRemoteDomAttributes(tagName, attributeProperties, { urlOriginPolicy: options.urlOriginPolicy });
+	const remoteAttributes = {};
+	for (const attribute of attributes) remoteAttributes[attribute.name] = attribute.value;
+	if (tagName === "button" && remoteAttributes.type === void 0) remoteAttributes.type = "button";
+	return {
+		ok: true,
+		node: {
+			id: value.id,
+			type: _remote_dom_core.NODE_TYPE_ELEMENT,
+			element: tagName,
+			attributes: remoteAttributes,
+			properties: remoteProperties,
+			children
+		},
+		nodeCount
+	};
+}
+function queueRemoteNodeEventListeners(id, tagName, eventListeners, pendingEventListenerUpdates) {
+	if (!isObjectRecord(eventListeners)) return;
+	for (const [eventName, listener] of Object.entries(eventListeners)) {
+		if (!require_remote_dom_values.isSafeRemoteDomPropertyKey(eventName) || !isSupportedRemoteDomEventName(eventName, tagName)) continue;
+		pendingEventListenerUpdates.push({
+			targetId: id,
+			eventName,
+			listener: typeof listener === "function" ? listener : null
+		});
+	}
+}
+function validateRemoteNodeId(id, seen) {
+	if (id === _remote_dom_core.ROOT_ID) return {
+		ok: false,
+		message: `Remote DOM node id "${id}" is reserved`
+	};
+	if (seen.has(id)) return {
+		ok: false,
+		message: `Remote DOM render payload contained duplicate node id "${id}"`
+	};
+	seen.add(id);
+	return { ok: true };
+}
+function readRemoteNodeProperties(value) {
+	const properties = {};
+	for (const source of [value.attributes, value.properties]) {
+		if (source === void 0) continue;
+		if (!isObjectRecord(source)) return void 0;
+		for (const [key, item] of Object.entries(source)) {
+			if (!require_remote_dom_values.isSafeRemoteDomPropertyKey(key)) return void 0;
+			if (item !== void 0 && !require_remote_dom_values.isRemoteDomSerializableValue(item)) return;
+			properties[key] = item;
+		}
+	}
+	return properties;
+}
+function registerSimulatedRemoteNode(state, node) {
+	if (node.type === _remote_dom_core.NODE_TYPE_TEXT) {
+		state.nodes.set(node.id, { kind: "text" });
+		return;
+	}
+	if (node.type !== _remote_dom_core.NODE_TYPE_ELEMENT) return;
+	state.nodes.set(node.id, {
+		kind: "element",
+		localName: node.element,
+		childIds: node.children.map((child) => child.id)
+	});
+	for (const child of node.children) registerSimulatedRemoteNode(state, child);
+}
+function removeSimulatedRemoteNode(state, id) {
+	const node = state.nodes.get(id);
+	if (!node) return;
+	state.nodes.delete(id);
+	if (node.kind === "element") for (const childId of node.childIds) removeSimulatedRemoteNode(state, childId);
+}
+function parseRemoteMutationRecord(value) {
+	if (!Array.isArray(value)) return void 0;
+	switch (value[0]) {
+		case _remote_dom_core.MUTATION_TYPE_INSERT_CHILD: return value.length === 4 && typeof value[1] === "string" && isObjectRecord(value[2]) && typeof value[3] === "number" ? value : void 0;
+		case _remote_dom_core.MUTATION_TYPE_REMOVE_CHILD: return value.length === 3 && typeof value[1] === "string" && typeof value[2] === "number" ? value : void 0;
+		case _remote_dom_core.MUTATION_TYPE_UPDATE_TEXT: return value.length === 3 && typeof value[1] === "string" && typeof value[2] === "string" ? value : void 0;
+		case _remote_dom_core.MUTATION_TYPE_UPDATE_PROPERTY: return (value.length === 4 || value.length === 5) && typeof value[1] === "string" && typeof value[2] === "string" ? value : void 0;
+		default: return;
+	}
+}
+function isObjectRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+//#region src/remote-dom-styles.ts
+const remoteDomCssArtifactCache = /* @__PURE__ */ new Map();
+const DEFAULT_THEME_DATA_ATTRIBUTES = [
+	"data-theme",
+	"data-mode",
+	"data-color-mode",
+	"data-fluid-theme",
+	"data-fluid-color-scheme"
+];
+const REMOTE_DOM_WIDGET_STYLE_ATTRIBUTE = "data-fluid-widget-style";
+function attachRemoteDomStyles({ artifact, root, cssText, widgetCssText, cssUrls, fluidComponentCssText, fluidComponentCssUrls, themeBridgeCssText, urlOriginPolicy, useConstructableStylesheets = true, fetchCss, onFailure, themeBridge }) {
+	const styleElements = [];
+	const adoptedSheets = /* @__PURE__ */ new Set();
+	const acquiredArtifacts = [];
+	let disposed = false;
+	let failureReported = false;
+	const resolvedUrlOriginPolicy = urlOriginPolicy ?? require_remote_dom_values.createRemoteDomUrlOriginPolicy({ artifactUrls: collectArtifactUrls$1(artifact) });
+	const { sources, failedSourceCount: rejectedSourceCount } = createStyleSources({
+		artifact,
+		cssText,
+		widgetCssText,
+		cssUrls,
+		fluidComponentCssText,
+		fluidComponentCssUrls,
+		themeBridgeCssText,
+		urlOriginPolicy: resolvedUrlOriginPolicy
+	});
+	const declaredSourceCount = sources.length + rejectedSourceCount;
+	const bridge = themeBridge === false ? void 0 : createRemoteDomThemeBridge({
+		root,
+		...themeBridge
+	});
+	const reportFailures = (failedSourceCount) => {
+		if (disposed || failureReported || failedSourceCount === 0) return;
+		failureReported = true;
+		try {
+			onFailure?.(failedSourceCount);
+		} catch {}
+	};
+	return {
+		ready: Promise.resolve().then(async () => {
+			const sourceResults = await Promise.all(sources.map(async (source) => {
+				if (disposed) return void 0;
+				if (source.kind === "text") return source;
+				let artifact;
+				try {
+					artifact = acquireCssArtifact(source, root, fetchCss);
+					acquiredArtifacts.push(artifact);
+					const sanitizedCssText = sanitizeRemoteDomCssUrlReferences(await artifact.entry.promise, { urlOriginPolicy: resolvedUrlOriginPolicy });
+					if (!sanitizedCssText) {
+						releaseCssArtifact(artifact);
+						if (artifact.entry.refCount === 0) remoteDomCssArtifactCache.delete(artifact.entry.key);
+						return null;
+					}
+					if (disposed) {
+						releaseCssArtifact(artifact);
+						return;
+					}
+					return {
+						kind: "text",
+						label: source.label,
+						cssText: sanitizedCssText,
+						artifact: artifact.entry
+					};
+				} catch {
+					if (artifact) {
+						releaseCssArtifact(artifact);
+						if (artifact.entry.refCount === 0) remoteDomCssArtifactCache.delete(artifact.entry.key);
+					}
+					return null;
+				}
+			}));
+			if (disposed) return;
+			const resolvedSources = [];
+			let resolutionFailureCount = 0;
+			for (const source of sourceResults) if (source === null) resolutionFailureCount += 1;
+			else if (source !== void 0) resolvedSources.push(source);
+			const installationFailureCount = installResolvedStyleSources({
+				root,
+				sources: resolvedSources,
+				styleElements,
+				adoptedSheets,
+				useConstructableStylesheets
+			});
+			reportFailures(rejectedSourceCount + resolutionFailureCount + installationFailureCount);
+		}).catch(() => {
+			reportFailures(declaredSourceCount);
+		}),
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const cleanupErrors = [];
+			runStyleCleanupStep(cleanupErrors, () => bridge?.dispose());
+			runStyleCleanupStep(cleanupErrors, () => removeAdoptedSheets(root, adoptedSheets));
+			for (const styleElement of styleElements) runStyleCleanupStep(cleanupErrors, () => styleElement.remove());
+			for (const artifact of acquiredArtifacts) runStyleCleanupStep(cleanupErrors, () => releaseCssArtifact(artifact));
+			throwStyleCleanupErrors(cleanupErrors, "Remote DOM style disposal encountered cleanup failures");
+		}
+	};
+}
+function createRemoteDomThemeBridge(options) {
+	const sourceElement = options.sourceElement ?? options.root.ownerDocument.documentElement;
+	const host = options.root.host;
+	const managedVariables = /* @__PURE__ */ new Set();
+	const managedAttributes = /* @__PURE__ */ new Set();
+	const managedClasses = /* @__PURE__ */ new Set();
+	const originalVariables = host instanceof HTMLElement ? snapshotCssVariables(host) : /* @__PURE__ */ new Map();
+	const originalAttributes = host instanceof HTMLElement ? snapshotDataAttributes(host) : /* @__PURE__ */ new Map();
+	const originalClasses = host instanceof HTMLElement ? new Set(host.classList) : /* @__PURE__ */ new Set();
+	let disposed = false;
+	let observer;
+	const restore = () => {
+		if (!(host instanceof HTMLElement)) return;
+		restoreThemeBridgeState({
+			host,
+			managedVariables,
+			managedAttributes,
+			managedClasses,
+			originalVariables,
+			originalAttributes,
+			originalClasses
+		});
+	};
+	const update = () => {
+		if (disposed || !(host instanceof HTMLElement)) return;
+		try {
+			mirrorCssVariables({
+				host,
+				sourceElement,
+				variableNames: options.cssVariableNames,
+				managedVariables,
+				originalVariables
+			});
+			mirrorDataAttributes({
+				host,
+				sourceElement,
+				dataAttributes: options.dataAttributes,
+				copyAllDataAttributes: options.copyAllDataAttributes ?? true,
+				managedAttributes,
+				originalAttributes
+			});
+			mirrorClasses({
+				host,
+				sourceElement,
+				classNames: options.classNames ?? "all",
+				managedClasses,
+				originalClasses
+			});
+		} catch (error) {
+			throw rollbackThemeBridge(error);
+		}
+	};
+	const rollbackThemeBridge = (error) => {
+		disposed = true;
+		const cleanupErrors = [];
+		runStyleCleanupStep(cleanupErrors, () => observer?.disconnect());
+		runStyleCleanupStep(cleanupErrors, restore);
+		return cleanupErrors.length === 0 ? error : new AggregateError([error, ...cleanupErrors], "Remote DOM theme update failed and rollback encountered cleanup failures");
+	};
+	try {
+		update();
+		if (options.observe !== false && typeof MutationObserver !== "undefined") {
+			observer = new MutationObserver(() => update());
+			observer.observe(options.observeTarget ?? sourceElement, {
+				attributes: true,
+				childList: options.observeTarget ? true : false,
+				subtree: options.observeTarget ? true : false
+			});
+		}
+	} catch (error) {
+		if (disposed) throw error;
+		throw rollbackThemeBridge(error);
+	}
+	return {
+		update,
+		dispose: () => {
+			if (disposed) return;
+			disposed = true;
+			const cleanupErrors = [];
+			runStyleCleanupStep(cleanupErrors, () => observer?.disconnect());
+			runStyleCleanupStep(cleanupErrors, restore);
+			throwStyleCleanupErrors(cleanupErrors, "Remote DOM theme bridge disposal encountered cleanup failures");
+		}
+	};
+}
+function collectArtifactUrls$1(artifact) {
+	return [
+		artifact.workerEntryUrl,
+		...artifact.cssUrls,
+		...artifact.assetUrls
+	];
+}
+function createStyleSources({ artifact, cssText, widgetCssText, cssUrls, fluidComponentCssText, fluidComponentCssUrls, themeBridgeCssText, urlOriginPolicy }) {
+	const sources = [];
+	const defaultVersion = `${artifact.packageId}@${artifact.version}`;
+	let failedSourceCount = 0;
+	failedSourceCount += addTextSource(sources, "fluid-components", fluidComponentCssText, urlOriginPolicy);
+	failedSourceCount += addUrlSources(sources, "fluid-components", fluidComponentCssUrls ?? [], defaultVersion, urlOriginPolicy);
+	failedSourceCount += addTextSource(sources, "theme-bridge", themeBridgeCssText, urlOriginPolicy);
+	failedSourceCount += addTextSource(sources, "widget", widgetCssText ?? cssText, urlOriginPolicy);
+	failedSourceCount += addUrlSources(sources, "widget", cssUrls ?? artifact.cssUrls, defaultVersion, urlOriginPolicy);
+	return {
+		sources,
+		failedSourceCount
+	};
+}
+function addTextSource(sources, label, cssText, urlOriginPolicy) {
+	if (!cssText || cssText.length === 0) return 0;
+	try {
+		const sanitizedCssText = sanitizeRemoteDomCssUrlReferences(cssText, { urlOriginPolicy });
+		if (!sanitizedCssText) return 1;
+		sources.push({
+			kind: "text",
+			label,
+			cssText: sanitizedCssText
+		});
+		return 0;
+	} catch {
+		return 1;
+	}
+}
+function addUrlSources(sources, label, cssUrls, defaultVersion, urlOriginPolicy) {
+	let failedSourceCount = 0;
+	for (const cssUrl of cssUrls) try {
+		const sanitizedUrl = sanitizeRemoteDomUrl(typeof cssUrl === "string" ? cssUrl : cssUrl.url, {
+			allowHashOnly: false,
+			allowMailTo: false,
+			allowRelative: false,
+			allowTel: false,
+			allowedHttpOriginGroups: ["artifact"],
+			originPolicy: urlOriginPolicy
+		});
+		if (!sanitizedUrl) {
+			failedSourceCount += 1;
+			continue;
+		}
+		sources.push({
+			kind: "url",
+			label,
+			url: sanitizedUrl,
+			version: typeof cssUrl === "string" ? defaultVersion : cssUrl.version ?? defaultVersion
+		});
+	} catch {
+		failedSourceCount += 1;
+	}
+	return failedSourceCount;
+}
+function acquireCssArtifact(source, root, fetchCss) {
+	const key = createCssArtifactCacheKey(source.url, source.version);
+	const existingEntry = remoteDomCssArtifactCache.get(key);
+	if (existingEntry) {
+		existingEntry.refCount += 1;
+		return {
+			entry: existingEntry,
+			released: false
+		};
+	}
+	const entry = {
+		key,
+		url: source.url,
+		version: source.version,
+		promise: resolveFetchCss(root, fetchCss)(source.url),
+		sheet: void 0,
+		refCount: 1
+	};
+	remoteDomCssArtifactCache.set(key, entry);
+	return {
+		entry,
+		released: false
+	};
+}
+function releaseCssArtifact(artifact) {
+	if (artifact.released) return;
+	artifact.released = true;
+	artifact.entry.refCount = Math.max(0, artifact.entry.refCount - 1);
+}
+function runStyleCleanupStep(errors, cleanup) {
+	try {
+		cleanup();
+	} catch (error) {
+		errors.push(error);
+	}
+}
+function throwStyleCleanupErrors(errors, message) {
+	if (errors.length > 0) throw new AggregateError(errors, message);
+}
+function installResolvedStyleSources({ root, sources, styleElements, adoptedSheets, useConstructableStylesheets }) {
+	const canAdoptStylesheets = useConstructableStylesheets && readAdoptedStyleSheets(root) !== void 0;
+	let failedSourceCount = 0;
+	let adoptedSourceCount = 0;
+	for (const source of sources) {
+		let sheet;
+		if (canAdoptStylesheets) try {
+			sheet = getOrCreateConstructableStyleSheet(source.cssText, source.artifact);
+		} catch {
+			sheet = void 0;
+		}
+		if (sheet) {
+			adoptedSheets.add(sheet);
+			adoptedSourceCount += 1;
+			continue;
+		}
+		let styleElement;
+		try {
+			styleElement = root.ownerDocument.createElement("style");
+			styleElement.setAttribute(REMOTE_DOM_WIDGET_STYLE_ATTRIBUTE, source.label);
+			styleElement.textContent = source.cssText;
+			root.append(styleElement);
+			styleElements.push(styleElement);
+		} catch {
+			styleElement?.remove();
+			failedSourceCount += 1;
+		}
+	}
+	if (adoptedSheets.size > 0) try {
+		appendAdoptedSheets(root, Array.from(adoptedSheets));
+	} catch {
+		let removalFailed = false;
+		try {
+			removeAdoptedSheets(root, adoptedSheets);
+		} catch {
+			removalFailed = true;
+		}
+		if (!removalFailed) adoptedSheets.clear();
+		failedSourceCount += adoptedSourceCount;
+	}
+	return failedSourceCount;
+}
+function getOrCreateConstructableStyleSheet(cssText, cachedArtifact) {
+	if (cachedArtifact?.sheet) return cachedArtifact.sheet;
+	const sheet = createConstructableStyleSheet(cssText);
+	if (cachedArtifact) cachedArtifact.sheet = sheet;
+	return sheet;
+}
+function createConstructableStyleSheet(cssText) {
+	if (typeof CSSStyleSheet === "undefined") return void 0;
+	const sheet = new CSSStyleSheet();
+	if (typeof sheet.replaceSync !== "function") return void 0;
+	try {
+		sheet.replaceSync(cssText);
+		return sheet;
+	} catch {
+		return;
+	}
+}
+function appendAdoptedSheets(root, sheets) {
+	const previousAdoptedStyleSheets = readAdoptedStyleSheets(root);
+	if (!previousAdoptedStyleSheets) return;
+	root.adoptedStyleSheets = [...previousAdoptedStyleSheets, ...sheets];
+}
+function removeAdoptedSheets(root, adoptedSheets) {
+	if (adoptedSheets.size === 0) return;
+	const currentAdoptedStyleSheets = readAdoptedStyleSheets(root);
+	if (!currentAdoptedStyleSheets) return;
+	root.adoptedStyleSheets = currentAdoptedStyleSheets.filter((sheet) => !adoptedSheets.has(sheet));
+}
+function readAdoptedStyleSheets(root) {
+	if (!("adoptedStyleSheets" in root)) return void 0;
+	return [...root.adoptedStyleSheets];
+}
+function resolveFetchCss(root, fetchCss) {
+	if (fetchCss) return fetchCss;
+	const windowFetch = root.ownerDocument.defaultView?.fetch;
+	if (typeof windowFetch === "function") return async (url) => {
+		const response = await windowFetch(url);
+		if (!response.ok) throw new Error(`Failed to fetch Remote DOM CSS: ${url}`);
+		return response.text();
+	};
+	return async () => "";
+}
+function createCssArtifactCacheKey(url, version) {
+	return `${version}:${url}`;
+}
+function snapshotCssVariables(host) {
+	const declaredVariableNames = /* @__PURE__ */ new Set();
+	collectCssVariableNamesFromDeclaration(declaredVariableNames, host.style);
+	const snapshots = /* @__PURE__ */ new Map();
+	for (const variableName of declaredVariableNames) snapshots.set(variableName, {
+		value: host.style.getPropertyValue(variableName),
+		priority: host.style.getPropertyPriority(variableName)
+	});
+	return snapshots;
+}
+function snapshotDataAttributes(host) {
+	const snapshots = /* @__PURE__ */ new Map();
+	for (const attributeName of host.getAttributeNames()) {
+		if (!attributeName.startsWith("data-")) continue;
+		const value = host.getAttribute(attributeName);
+		if (value !== null) snapshots.set(attributeName, value);
+	}
+	return snapshots;
+}
+function restoreThemeBridgeState({ host, managedVariables, managedAttributes, managedClasses, originalVariables, originalAttributes, originalClasses }) {
+	const restorationErrors = [];
+	for (const variableName of Array.from(managedVariables)) runStyleCleanupStep(restorationErrors, () => {
+		restoreCssVariable(host, variableName, originalVariables);
+		managedVariables.delete(variableName);
+	});
+	for (const attributeName of Array.from(managedAttributes)) runStyleCleanupStep(restorationErrors, () => {
+		const originalValue = originalAttributes.get(attributeName);
+		if (originalValue === void 0) host.removeAttribute(attributeName);
+		else host.setAttribute(attributeName, originalValue);
+		managedAttributes.delete(attributeName);
+	});
+	for (const className of Array.from(managedClasses)) runStyleCleanupStep(restorationErrors, () => {
+		host.classList.toggle(className, originalClasses.has(className));
+		managedClasses.delete(className);
+	});
+	throwStyleCleanupErrors(restorationErrors, "Remote DOM theme restoration encountered cleanup failures");
+}
+function restoreCssVariable(host, variableName, originalVariables) {
+	const original = originalVariables.get(variableName);
+	if (original) host.style.setProperty(variableName, original.value, original.priority);
+	else host.style.removeProperty(variableName);
+}
+function mirrorCssVariables({ host, sourceElement, variableNames, managedVariables, originalVariables }) {
+	const computedStyle = sourceElement.ownerDocument.defaultView?.getComputedStyle(sourceElement);
+	const nextVariables = new Set((variableNames ?? collectCssVariableNames(sourceElement, computedStyle)).filter((variableName) => variableName.startsWith("--")));
+	for (const variableName of managedVariables) if (!nextVariables.has(variableName)) {
+		restoreCssVariable(host, variableName, originalVariables);
+		managedVariables.delete(variableName);
+	}
+	for (const variableName of nextVariables) {
+		const value = computedStyle?.getPropertyValue(variableName) ?? "";
+		if (value.length > 0) {
+			managedVariables.add(variableName);
+			host.style.setProperty(variableName, value.trim());
+		} else {
+			restoreCssVariable(host, variableName, originalVariables);
+			managedVariables.delete(variableName);
+		}
+	}
+}
+function collectCssVariableNames(sourceElement, computedStyle) {
+	const variableNames = /* @__PURE__ */ new Set();
+	collectCssVariableNamesFromDeclaration(variableNames, computedStyle);
+	if (sourceElement instanceof HTMLElement || sourceElement instanceof SVGElement) collectCssVariableNamesFromDeclaration(variableNames, sourceElement.style);
+	return Array.from(variableNames);
+}
+function collectCssVariableNamesFromDeclaration(variableNames, declaration) {
+	if (!declaration) return;
+	for (let index = 0; index < declaration.length; index += 1) {
+		const propertyName = declaration.item(index);
+		if (propertyName.startsWith("--")) variableNames.add(propertyName);
+	}
+}
+function mirrorDataAttributes({ host, sourceElement, dataAttributes, copyAllDataAttributes, managedAttributes, originalAttributes }) {
+	const nextAttributes = /* @__PURE__ */ new Map();
+	const attributeNames = (dataAttributes ?? (copyAllDataAttributes ? sourceElement.getAttributeNames() : DEFAULT_THEME_DATA_ATTRIBUTES)).filter((attributeName) => attributeName.startsWith("data-"));
+	for (const attributeName of attributeNames) {
+		const value = sourceElement.getAttribute(attributeName);
+		if (value !== null) nextAttributes.set(attributeName, value);
+	}
+	for (const attributeName of managedAttributes) if (!nextAttributes.has(attributeName)) {
+		const originalValue = originalAttributes.get(attributeName);
+		if (originalValue === void 0) host.removeAttribute(attributeName);
+		else host.setAttribute(attributeName, originalValue);
+		managedAttributes.delete(attributeName);
+	}
+	for (const [attributeName, value] of nextAttributes) {
+		managedAttributes.add(attributeName);
+		host.setAttribute(attributeName, value);
+	}
+}
+function mirrorClasses({ host, sourceElement, classNames, managedClasses, originalClasses }) {
+	const sourceClasses = new Set(sourceElement.classList);
+	const nextClasses = classNames === "all" ? sourceClasses : new Set(classNames.filter((className) => sourceClasses.has(className)));
+	for (const className of managedClasses) if (!nextClasses.has(className)) {
+		host.classList.toggle(className, originalClasses.has(className));
+		managedClasses.delete(className);
+	}
+	for (const className of nextClasses) {
+		managedClasses.add(className);
+		host.classList.add(className);
+	}
+}
+//#endregion
+//#region src/remote-dom-renderer.ts
+const DEFAULT_MAX_MUTATION_BATCH_SIZE = 100;
+const DEFAULT_MAX_DOM_NODE_COUNT = 1e3;
+function mountRemoteDomWidget(options) {
+	const initialProps = options.props ?? null;
+	assertSerializable(initialProps, "Initial widget props");
+	const shadowRoot = createShadowRoot(options.host);
+	const navigationOrigin = normalizeNavigationOrigin(options.hostOrigin);
+	const urlOriginPolicy = require_remote_dom_values.createRemoteDomUrlOriginPolicy({
+		artifactUrls: collectArtifactUrls(options.artifact),
+		...options.mediaOrigins === void 0 ? {} : { mediaOrigins: options.mediaOrigins },
+		...navigationOrigin === void 0 ? {} : { navigationOrigin }
+	});
+	const styles = attachRemoteDomStyles({
+		artifact: options.artifact,
+		root: shadowRoot,
+		urlOriginPolicy,
+		onFailure: (count) => {
+			reportError(options, `${count} Remote DOM widget styles failed to load`);
+		},
+		...options.cssText === void 0 ? {} : { cssText: options.cssText },
+		...options.widgetCssText === void 0 ? {} : { widgetCssText: options.widgetCssText },
+		...options.cssUrls === void 0 ? {} : { cssUrls: options.cssUrls },
+		...options.fluidComponentCssText === void 0 ? {} : { fluidComponentCssText: options.fluidComponentCssText },
+		...options.fluidComponentCssUrls === void 0 ? {} : { fluidComponentCssUrls: options.fluidComponentCssUrls },
+		...options.themeBridgeCssText === void 0 ? {} : { themeBridgeCssText: options.themeBridgeCssText },
+		...options.themeBridge === void 0 ? {} : { themeBridge: options.themeBridge },
+		...options.fetchCss === void 0 ? {} : { fetchCss: options.fetchCss },
+		...options.useConstructableStylesheets === void 0 ? {} : { useConstructableStylesheets: options.useConstructableStylesheets }
+	});
+	let worker;
+	try {
+		worker = (options.workerFactory ?? createDefaultWorker)(options.artifact.workerEntryUrl, { type: "module" });
+	} catch (error) {
+		reportCleanupErrors(options, "Remote DOM widget setup cleanup failed", collectCleanupErrors([() => styles.dispose(), () => clearRenderedRemoteDomNodes(shadowRoot)]));
+		throw error;
+	}
+	let thread;
+	try {
+		thread = new require_Thread.Thread(createWorkerMessageTarget(worker));
+	} catch (error) {
+		reportCleanupErrors(options, "Remote DOM widget setup cleanup failed", collectCleanupErrors([
+			() => styles.dispose(),
+			() => worker.terminate(),
+			() => clearRenderedRemoteDomNodes(shadowRoot)
+		]));
+		throw error;
+	}
+	let state;
+	const pendingListenerUpdates = /* @__PURE__ */ new Map();
+	const connection = createSanitizingRemoteConnection({
+		connection: new _remote_dom_core_receivers.DOMRemoteReceiver({
+			root: shadowRoot,
+			call: () => {
+				throw new RemoteDomConnectionCallDeniedError("remote element method");
+			}
+		}).connection,
+		urlOriginPolicy,
+		maxMutationBatchSize: options.maxMutationBatchSize ?? DEFAULT_MAX_MUTATION_BATCH_SIZE,
+		maxDomNodeCount: options.maxDomNodeCount ?? DEFAULT_MAX_DOM_NODE_COUNT,
+		onEventListenerUpdate: (targetId, eventName, listener) => {
+			pendingListenerUpdates.set(subscriptionKey(targetId, eventName), {
+				targetId,
+				eventName,
+				listener
+			});
+		},
+		onNodeLimitExceeded: () => {
+			reportError(options, "Remote DOM widget exceeded its DOM node limit");
+		},
+		onInvalidRecord: (message) => reportError(options, message),
+		onMutateError: (error) => reportError(options, "Remote DOM mutation could not be applied", error)
+	});
+	const submitListener = createSubmitPreventionListener();
+	const navigationListener = (event) => {
+		handleNavigationIntent(state, event);
+	};
+	state = {
+		options,
+		shadowRoot,
+		worker,
+		thread,
+		styles,
+		urlOriginPolicy,
+		navigationOrigin,
+		nodesById: new Map([[_remote_dom_core.ROOT_ID, shadowRoot]]),
+		subscriptions: /* @__PURE__ */ new Map(),
+		pendingListenerUpdates,
+		submitListener,
+		navigationListener,
+		disposed: false,
+		cleanupStarted: false
+	};
+	shadowRoot.addEventListener("submit", submitListener, { capture: true });
+	shadowRoot.addEventListener("click", navigationListener, { capture: true });
+	worker.onerror = (event) => {
+		if (state.disposed) return;
+		reportError(options, event.message || "Remote DOM widget worker failed", event.error);
+		disposeAfterFailure(state, false);
+	};
+	const ready = Promise.all([styles.ready, thread.imports.mount({
+		widgetType: options.artifact.widgetType,
+		props: initialProps
+	}, {
+		mutate(records) {
+			if (state.disposed) return;
+			connection.mutate(records);
+			rebuildNodeIndex(state);
+			flushPendingListenerUpdates(state);
+		},
+		callCapability(capability, method, payload) {
+			return callCapability(state, capability, method, payload);
+		},
+		reportError(error) {
+			reportError(options, error.message);
+		}
+	})]).then(() => void 0);
+	ready.catch((error) => {
+		if (state.disposed) return;
+		reportError(options, "Remote DOM widget failed to mount", error);
+		disposeAfterFailure(state);
+	});
+	return {
+		shadowRoot,
+		styles,
+		ready,
+		updateProps(props) {
+			if (state.disposed) return;
+			assertSerializable(props, "Widget props");
+			state.thread.imports.updateProps(props).catch((error) => {
+				if (!state.disposed) reportError(options, "Remote DOM widget props update failed", error);
+			});
+		},
+		dispose() {
+			disposeMount(state);
+		}
+	};
+}
+function callCapability(state, capability, method, payload) {
+	if (state.disposed) return Promise.reject(/* @__PURE__ */ new Error("Remote DOM widget has been disposed"));
+	if (!state.options.artifact.capabilities.some((declaration) => declaration.name === capability)) return Promise.reject(/* @__PURE__ */ new Error(`Remote DOM capability "${capability}" was not declared`));
+	if (payload !== void 0 && !require_remote_dom_values.isRemoteDomSerializableValue(payload)) return Promise.reject(/* @__PURE__ */ new Error("Remote DOM capability payload was not serializable"));
+	if (capability === "fullscreen" && state.options.onFullscreen) return Promise.resolve().then(() => state.options.onFullscreen?.({
+		method,
+		...payload === void 0 ? {} : { payload },
+		host: state.options.host,
+		shadowRoot: state.shadowRoot
+	})).then((result) => {
+		if (result === void 0) throw new Error("Remote DOM fullscreen handler returned no result");
+		return assertSerializableCapabilityResult(result);
+	});
+	if (!state.options.callCapability) return Promise.reject(/* @__PURE__ */ new Error(`No host handler is configured for capability "${capability}"`));
+	return Promise.resolve().then(() => state.options.callCapability?.(capability, method, payload)).then((result) => {
+		if (result === void 0) throw new Error(`Capability handler for "${capability}" returned no result`);
+		return assertSerializableCapabilityResult(result);
+	});
+}
+function assertSerializableCapabilityResult(result) {
+	if (!require_remote_dom_values.isRemoteDomSerializableValue(result)) throw new Error("Remote DOM capability result was not serializable");
+	return result;
+}
+function rebuildNodeIndex(state) {
+	state.nodesById.clear();
+	state.nodesById.set(_remote_dom_core.ROOT_ID, state.shadowRoot);
+	const visit = (node) => {
+		state.nodesById.set((0, _remote_dom_core_elements.remoteId)(node), node);
+		for (const child of node.childNodes) visit(child);
+	};
+	for (const child of state.shadowRoot.childNodes) if (!isWidgetStyleNode(child)) visit(child);
+	for (const subscription of Array.from(state.subscriptions.values())) if (!state.nodesById.has(subscription.targetId)) unsubscribe(state, subscription.targetId, subscription.eventName);
+}
+function flushPendingListenerUpdates(state) {
+	for (const update of state.pendingListenerUpdates.values()) if (update.listener === null) unsubscribe(state, update.targetId, update.eventName);
+	else subscribe(state, update.targetId, update.eventName, update.listener);
+	state.pendingListenerUpdates.clear();
+}
+function subscribe(state, targetId, eventName, proxy) {
+	const target = state.nodesById.get(targetId);
+	const tagName = target instanceof Element ? target.localName : void 0;
+	if (!target || !isSupportedRemoteDomEventName(eventName, tagName)) return;
+	unsubscribe(state, targetId, eventName);
+	const capture = targetId === _remote_dom_core.ROOT_ID;
+	const listener = (event) => {
+		if (!capture && hasCloserEventSubscription(state, event, target, eventName)) return;
+		if (eventName === "submit" && event.cancelable) event.preventDefault();
+		const actualTargetId = resolveEventTargetId(state, event);
+		if (!actualTargetId) return;
+		const eventPayload = serializeRemoteDomEvent(event, actualTargetId, targetId, tagName);
+		if (!eventPayload) return;
+		try {
+			const result = proxy({
+				targetId: actualTargetId,
+				detail: toSerializableEventPayload(eventPayload)
+			});
+			if (isPromiseLike(result)) result.catch((error) => {
+				reportEventDeliveryFailure(state, error);
+			});
+		} catch (error) {
+			reportEventDeliveryFailure(state, error);
+		}
+	};
+	target.addEventListener(eventName, listener, { capture });
+	require_Thread.retain(proxy);
+	state.subscriptions.set(subscriptionKey(targetId, eventName), {
+		targetId,
+		eventName,
+		target,
+		listener,
+		capture,
+		proxy
+	});
+}
+function hasCloserEventSubscription(state, event, subscriptionTarget, eventName) {
+	for (const pathTarget of event.composedPath()) {
+		if (pathTarget === subscriptionTarget) return false;
+		if (!(pathTarget instanceof Node)) continue;
+		const pathTargetId = (0, _remote_dom_core_elements.remoteId)(pathTarget);
+		if (state.nodesById.get(pathTargetId) === pathTarget && state.subscriptions.has(subscriptionKey(pathTargetId, eventName))) return true;
+	}
+	return false;
+}
+function unsubscribe(state, targetId, eventName) {
+	const key = subscriptionKey(targetId, eventName);
+	const subscription = state.subscriptions.get(key);
+	if (!subscription) return;
+	subscription.target.removeEventListener(eventName, subscription.listener, { capture: subscription.capture });
+	require_Thread.release(subscription.proxy);
+	state.subscriptions.delete(key);
+}
+function resolveEventTargetId(state, event) {
+	for (const target of event.composedPath()) {
+		if (target === state.shadowRoot) return _remote_dom_core.ROOT_ID;
+		if (!(target instanceof Node)) continue;
+		const id = (0, _remote_dom_core_elements.remoteId)(target);
+		if (state.nodesById.get(id) === target) return id;
+	}
+}
+function handleNavigationIntent(state, event) {
+	if (!(event instanceof MouseEvent)) return;
+	const anchor = (event.target instanceof Element ? event.target : event.target instanceof Text ? event.target.parentElement : null)?.closest("a[href]");
+	if (!(anchor instanceof HTMLAnchorElement)) return;
+	if (!state.shadowRoot.contains(anchor)) return;
+	if (event.cancelable) event.preventDefault();
+	const href = sanitizeRemoteDomUrl(anchor.getAttribute("href"), {
+		allowHashOnly: true,
+		allowMailTo: false,
+		allowRelative: true,
+		allowTel: false,
+		allowedHttpOriginGroups: ["navigation"],
+		originPolicy: state.urlOriginPolicy,
+		relativeUrlBase: "navigation"
+	});
+	const url = href ? resolveInternalNavigationUrl(href, state.navigationOrigin) : void 0;
+	if (!href || !url || !state.options.onNavigate) {
+		reportError(state.options, "Remote DOM navigation was blocked because no allowed internal route handler was available");
+		return;
+	}
+	const targetId = findNodeId(state, anchor);
+	Promise.resolve(state.options.onNavigate({
+		href,
+		url,
+		source: "anchor",
+		...targetId === void 0 ? {} : { targetId },
+		altKey: event.altKey,
+		button: event.button,
+		ctrlKey: event.ctrlKey,
+		metaKey: event.metaKey,
+		shiftKey: event.shiftKey
+	})).catch((error) => {
+		if (!state.disposed) reportError(state.options, "Remote DOM navigation handler failed", error);
+	});
+}
+function disposeMount(state, notifyWorker = true) {
+	if (state.cleanupStarted) return;
+	state.cleanupStarted = true;
+	state.disposed = true;
+	const cleanupSteps = [
+		() => {
+			state.worker.onerror = null;
+		},
+		() => {
+			state.shadowRoot.removeEventListener("submit", state.submitListener, { capture: true });
+		},
+		() => {
+			state.shadowRoot.removeEventListener("click", state.navigationListener, { capture: true });
+		}
+	];
+	for (const subscription of Array.from(state.subscriptions.values())) cleanupSteps.push(() => {
+		unsubscribe(state, subscription.targetId, subscription.eventName);
+	});
+	cleanupSteps.push(() => state.pendingListenerUpdates.clear(), () => state.styles.dispose(), () => clearRenderedRemoteDomNodes(state.shadowRoot), () => state.nodesById.clear());
+	const cleanupErrors = collectCleanupErrors(cleanupSteps);
+	if (notifyWorker) Promise.resolve(state.thread.imports.dispose()).catch(() => void 0);
+	queueMicrotask(() => {
+		reportCleanupErrors(state.options, "Remote DOM widget asynchronous cleanup failed", collectCleanupErrors([() => state.thread.close(), () => state.worker.terminate()]));
+	});
+	if (cleanupErrors.length > 0) throw new AggregateError(cleanupErrors, "Remote DOM widget cleanup failed");
+}
+function disposeAfterFailure(state, notifyWorker = true) {
+	try {
+		disposeMount(state, notifyWorker);
+	} catch (cleanupError) {
+		reportError(state.options, "Remote DOM widget cleanup failed after an earlier error", cleanupError);
+	}
+}
+function reportEventDeliveryFailure(state, error) {
+	if (state.disposed) return;
+	reportError(state.options, "Remote DOM event delivery failed", error);
+}
+function createShadowRoot(host) {
+	if (host.shadowRoot) {
+		host.shadowRoot.replaceChildren();
+		return host.shadowRoot;
+	}
+	return host.attachShadow({ mode: "open" });
+}
+function createSubmitPreventionListener() {
+	return (event) => {
+		if (event.cancelable) event.preventDefault();
+	};
+}
+function collectArtifactUrls(artifact) {
+	return [
+		artifact.workerEntryUrl,
+		...artifact.cssUrls,
+		...artifact.assetUrls
+	];
+}
+function normalizeNavigationOrigin(value) {
+	if (!value) return void 0;
+	try {
+		const url = new URL(value);
+		return url.protocol === "http:" || url.protocol === "https:" ? url.origin : void 0;
+	} catch {
+		return;
+	}
+}
+function resolveInternalNavigationUrl(href, navigationOrigin) {
+	if (href.startsWith("#")) return href;
+	if (href.startsWith("//") || /^https?:(?!\/\/)/iu.test(href)) return;
+	try {
+		const url = new URL(href, navigationOrigin ?? "https://fluid.local");
+		if (url.protocol !== "http:" && url.protocol !== "https:") return;
+		if (/^[a-z][a-z\d+.-]*:/iu.test(href) && (!navigationOrigin || url.origin !== navigationOrigin)) return;
+		return `${url.pathname}${url.search}${url.hash}`;
+	} catch {
+		return;
+	}
+}
+function findNodeId(state, node) {
+	for (const [id, candidate] of state.nodesById) if (candidate === node) return id;
+}
+function isWidgetStyleNode(node) {
+	return node instanceof HTMLStyleElement && node.hasAttribute("data-fluid-widget-style");
+}
+function clearRenderedRemoteDomNodes(shadowRoot) {
+	for (const child of Array.from(shadowRoot.childNodes)) if (!isWidgetStyleNode(child)) child.remove();
+}
+function toSerializableEventPayload(payload) {
+	const result = {
+		bubbles: payload.bubbles,
+		cancelable: payload.cancelable,
+		currentTargetId: payload.currentTargetId,
+		defaultPrevented: payload.defaultPrevented,
+		targetId: payload.targetId,
+		type: payload.type
+	};
+	for (const key of [
+		"altKey",
+		"button",
+		"buttons",
+		"checked",
+		"clientX",
+		"clientY",
+		"code",
+		"ctrlKey",
+		"detailJson",
+		"isPrimary",
+		"key",
+		"metaKey",
+		"pointerId",
+		"pointerType",
+		"shiftKey",
+		"value"
+	]) {
+		const value = payload[key];
+		if (value !== void 0) result[key] = value;
+	}
+	return result;
+}
+function assertSerializable(value, description) {
+	if (!require_remote_dom_values.isRemoteDomSerializableValue(value)) throw new TypeError(`${description} must be serializable`);
+}
+function createWorkerMessageTarget(worker) {
+	return {
+		send(message, transferables) {
+			worker.postMessage(message, transferables ?? []);
+		},
+		listen(listener, { signal }) {
+			const onMessage = (event) => {
+				listener(event.data);
+			};
+			if (worker.addEventListener) worker.addEventListener("message", onMessage, { signal });
+			else {
+				worker.onmessage = onMessage;
+				signal?.addEventListener("abort", () => {
+					worker.onmessage = null;
+				}, { once: true });
+			}
+		}
+	};
+}
+function createDefaultWorker(workerEntryUrl, options) {
+	if (typeof Worker === "undefined") throw new Error("Remote DOM Worker is not available in this environment");
+	if (!shouldWrapWorkerEntryUrl(workerEntryUrl)) return new Worker(workerEntryUrl, options);
+	return createBlobWrappedWorker(workerEntryUrl, options);
+}
+function shouldWrapWorkerEntryUrl(workerEntryUrl) {
+	if (typeof location === "undefined" || typeof Blob === "undefined" || typeof URL.createObjectURL !== "function") return false;
+	try {
+		return new URL(workerEntryUrl, location.href).origin !== location.origin;
+	} catch {
+		return false;
+	}
+}
+function createBlobWrappedWorker(workerEntryUrl, options) {
+	const blobUrl = URL.createObjectURL(new Blob([`import ${JSON.stringify(workerEntryUrl)};\n`], { type: "application/javascript" }));
+	let worker;
+	try {
+		worker = new Worker(blobUrl, options);
+	} catch (error) {
+		URL.revokeObjectURL(blobUrl);
+		throw error;
+	}
+	const terminate = worker.terminate.bind(worker);
+	worker.terminate = () => {
+		try {
+			terminate();
+		} finally {
+			URL.revokeObjectURL(blobUrl);
+		}
+	};
+	return worker;
+}
+function reportError(options, message, cause) {
+	try {
+		options.onError?.(new Error(message, cause === void 0 ? {} : { cause }));
+	} catch {}
+}
+function collectCleanupErrors(cleanupSteps) {
+	const errors = [];
+	for (const cleanup of cleanupSteps) try {
+		cleanup();
+	} catch (error) {
+		errors.push(error);
+	}
+	return errors;
+}
+function reportCleanupErrors(options, message, errors) {
+	if (errors.length === 0) return;
+	reportError(options, message, errors.length === 1 ? errors[0] : new AggregateError(errors, "Multiple cleanup operations failed"));
+}
+function subscriptionKey(targetId, eventName) {
+	return `${targetId}:${eventName}`;
+}
+function isPromiseLike(value) {
+	return typeof value === "object" && value !== null && "then" in value && typeof value.then === "function";
+}
+//#endregion
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});
+Object.defineProperty(exports, "mountRemoteDomWidget", {
+	enumerable: true,
+	get: function() {
+		return mountRemoteDomWidget;
+	}
+});
+
+//# sourceMappingURL=remote-dom-renderer-DUQf80Nu.cjs.map