coldwired 0.18.0

package/dist/actions-k0j8z15o.mjs

@@ -0,0 +1,883 @@
+import { C as isFormOptionElement, E as isInputElement, L as nextAnimationFrame, O as isLinkElement, R as parseHTMLDocument, S as isFormInputElement, V as partition, W as wait, _ as isElement, a as dispatch, c as focusElement, l as focusNextElement, t as AbortError, u as groupBy, v as isElementOrText, w as isHTMLElement, x as isFormElement, z as parseHTMLFragment } from "./utils-C2S0wWJJ.mjs";
+import morphdom from "morphdom";
+//#region node_modules/tiny-invariant/dist/esm/tiny-invariant.js
+var isProduction = process.env.NODE_ENV === "production";
+var prefix = "Invariant failed";
+function invariant(condition, message) {
+	if (condition) return;
+	if (isProduction) throw new Error(prefix);
+	var provided = typeof message === "function" ? message() : message;
+	var value = provided ? "".concat(prefix, ": ").concat(provided) : prefix;
+	throw new Error(value);
+}
+//#endregion
+//#region src/actions/attribute-observer.ts
+const attributes = [
+	"role",
+	"disabled",
+	"hidden",
+	"tab-index",
+	"style",
+	"aria-autocomplete",
+	"aria-checked",
+	"aria-disabled",
+	"aria-errormessage",
+	"aria-expanded",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-label",
+	"aria-level",
+	"aria-modal",
+	"aria-multiline",
+	"aria-multiselectable",
+	"aria-orientation",
+	"aria-placeholder",
+	"aria-pressed",
+	"aria-readonly",
+	"aria-required",
+	"aria-selected",
+	"aria-sort",
+	"aria-valuemax",
+	"aria-valuemin",
+	"aria-valuenow",
+	"aria-valuetext",
+	"aria-busy",
+	"aria-live",
+	"aria-relevant",
+	"aria-atomic",
+	"aria-dropeffect",
+	"aria-grabbed",
+	"aria-activedescendant",
+	"aria-colcount",
+	"aria-colindex",
+	"aria-colspan",
+	"aria-controls",
+	"aria-describedby",
+	"aria-description",
+	"aria-details",
+	"aria-errormessage",
+	"aria-flowto",
+	"aria-labelledby",
+	"aria-owns",
+	"aria-posinset",
+	"aria-rowcount",
+	"aria-rowindex",
+	"aria-rowspan",
+	"aria-setsize",
+	"aria-atomic",
+	"aria-busy",
+	"aria-controls",
+	"aria-current",
+	"aria-describedby",
+	"aria-description",
+	"aria-details",
+	"aria-disabled",
+	"aria-dropeffect",
+	"aria-errormessage",
+	"aria-flowto",
+	"aria-grabbed",
+	"aria-haspopup",
+	"aria-hidden",
+	"aria-invalid",
+	"aria-keyshortcuts",
+	"aria-label",
+	"aria-labelledby",
+	"aria-live",
+	"aria-owns",
+	"aria-relevant",
+	"aria-roledescription"
+];
+var AttributeObserver = class {
+	#element;
+	#observer;
+	#delegate;
+	constructor(element, delegate) {
+		this.#element = element;
+		this.#observer = new MutationObserver((mutations) => {
+			for (const mutation of mutations) this.onAttributeMutation(mutation);
+		});
+		this.#delegate = delegate;
+	}
+	observe() {
+		this.#observer.observe(this.#element, {
+			attributes: true,
+			attributeFilter: attributes,
+			subtree: true
+		});
+	}
+	disconnect() {
+		this.#observer.disconnect();
+	}
+	onAttributeMutation(mutation) {
+		if (isElement(mutation.target) && mutation.attributeName) if (mutation.attributeName == "style") {
+			if (isHTMLElement(mutation.target)) this.#delegate.attributeChanged(mutation.target, mutation.attributeName, mutation.target.style.cssText);
+		} else {
+			const value = mutation.target.getAttribute(mutation.attributeName);
+			this.#delegate.attributeChanged(mutation.target, mutation.attributeName, value);
+		}
+	}
+};
+//#endregion
+//#region src/actions/class-list-observer.ts
+var ClassListObserver = class {
+	#element;
+	#observer;
+	#delegate;
+	constructor(element, delegate) {
+		this.#element = element;
+		this.#observer = new MutationObserver((mutations) => {
+			for (const mutation of mutations) this.onAttributeMutation(mutation);
+		});
+		this.#delegate = delegate;
+	}
+	observe() {
+		this.#observer.observe(this.#element, {
+			attributes: true,
+			attributeFilter: ["class"],
+			attributeOldValue: true,
+			subtree: true
+		});
+	}
+	disconnect() {
+		this.#observer.disconnect();
+	}
+	onAttributeMutation(mutation) {
+		if (isElement(mutation.target)) if (mutation.oldValue) {
+			const classList = new Set(mutation.oldValue.split(/\s/).filter(Boolean));
+			this.#delegate.classListChanged(mutation.target, classList);
+		} else this.#delegate.classListChanged(mutation.target, /* @__PURE__ */ new Set([]));
+	}
+};
+//#endregion
+//#region src/actions/metadata.ts
+var Metadata = class {
+	#registry = /* @__PURE__ */ new WeakMap();
+	get(element) {
+		return this.#registry.get(element) ?? null;
+	}
+	getOrCreate(element) {
+		let metadata = this.#registry.get(element);
+		if (!metadata) {
+			metadata = {
+				addedClassNames: /* @__PURE__ */ new Set(),
+				removedClassNames: /* @__PURE__ */ new Set(),
+				touched: false,
+				attributes: {}
+			};
+			this.#registry.set(element, metadata);
+		}
+		return metadata;
+	}
+	clear() {
+		this.#registry = /* @__PURE__ */ new WeakMap();
+	}
+};
+//#endregion
+//#region src/actions/morph.ts
+function morph(fromElementOrDocument, toElementOrDocument, options) {
+	options?.plugins?.forEach((plugin) => plugin.validate?.(fromElementOrDocument));
+	if (fromElementOrDocument instanceof Document) {
+		invariant(toElementOrDocument instanceof Document, "Cannot morph document to element");
+		morphDocument(fromElementOrDocument, toElementOrDocument, options);
+	} else if (fromElementOrDocument instanceof Element) {
+		invariant(!(toElementOrDocument instanceof Document), "Cannot morph element to document");
+		if (toElementOrDocument instanceof DocumentFragment) morphToDocumentFragment(fromElementOrDocument, toElementOrDocument, options);
+		else if (typeof toElementOrDocument == "string") morphToDocumentFragment(fromElementOrDocument, parseHTMLFragment(toElementOrDocument, fromElementOrDocument.ownerDocument), options);
+		else morphToElement(fromElementOrDocument, toElementOrDocument, options);
+	}
+}
+function morphToDocumentFragment(fromElement, toDocumentFragment, options) {
+	toDocumentFragment.normalize();
+	if (options?.childrenOnly) {
+		if (!options?.plugins?.some((plugin) => plugin.onBeforeUpdateElement?.(fromElement, toDocumentFragment))) {
+			const wrapper = toDocumentFragment.ownerDocument.createElement("div");
+			wrapper.append(toDocumentFragment);
+			morphToElement(fromElement, wrapper, options);
+		}
+	} else {
+		const [firstChild, secondChild, ...children] = [...toDocumentFragment.childNodes].filter(isElementOrText);
+		if (isElement(firstChild)) {
+			if (secondChild) fromElement.after(secondChild);
+			morphToElement(fromElement, firstChild, options);
+		} else if (isElement(secondChild)) {
+			fromElement.before(firstChild);
+			morphToElement(fromElement, secondChild, options);
+		} else {
+			if (secondChild) fromElement.after(secondChild);
+			fromElement.replaceWith(firstChild);
+		}
+		fromElement.after(...children);
+	}
+}
+function morphToElement(fromElement, toElement, options) {
+	const forceAttribute = options?.forceAttribute;
+	const added = /* @__PURE__ */ new WeakSet();
+	morphdom(fromElement, toElement, {
+		childrenOnly: options?.childrenOnly,
+		onBeforeElUpdated(fromElement, toElement) {
+			if (options?.plugins?.some((plugin) => plugin.onBeforeUpdateElement?.(fromElement, toElement))) return false;
+			const force = forceAttribute ? !!toElement.closest(`[${forceAttribute}="server"]`) : false;
+			const metadata = options?.metadata?.get(fromElement);
+			if (force && metadata) {
+				if (isFormInputElement(fromElement) || isFormOptionElement(fromElement)) metadata.touched = false;
+			}
+			if (fromElement.isEqualNode(toElement)) return false;
+			if (!force && forceAttribute) {
+				if (!!fromElement.closest(`[${forceAttribute}="browser"]`)) return false;
+			}
+			if (!force && metadata) {
+				toElement.classList.add(...metadata.addedClassNames);
+				toElement.classList.remove(...metadata.removedClassNames);
+				for (const [name, value] of Object.entries(metadata.attributes)) if (value == null) toElement.removeAttribute(name);
+				else if (name == "style") {
+					if (isHTMLElement(toElement)) toElement.style.cssText = value;
+				} else toElement.setAttribute(name, value);
+				if (metadata.touched) {
+					if (isInputElement(fromElement) && (fromElement.type == "checkbox" || fromElement.type == "radio")) Object.assign(toElement, { checked: fromElement.checked });
+					else if (isFormOptionElement(fromElement)) Object.assign(toElement, { selected: fromElement.selected });
+					else if (isFormInputElement(fromElement)) Object.assign(toElement, { value: fromElement.value });
+				}
+			}
+			return true;
+		},
+		onBeforeNodeDiscarded(node) {
+			if (isElement(node)) {
+				options?.plugins?.forEach((plugin) => plugin.onBeforeDestroyElement?.(node));
+				focusNextElement(node, options);
+			}
+			return true;
+		},
+		onNodeAdded(node) {
+			if (isElement(node) && node.parentElement) {
+				if (!added.has(node.parentElement)) options?.plugins?.forEach((plugin) => plugin.onCreateElement?.(node));
+				added.add(node);
+			}
+			return node;
+		}
+	});
+	if (forceAttribute) {
+		const forcedElements = fromElement.getAttribute(forceAttribute) == "server" ? [fromElement] : [];
+		for (const element of [...forcedElements, ...fromElement.querySelectorAll(`[${forceAttribute}="server"]`)]) element.removeAttribute(forceAttribute);
+	}
+}
+function morphDocument(fromDocument, toDocument, options) {
+	if (toDocument.head) morphHead(fromDocument.head, fromDocument.adoptNode(toDocument.head));
+	morphToElement(fromDocument.body, fromDocument.adoptNode(toDocument.body), options);
+}
+function morphHead(fromHeadElement, toHeadElement) {
+	morphdom(fromHeadElement, toHeadElement, {
+		childrenOnly: true,
+		onBeforeElUpdated(fromElement, toElement) {
+			if (fromElement.isEqualNode(toElement)) return false;
+			return true;
+		},
+		onBeforeNodeDiscarded(node) {
+			if (isLinkElement(node)) return false;
+			return true;
+		}
+	});
+}
+//#endregion
+//#region src/actions/schema.ts
+const defaultSchema = {
+	forceAttribute: "data-turbo-force",
+	focusGroupAttribute: "data-turbo-focus-group",
+	focusDirectionAttribute: "data-turbo-focus-direction",
+	hiddenClassName: "hidden"
+};
+//#endregion
+//#region src/actions/actions.ts
+const voidActionNames = [
+	"remove",
+	"focus",
+	"enable",
+	"disable",
+	"hide",
+	"show",
+	"reset",
+	"refresh"
+];
+const fragmentActionNames = [
+	"after",
+	"before",
+	"append",
+	"prepend",
+	"replace",
+	"update"
+];
+const actionNames = [...voidActionNames, ...fragmentActionNames];
+var Actions = class {
+	#element;
+	#schema;
+	#classListObserver;
+	#attributeObserver;
+	#delegate;
+	#metadata = new Metadata();
+	#controller = new AbortController();
+	#plugins = [];
+	#refreshRequestController;
+	#pending = /* @__PURE__ */ new Set();
+	#pinned = /* @__PURE__ */ new Map();
+	#debug;
+	constructor(options) {
+		this.#element = options?.element ?? document.documentElement;
+		this.#schema = {
+			...defaultSchema,
+			...options?.schema
+		};
+		this.#debug = options?.debug ?? false;
+		this.#plugins = options?.plugins ?? [];
+		this.#delegate = {
+			handleEvent: this.handleEvent.bind(this),
+			classListChanged: this.classListChanged.bind(this),
+			attributeChanged: this.attributeChanged.bind(this)
+		};
+		this.#classListObserver = new ClassListObserver(this.#element, this.#delegate);
+		this.#attributeObserver = new AttributeObserver(this.#element, this.#delegate);
+	}
+	async ready() {
+		const pendingPlugins = this.#plugins.map((plugin) => plugin.ready());
+		await Promise.all([...this.#pending, ...pendingPlugins]);
+	}
+	get element() {
+		return this.#element;
+	}
+	get plugins() {
+		return this.#plugins;
+	}
+	observe() {
+		this.#classListObserver.observe();
+		this.#attributeObserver.observe();
+		this.#element.addEventListener("input", this.#delegate);
+		this.#element.addEventListener("change", this.#delegate);
+		this.#element.addEventListener(ACTIONS_EVENT_TYPE, this.#delegate);
+		this.#plugins.forEach((plugin) => plugin.init(this.#element));
+	}
+	disconnect() {
+		this.clear();
+		this.#classListObserver.disconnect();
+		this.#attributeObserver.disconnect();
+		this.#element.removeEventListener("input", this.#delegate);
+		this.#element.removeEventListener("change", this.#delegate);
+		this.#element.removeEventListener(ACTIONS_EVENT_TYPE, this.#delegate);
+	}
+	clear() {
+		this.#controller.abort();
+		this.#controller = new AbortController();
+		this.#pending.clear();
+		this.#pinned.clear();
+		this.#metadata.clear();
+	}
+	applyActions(actions) {
+		const materializedActions = [];
+		const unmaterializedActions = [];
+		for (const action of actions) if (isMaterializedAction(action)) materializedActions.push(action);
+		else unmaterializedActions.push(action);
+		this.scheduleMaterializedActions(materializedActions);
+		const immediateActions = unmaterializedActions.filter(isImmediateAction);
+		const delayedActions = groupBy(unmaterializedActions.filter(isDelayedAction), ({ delay }) => delay);
+		this.scheduleActions(immediateActions);
+		for (const [delay, actions] of delayedActions) this.scheduleActions(actions, delay);
+	}
+	applyPinnedActions(element) {
+		const actions = [...this.#pinned].flatMap(([, actions]) => actions);
+		this._applyActionsInContext(this.materializeActions(actions, element));
+	}
+	after(params) {
+		this.applyActions([{
+			action: "after",
+			...params
+		}]);
+	}
+	before(params) {
+		this.applyActions([{
+			action: "before",
+			...params
+		}]);
+	}
+	append(params) {
+		this.applyActions([{
+			action: "append",
+			...params
+		}]);
+	}
+	prepend(params) {
+		this.applyActions([{
+			action: "prepend",
+			...params
+		}]);
+	}
+	replace(params) {
+		this.applyActions([{
+			action: "replace",
+			...params
+		}]);
+	}
+	update(params) {
+		this.applyActions([{
+			action: "update",
+			...params
+		}]);
+	}
+	remove(params) {
+		this.applyActions([{
+			action: "remove",
+			...params
+		}]);
+	}
+	focus(params) {
+		this.applyActions([{
+			action: "focus",
+			...params
+		}]);
+	}
+	disable(params) {
+		this.applyActions([{
+			action: "disable",
+			...params
+		}]);
+	}
+	enable(params) {
+		this.applyActions([{
+			action: "enable",
+			...params
+		}]);
+	}
+	hide(params) {
+		this.applyActions([{
+			action: "hide",
+			...params
+		}]);
+	}
+	show(params) {
+		this.applyActions([{
+			action: "show",
+			...params
+		}]);
+	}
+	reset(params) {
+		this.applyActions([{
+			action: "reset",
+			...params
+		}]);
+	}
+	refresh(params) {
+		this.applyActions([{
+			action: "refresh",
+			...params
+		}]);
+	}
+	morph(from, to, options) {
+		this.#classListObserver.disconnect();
+		this.#attributeObserver.disconnect();
+		this._morph(from, to, options);
+		this.#classListObserver.observe();
+		this.#attributeObserver.observe();
+	}
+	scheduleActions(actions, delay) {
+		const promise = this._scheduleActions(actions, delay);
+		this.#pending.add(promise);
+		promise.finally(() => this.#pending.delete(promise));
+	}
+	scheduleMaterializedActions(actions) {
+		const promise = nextAnimationFrame().then(() => this._applyActionsInContext(actions));
+		this.#pending.add(promise);
+		promise.finally(() => this.#pending.delete(promise));
+	}
+	materializeActions(actions, element) {
+		this._debugMaterializeActions(actions, element);
+		return actions.map((action) => {
+			if (action.action == "refresh") return {
+				...action,
+				targets: []
+			};
+			const targets = getTargetElements(element, action.targets);
+			return {
+				...action,
+				targets
+			};
+		});
+	}
+	async _scheduleActions(actions, delay) {
+		if (!delay) await nextAnimationFrame();
+		else {
+			try {
+				await wait(delay, this.#controller.signal);
+			} catch (error) {
+				if (error instanceof AbortError) return;
+				throw error;
+			}
+			if (this.#controller.signal?.aborted) return;
+		}
+		for (const action of actions) {
+			validateAction(action);
+			this.pinAction(action);
+		}
+		let materializedActions = this.materializeActions(actions, this.#element);
+		const activeElement = this.#element.ownerDocument.activeElement;
+		if (delay && activeElement) materializedActions = materializedActions.filter((action) => {
+			if (action.action == "remove" || action.action == "hide" || action.action == "disable") {
+				for (const target of action.targets) if (target == activeElement || target.contains(activeElement)) return false;
+			}
+			return true;
+		});
+		this._applyActionsInContext(materializedActions);
+	}
+	_applyActionsInContext(actions) {
+		const [observableActions, unobservableActions] = partition(actions, isFragmentAction);
+		this._applyActions(unobservableActions);
+		if (observableActions.length > 0) {
+			this.#classListObserver.disconnect();
+			this.#attributeObserver.disconnect();
+			this._applyActions(observableActions);
+			this.#classListObserver.observe();
+			this.#attributeObserver.observe();
+		}
+	}
+	_applyActions(actions) {
+		this._debugApplyActions(actions);
+		for (const action of actions) if (isFragmentAction(action)) this[`_${action.action}`](action);
+		else {
+			if (action.action != "focus") action.targets.forEach((element) => {
+				this.#plugins.forEach((plugin) => plugin.validate?.(element));
+			});
+			this[`_${action.action}`](action);
+		}
+	}
+	_debugMaterializeActions(actions, element) {
+		if (this.#debug && actions.length > 0) {
+			if (actions.length == 1) console.groupCollapsed(`[actions] materialize one action:`);
+			else console.groupCollapsed(`[actions] materialize ${actions.length} actions:`);
+			for (const action of actions) console.log(`"${action.action}"`, action.targets, element);
+			console.groupEnd();
+		}
+	}
+	_debugApplyActions(actions) {
+		if (this.#debug && actions.length > 0) {
+			if (actions.length == 1) console.groupCollapsed(`[actions] apply one action:`);
+			else console.groupCollapsed(`[actions] apply ${actions.length} actions:`);
+			for (const action of actions) console.dir(action);
+			console.groupEnd();
+		}
+	}
+	pinAction({ delay, pin, ...params }) {
+		if (pin && !delay) {
+			const key = `${params.action}--${params.targets}`;
+			if (pin == "last") this.#pinned.set(key, [params]);
+			else {
+				let streams = this.#pinned.get(key);
+				if (!streams) {
+					streams = [];
+					this.#pinned.set(key, streams);
+				}
+				streams.push(params);
+			}
+		}
+	}
+	_morph(from, to, options) {
+		morph(from, to, {
+			metadata: this.#metadata,
+			plugins: this.#plugins,
+			...this.#schema,
+			...options
+		});
+	}
+	_after({ targets, fragment }) {
+		for (const element of targets) {
+			element.after(getDocumentFragment(fragment, element));
+			const parent = element.parentElement;
+			if (parent) this.plugins.forEach((plugin) => plugin.onCreateElement?.(parent));
+		}
+	}
+	_before({ targets, fragment }) {
+		for (const element of targets) {
+			element.before(getDocumentFragment(fragment, element));
+			const parent = element.parentElement;
+			if (parent) this.plugins.forEach((plugin) => plugin.onCreateElement?.(parent));
+		}
+	}
+	_append({ targets, fragment }) {
+		for (const element of targets) {
+			element.append(getDocumentFragment(fragment, element, true));
+			this.plugins.forEach((plugin) => plugin.onCreateElement?.(element));
+		}
+	}
+	_prepend({ targets, fragment }) {
+		for (const element of targets) {
+			element.prepend(getDocumentFragment(fragment, element, true));
+			this.plugins.forEach((plugin) => plugin.onCreateElement?.(element));
+		}
+	}
+	_replace({ targets, fragment }) {
+		for (const element of targets) this._morph(element, getDocumentFragment(fragment, element));
+	}
+	_update({ targets, fragment }) {
+		for (const element of targets) this._morph(element, getDocumentFragment(fragment, element), { childrenOnly: true });
+	}
+	_remove({ targets }) {
+		for (const element of targets) {
+			focusNextElement(element, this.#schema);
+			element.remove();
+		}
+	}
+	_focus({ targets }) {
+		const element = targets.at(0);
+		if (element) focusElement(element);
+	}
+	_show({ targets }) {
+		for (const element of targets) {
+			element.removeAttribute("hidden");
+			element.classList.remove(this.#schema.hiddenClassName);
+		}
+	}
+	_hide({ targets }) {
+		for (const element of targets) {
+			focusNextElement(element, this.#schema);
+			element.setAttribute("hidden", "hidden");
+			element.classList.add(this.#schema.hiddenClassName);
+		}
+	}
+	_enable({ targets }) {
+		for (const element of targets) if ("disabled" in element) element.disabled = false;
+	}
+	_disable({ targets }) {
+		for (const element of targets) if ("disabled" in element) {
+			focusNextElement(element, this.#schema);
+			element.disabled = true;
+		}
+	}
+	_reset({ targets }) {
+		for (const element of targets) if (isFormElement(element)) element.reset();
+		else console.warn("reset action is not supported on non-form elements", element);
+	}
+	_refresh() {
+		const currentPath = () => `${window.location.pathname}${window.location.search}`;
+		this.#refreshRequestController?.abort();
+		const controller = new AbortController();
+		this.#refreshRequestController = controller;
+		const path = currentPath();
+		fetch(path, {
+			method: "get",
+			signal: controller.signal,
+			headers: { accept: "text/html,application/xhtml+xml" },
+			credentials: "same-origin",
+			redirect: "follow"
+		}).then((response) => {
+			if (currentPath() == path) if (response.redirected) window.location.href = response.url;
+			else response.text().then((html) => {
+				const newDocument = parseHTMLDocument(html);
+				if (response.ok) this._morph(document.body, newDocument.body);
+				else document.body.innerHTML = newDocument.body.innerHTML;
+			});
+		}, (error) => {
+			if (error.name != "AbortError") console.error(`Failed to refresh the page: ${path}`, error);
+		}).finally(() => {
+			this.#refreshRequestController = void 0;
+		});
+	}
+	handleEvent(event) {
+		const target = event.composedPath && event.composedPath()[0] || event.target;
+		if (event.type == ACTIONS_EVENT_TYPE) {
+			const actions = (event.detail ?? []).map((action) => ({
+				...action,
+				targets: [target]
+			}));
+			this.applyActions(actions);
+		} else if (isFormInputElement(target)) this.#metadata.getOrCreate(target).touched = true;
+	}
+	classListChanged(element, oldClassList) {
+		const metadata = this.#metadata.getOrCreate(element);
+		const classList = new Set(element.classList);
+		const added = difference(classList, oldClassList);
+		const removed = difference(oldClassList, classList);
+		for (const className of added) {
+			metadata.addedClassNames.add(className);
+			metadata.removedClassNames.delete(className);
+		}
+		for (const className of removed) {
+			metadata.removedClassNames.add(className);
+			metadata.addedClassNames.delete(className);
+		}
+	}
+	attributeChanged(element, attributeName, value) {
+		this.#metadata.getOrCreate(element).attributes[attributeName] = value;
+	}
+};
+function removeDuplicateTargetChildren(targets, fragment) {
+	for (const element of duplicateChildren(targets, fragment)) element.remove();
+}
+function duplicateChildren(targets, fragment) {
+	const existingChildren = targets.flatMap((element) => [...element.children]).filter((element) => !!element.id);
+	const newChildrenIds = new Set([...fragment.children].filter((element) => !!element.id).map((element) => element.id));
+	return existingChildren.filter((element) => newChildrenIds.has(element.id));
+}
+function difference(a, b) {
+	return new Set([...a].filter((x) => !b.has(x)));
+}
+function isValidActionName(actionName) {
+	return !!actionName && actionNames.includes(actionName);
+}
+function isImmediateAction(action) {
+	return !action.delay;
+}
+function isDelayedAction(action) {
+	return !!action.delay;
+}
+function isFragmentAction(action) {
+	return "fragment" in action;
+}
+function isMaterializedAction(action) {
+	return !(typeof action.targets == "string");
+}
+function getTargetElements(element, selector) {
+	if (selector == "head") return [element.ownerDocument.head];
+	else if (selector == "body") return [element.ownerDocument.body];
+	return [...element.querySelectorAll(selector)];
+}
+function getDocumentFragment(fragmentOrHTML, target, deduplicate = false) {
+	const fragment = typeof fragmentOrHTML == "string" ? parseHTMLFragment(fragmentOrHTML, target.ownerDocument) : fragmentOrHTML.cloneNode(true);
+	if (deduplicate) removeDuplicateTargetChildren([target], fragment);
+	return fragment;
+}
+function serializeDocumentFragment(action) {
+	if (isFragmentAction(action)) {
+		if (action.fragment instanceof DocumentFragment) return new XMLSerializer().serializeToString(action.fragment);
+		return action.fragment;
+	}
+}
+function getTargets(targets) {
+	if (typeof targets == "string") return [...document.querySelectorAll(targets)];
+	else if (Array.isArray(targets)) return [...targets];
+	return targets ? [targets] : [];
+}
+function validateAction(action) {
+	invariant(!(action.delay && action.pin), "[actions] a delayed action cannot be pinned");
+}
+var DispatchEventElement = class extends HTMLElement {
+	constructor() {
+		super();
+		this.style.display = "none";
+	}
+	connectedCallback() {
+		const type = this.getAttribute("type");
+		const target = this.parentElement?.tagName == "HEAD" ? this.ownerDocument.documentElement : this.previousElementSibling;
+		invariant(type, "[dispatch-event] must have \"type\" attribute");
+		invariant(target, "[dispatch-event] must have a target element");
+		const content = this.querySelector("script[type=\"application/json\"]")?.textContent;
+		dispatch(type, {
+			target,
+			detail: content ? parseEventDetail(content) : null
+		});
+		this.remove();
+	}
+};
+if (!customElements.get("dispatch-event")) customElements.define("dispatch-event", DispatchEventElement);
+function parseEventDetail(content) {
+	const maybeJSON = content.trim().replace(/^<!\[CDATA\[/, "").replace(/\]\]>$/, "").trim();
+	if (!maybeJSON) return null;
+	try {
+		return JSON.parse(maybeJSON);
+	} catch {
+		return null;
+	}
+}
+const ACTIONS_EVENT_TYPE = "__actions__";
+function dispatchActions(actions) {
+	const actionsByTarget = groupBy(actions.flatMap((action) => {
+		return getTargets(action.targets).filter((target) => target.isConnected).map((target) => [
+			target,
+			action.action,
+			serializeDocumentFragment(action)
+		]);
+	}), ([target]) => target);
+	for (const [target, actions] of actionsByTarget) dispatch(ACTIONS_EVENT_TYPE, {
+		target,
+		detail: actions.map(([, action, fragment]) => ({
+			action,
+			fragment
+		}))
+	});
+}
+function dispatchAction({ targets, ...action }) {
+	dispatchActions([{
+		...action,
+		targets: getTargets(targets)
+	}]);
+}
+//#endregion
+//#region src/actions.ts
+function hide(targets) {
+	dispatchAction({
+		action: "hide",
+		targets
+	});
+}
+function show(targets) {
+	dispatchAction({
+		action: "show",
+		targets
+	});
+}
+function disable(targets) {
+	dispatchAction({
+		action: "disable",
+		targets
+	});
+}
+function enable(targets) {
+	dispatchAction({
+		action: "enable",
+		targets
+	});
+}
+function remove(targets) {
+	dispatchAction({
+		action: "remove",
+		targets
+	});
+}
+function append(targets, fragment) {
+	dispatchAction({
+		action: "append",
+		targets,
+		fragment
+	});
+}
+function prepend(targets, fragment) {
+	dispatchAction({
+		action: "prepend",
+		targets,
+		fragment
+	});
+}
+function after(targets, fragment) {
+	dispatchAction({
+		action: "after",
+		targets,
+		fragment
+	});
+}
+function before(targets, fragment) {
+	dispatchAction({
+		action: "before",
+		targets,
+		fragment
+	});
+}
+function update(targets, fragment) {
+	dispatchAction({
+		action: "update",
+		targets,
+		fragment
+	});
+}
+function replace(targets, fragment) {
+	dispatchAction({
+		action: "replace",
+		targets,
+		fragment
+	});
+}
+//#endregion
+export { invariant as _, enable as a, remove as c, update as d, Actions as f, defaultSchema as g, isValidActionName as h, disable as i, replace as l, dispatchActions as m, append as n, hide as o, dispatchAction as p, before as r, prepend as s, after as t, show as u };