@threadlabs/looma 0.28.4 → 0.28.6

package/vue/chunks/_plugin-vue_export-helper.js

@@ -1,3 +1,906 @@
+import { Fragment, computed, defineComponent, getCurrentInstance, h, onBeforeUnmount, onBeforeUpdate, onMounted, onUpdated, shallowRef, useSlots, watchEffect } from "vue";
+//#region .build/vue/host.ts
+function controllerNamespaces(options, source) {
+	const reported = /* @__PURE__ */ new Set();
+	const nested = /* @__PURE__ */ new WeakMap();
+	const eventType = typeof Event === "undefined" ? void 0 : Object.getOwnPropertyDescriptor(Event.prototype, "type").get;
+	const eventBrands = /* @__PURE__ */ new WeakMap();
+	const nativeEvent = (value) => {
+		if (!("type" in value) || eventType === void 0) return false;
+		const known = eventBrands.get(value);
+		if (known !== void 0) return known;
+		let accepted = false;
+		try {
+			eventType.call(value);
+			accepted = true;
+		} catch {}
+		eventBrands.set(value, accepted);
+		return accepted;
+	};
+	const warn = (path, readonly) => {
+		if (reported.has(path)) return;
+		reported.add(path);
+		console.warn(source + ": HR007: Destination " + path + (readonly ? " is read-only." : " does not satisfy its declared type."));
+	};
+	const write = (name, keys, value, readonly, apply) => {
+		if (readonly || options.acceptsState?.(name, keys, value) === false) warn([name, ...keys].join("."), readonly);
+		else apply();
+		return true;
+	};
+	const plain = /* @__PURE__ */ new WeakMap();
+	const unwrap = (value) => typeof value === "object" && value !== null && plain.has(value) ? plain.get(value) : value;
+	const wrap = (value, name, keys, readonly) => {
+		if (value === null || typeof value !== "object" || nativeEvent(value)) return value;
+		const path = [name, ...keys].join(".");
+		let paths = nested.get(value);
+		if (paths === void 0) nested.set(value, paths = /* @__PURE__ */ new Map());
+		const known = paths.get(path);
+		if (known !== void 0) return known;
+		const surface = readonly ? Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value)) : value;
+		if (readonly && Array.isArray(value)) surface.length = value.length;
+		const proxy = new Proxy(surface, {
+			get: (_target, key) => {
+				if (!readonly) options.read?.(name, [...keys, String(key)]);
+				return wrap(Reflect.get(value, key), name, [...keys, String(key)], readonly);
+			},
+			set: (_target, key, written) => {
+				const next = unwrap(written);
+				return write(name, [...keys, String(key)], next, readonly, () => {
+					const previous = Reflect.get(value, key);
+					const length = Array.isArray(value) ? value.length : void 0;
+					if (Reflect.set(value, key, next) && !Object.is(previous, next)) options.changed?.(name, [...keys, String(key)]);
+					if (length !== void 0 && length !== value.length && key !== "length") options.changed?.(name, [...keys, "length"]);
+				});
+			},
+			has: (_target, key) => Reflect.has(value, key),
+			ownKeys: () => Reflect.ownKeys(value),
+			getOwnPropertyDescriptor: (_target, key) => {
+				if (readonly && Array.isArray(value) && key === "length") {
+					surface.length = value.length;
+					return Reflect.getOwnPropertyDescriptor(surface, key);
+				}
+				const descriptor = Reflect.getOwnPropertyDescriptor(value, key);
+				return descriptor === void 0 ? void 0 : readonly ? {
+					...descriptor,
+					configurable: true
+				} : descriptor;
+			},
+			deleteProperty: (_target, key) => write(name, [...keys, String(key)], void 0, readonly, () => {
+				if (Reflect.has(value, key) && Reflect.deleteProperty(value, key)) options.changed?.(name, [...keys, String(key)]);
+			}),
+			defineProperty: (_target, key, descriptor) => {
+				if (readonly || !("value" in descriptor) || options.acceptsState?.(name, [...keys, String(key)], descriptor.value) === false) {
+					warn([
+						name,
+						...keys,
+						String(key)
+					].join("."), readonly);
+					return false;
+				}
+				const changed = Reflect.defineProperty(value, key, descriptor);
+				if (changed) options.changed?.(name, [...keys, String(key)]);
+				return changed;
+			}
+		});
+		paths.set(path, proxy);
+		plain.set(proxy, value);
+		return proxy;
+	};
+	return {
+		state: new Proxy({}, {
+			get: (_target, name) => {
+				if (typeof name !== "string") return void 0;
+				if (Object.hasOwn(options.state, name)) return wrap(options.state[name].get(), name, [], false);
+				if (Object.hasOwn(options.computed, name)) return wrap(options.computed[name](), name, [], true);
+			},
+			set: (_target, name, value) => write(String(name), [], unwrap(value), typeof name !== "string" || !Object.hasOwn(options.state, name), () => options.state[String(name)].set(unwrap(value))),
+			deleteProperty: (_target, name) => {
+				warn(String(name), true);
+				return true;
+			},
+			defineProperty: (_target, name) => {
+				warn(String(name), true);
+				return false;
+			},
+			has: (_target, name) => typeof name === "string" && (Object.hasOwn(options.state, name) || Object.hasOwn(options.computed, name))
+		}),
+		data: new Proxy({}, {
+			get: (_target, name) => typeof name === "string" && Object.hasOwn(options.data ?? {}, name) ? wrap(options.data[name](), "data." + name, [], true) : void 0,
+			set: (_target, name, value) => write("data." + String(name), [], value, true, () => {}),
+			deleteProperty: (_target, name) => {
+				warn("data." + String(name), true);
+				return true;
+			},
+			defineProperty: (_target, name) => {
+				warn("data." + String(name), true);
+				return false;
+			},
+			has: (_target, name) => typeof name === "string" && Object.hasOwn(options.data ?? {}, name)
+		})
+	};
+}
+function dispatchToTargets(recorded, send) {
+	const targets = (recorded instanceof Set ? [...recorded] : Array.isArray(recorded) ? [...recorded] : [recorded]).map((ref) => ref?.nodeType === 1 ? ref : ref?.$el).filter((element) => element?.nodeType === 1 && element.isConnected).sort((a, b) => a === b ? 0 : a.compareDocumentPosition(b) & 4 ? -1 : 1);
+	for (const target of targets) if (target.isConnected) send(target);
+}
+var runtimeKey = Symbol.for("@nextwebwg/html-next.runtime.v1");
+function observeConnection(element, check) {
+	const document = element.ownerDocument;
+	const state = document[runtimeKey] ??= {};
+	let hub = state.mutationHub;
+	if (hub === void 0) {
+		const Observer = document.defaultView?.MutationObserver ?? MutationObserver;
+		const subscribers = /* @__PURE__ */ new Set();
+		const observer = new Observer((mutations) => {
+			for (const notify of Array.from(subscribers)) notify(mutations);
+		});
+		hub = {
+			observer,
+			subscribers
+		};
+		state.mutationHub = hub;
+		observer.observe(document, {
+			childList: true,
+			subtree: true
+		});
+	}
+	const shared = hub;
+	const subscriber = () => check();
+	shared.subscribers.add(subscriber);
+	return () => {
+		shared.subscribers.delete(subscriber);
+		if (shared.subscribers.size === 0 && state.mutationHub === shared) {
+			shared.observer.disconnect();
+			delete state.mutationHub;
+		}
+	};
+}
+/** Keep native focus on the corresponding control when a root-level $match replaces its element. */
+function preserveRootFocus(root) {
+	const focusable = "a[href], button, input, select, textarea, summary, [tabindex], [contenteditable]";
+	let previous = null;
+	let active = null;
+	let focusIndex = -1;
+	onBeforeUpdate(() => {
+		previous = root.value;
+		active = previous?.ownerDocument.activeElement ?? null;
+		focusIndex = previous !== null && active !== null && active !== previous && previous.contains(active) ? Array.from(previous.querySelectorAll(focusable)).indexOf(active) : -1;
+	});
+	onUpdated(() => {
+		const next = root.value;
+		if (previous === null || next === null || previous === next) return;
+		(active === previous ? next : active?.isConnected === true && next.contains(active) ? active : focusIndex >= 0 ? next.querySelectorAll(focusable)[focusIndex] : void 0)?.focus?.({ preventScroll: true });
+	});
+}
+/** Vue does not promise a `v-for` ref array in source order, and the host does. */
+function inDocumentOrder(elements) {
+	return [...elements].sort((a, b) => (a.compareDocumentPosition(b) & 4) !== 0 ? -1 : 1);
+}
+/** Slot content flattened to the elements Vue mounted for it, descending through fragments. */
+function slottedElements(nodes) {
+	const elements = [];
+	for (const node of nodes) if (node.type === Fragment && Array.isArray(node.children)) elements.push(...slottedElements(node.children));
+	else if (node.el instanceof Element) elements.push(node.el);
+	return elements;
+}
+/**
+* The controller host, built from Vue refs, effects, and lifecycle. Reads and writes reach the
+* component's own refs, so a controller's change renders as any other Vue change does. Vue
+* hooks cover mount/unmount; a shared native observer also detects external root detachment
+* and reinsertion without treating an in-tree move as a new connection.
+*/
+function useComponentHost(controllerLoader, options) {
+	const { root, dispatch, props, propInputs = () => null, propNames = [], refs = {}, state = {}, computed: computedValues = {}, data = {}, context = {} } = options;
+	const vueSlots = useSlots();
+	const component = getCurrentInstance();
+	const report = (error) => {
+		const handler = component?.appContext.config.errorHandler;
+		if (handler === void 0) queueMicrotask(() => {
+			throw error;
+		});
+		else handler(error, component?.proxy ?? null, "HTML Next controller");
+	};
+	const controllerDiagnostic = (code, reason) => {
+		const edge = options.controllerSource;
+		const source = edge?.definition ? new URL(edge.definition, document.baseURI).href : void 0;
+		const url = new URL(edge?.specifier ?? "", source ?? document.baseURI).href;
+		const message = code === "HJ002" ? "Controller module `" + url + "` must default-export a function." : "Controller module `" + url + "` failed to load: " + (reason instanceof Error ? reason.message : String(reason)) + ".";
+		return Object.assign(/* @__PURE__ */ new Error((source === void 0 ? "" : source + ": ") + code + ": " + message), {
+			name: "HtmlDiagnosticError",
+			diagnostic: Object.freeze({
+				code,
+				message,
+				...source === void 0 ? {} : { source }
+			})
+		});
+	};
+	let controllerModule;
+	const loadControllerModule = () => controllerModule ??= Promise.resolve().then(controllerLoader).then((candidate) => {
+		if (typeof candidate?.default !== "function") throw controllerDiagnostic("HJ002");
+		return candidate;
+	}).catch((error) => {
+		if (error instanceof Error && "diagnostic" in error) throw error;
+		throw controllerDiagnostic("HJ001", error);
+	});
+	const stops = [];
+	const connected = shallowRef(false);
+	const pauses = /* @__PURE__ */ new Map();
+	const subscriptions = /* @__PURE__ */ new Set();
+	const activate = (entry) => {
+		if (entry.type === "connect") entry.cleanup = entry.callback(new Event("connect"));
+		else if (entry.type !== "disconnect") {
+			entry.target = root.value ?? void 0;
+			entry.target?.addEventListener(entry.type, entry.callback);
+		}
+	};
+	const deactivate = (entry, disconnecting) => {
+		entry.target?.removeEventListener(entry.type, entry.callback);
+		entry.target = void 0;
+		const cleanup = entry.cleanup;
+		entry.cleanup = void 0;
+		cleanup?.();
+		if (disconnecting && entry.type === "disconnect") entry.callback(new Event("disconnect"));
+	};
+	const propHandles = Object.create(null);
+	for (const name of propNames) {
+		const validity = () => options.propValidity?.(name);
+		const value = computed(() => props?.value[name]);
+		propHandles[name] = Object.freeze({
+			get value() {
+				return value.value;
+			},
+			get inputValue() {
+				return propInputs(name);
+			},
+			get validity() {
+				return validity();
+			},
+			validate: validity
+		});
+	}
+	const host = {
+		get element() {
+			return root.value;
+		},
+		get root() {
+			return root.value;
+		},
+		...controllerNamespaces({
+			state: Object.fromEntries(Object.entries(state).map(([name, value]) => [name, {
+				get: () => value.value,
+				set: (next) => {
+					value.value = next;
+				}
+			}])),
+			computed: Object.fromEntries([...Object.entries(computedValues), ...Object.entries(context)].map(([name, value]) => [name, () => value.value])),
+			data: Object.fromEntries(Object.entries(data).map(([name, value]) => [name, () => value.value])),
+			...options.acceptsState === void 0 ? {} : { acceptsState: options.acceptsState }
+		}, options.controllerSource?.definition ?? "<component>"),
+		on(type, callback) {
+			const entry = {
+				type,
+				callback
+			};
+			subscriptions.add(entry);
+			if (connected.value) activate(entry);
+			return () => {
+				if (subscriptions.delete(entry)) deactivate(entry, false);
+			};
+		},
+		props: Object.freeze(propHandles),
+		refs: Object.defineProperties({}, Object.fromEntries(Object.entries(refs).map(([name, ref]) => [name, {
+			enumerable: true,
+			get: () => Array.isArray(ref.value) ? inDocumentOrder(ref.value) : ref.value
+		}]))),
+		slots: new Proxy({}, {
+			get: (_target, name) => {
+				if (typeof name !== "string") return void 0;
+				const render = vueSlots[name];
+				return render === void 0 ? [] : slottedElements(render());
+			},
+			has: (_target, name) => typeof name === "string" && vueSlots[name] !== void 0
+		}),
+		signal(initialValue) {
+			const value = shallowRef(initialValue);
+			return {
+				get: () => value.value,
+				set: (next) => {
+					value.value = next;
+				},
+				update: (next) => {
+					value.value = next(value.value);
+				}
+			};
+		},
+		computed(compute) {
+			const value = computed(compute);
+			return { get: () => value.value };
+		},
+		effect(run) {
+			let cleanup;
+			const pause = () => {
+				const previous = cleanup;
+				cleanup = void 0;
+				previous?.();
+			};
+			const stop = watchEffect(() => {
+				pause();
+				if (connected.value) cleanup = run();
+			}, { flush: "post" });
+			const dispose = () => {
+				stop();
+				pause();
+				pauses.delete(dispose);
+			};
+			pauses.set(dispose, pause);
+			stops.push(dispose);
+			return dispose;
+		},
+		dispatch
+	};
+	let cleanup;
+	let started;
+	let stopObserving;
+	let connection = 0;
+	let initialized = false;
+	let unmounted = false;
+	const disconnect = () => {
+		if (!connected.value) return;
+		connected.value = false;
+		connection += 1;
+		for (const pause of pauses.values()) pause();
+		for (const entry of subscriptions) deactivate(entry, true);
+		cleanup?.();
+		cleanup = void 0;
+	};
+	const synchronize = () => {
+		if (unmounted) return;
+		if (root.value?.isConnected !== true) {
+			disconnect();
+			return;
+		}
+		if (connected.value) {
+			for (const entry of subscriptions) if (entry.type !== "connect" && entry.type !== "disconnect" && entry.target !== root.value) {
+				deactivate(entry, false);
+				activate(entry);
+			}
+			return;
+		}
+		connected.value = true;
+		for (const entry of subscriptions) activate(entry);
+		if (initialized) return;
+		const current = ++connection;
+		started = loadControllerModule().then(async (loaded) => {
+			if (!connected.value || current !== connection || initialized) return loaded;
+			initialized = true;
+			const result = await loaded.default(host);
+			if (typeof result === "function") {
+				if (!connected.value || current !== connection) result();
+				else cleanup = result;
+			}
+			return loaded;
+		});
+		started.catch(report);
+	};
+	onMounted(() => {
+		if (root.value === null) return;
+		stopObserving = observeConnection(root.value, () => {
+			try {
+				synchronize();
+			} catch (error) {
+				report(error);
+			}
+		});
+		synchronize();
+	});
+	onUpdated(synchronize);
+	onBeforeUnmount(() => {
+		unmounted = true;
+		stopObserving?.();
+		disconnect();
+		for (const stop of stops.splice(0)) stop();
+		subscriptions.clear();
+	});
+	return host;
+}
+var HtmlDiagnosticError = class extends Error {
+	diagnostic;
+	constructor(code, message) {
+		super(code + ": " + message);
+		this.name = "HtmlDiagnosticError";
+		this.diagnostic = Object.freeze({
+			code,
+			message
+		});
+	}
+};
+/** Reports declared CustomEvents to Vue and dispatches them through the DOM. */
+function createDispatch(root, emit, options = {}) {
+	const { declared = {}, checks = {}, modeled = [] } = options;
+	const reported = /* @__PURE__ */ new Map();
+	return (name, detail, targets) => {
+		const check = checks[name];
+		if (detail !== void 0 && check !== void 0 && !check(detail)) throw new HtmlDiagnosticError("HR002", `Event \`${name}\` detail does not satisfy its declared type.`);
+		if (targets !== void 0) {
+			let accepted = true;
+			dispatchToTargets(targets, (target) => {
+				if (!target.dispatchEvent(new CustomEvent(name, {
+					bubbles: true,
+					composed: true,
+					...declared[name],
+					detail
+				}))) accepted = false;
+			});
+			return accepted;
+		}
+		if (detail !== null && typeof detail === "object") for (const prop of modeled) {
+			if (!(prop in detail)) continue;
+			const value = detail[prop];
+			if (reported.has(prop) && Object.is(reported.get(prop), value)) continue;
+			if (reported.size === 0) queueMicrotask(() => reported.clear());
+			reported.set(prop, value);
+			emit?.(`update:${prop}`, value);
+		}
+		const event = new CustomEvent(name, {
+			bubbles: true,
+			composed: true,
+			...declared[name],
+			detail
+		});
+		if (check !== void 0) emit?.(name, event);
+		return root.value?.dispatchEvent(event) ?? true;
+	};
+}
+/**
+* A consumer's attributes for the root. Vue sets a name that is also an object property, such as
+* `constructor`, as a DOM property; capitalized, it stays an attribute, which HTML lowercases.
+*/
+function nativeAttrs(attrs) {
+	const names = Object.keys(attrs);
+	if (!names.some((name) => Object.hasOwn(Object.prototype, name))) return attrs;
+	return Object.fromEntries(names.map((name) => [Object.hasOwn(Object.prototype, name) ? name === "__proto__" ? "__Proto__" : name[0].toUpperCase() + name.slice(1) : name, attrs[name]]));
+}
+/** Hydrating server markup needs its root to be the element this component renders. */
+function checkHydratedRoot(expected, tag) {
+	const node = getCurrentInstance()?.vnode.el;
+	if (typeof window === "undefined" || node == null || node instanceof Element && node.localName === expected) return;
+	const message = `Server markup for <${tag}> has an incompatible root.`;
+	throw Object.assign(/* @__PURE__ */ new Error(`HR005: ${message}`), {
+		name: "HtmlDiagnosticError",
+		diagnostic: Object.freeze({
+			code: "HR005",
+			message
+		})
+	});
+}
+function diagnostic(code, message) {
+	return Object.assign(/* @__PURE__ */ new Error(`${code}: ${message}`), {
+		name: "HtmlDiagnosticError",
+		diagnostic: Object.freeze({
+			code,
+			message
+		})
+	});
+}
+/** Vue may return an in-progress computed value on a cyclic read; guard the public value access instead. */
+function cycleCheckedComputed(evaluate) {
+	const value = computed(evaluate);
+	let reading = false;
+	return new Proxy(value, { get(target, property) {
+		if (property !== "value") return Reflect.get(target, property);
+		if (reading) throw diagnostic("HR006", "A reactive computed value depends on itself.");
+		reading = true;
+		try {
+			return target.value;
+		} finally {
+			reading = false;
+		}
+	} });
+}
+/**
+* A declared prop's reflected root attribute: the authored literal until the consumer passes the
+* prop, then its value as text, absent for null.
+*/
+function useReflectedProp() {
+	const instance = getCurrentInstance();
+	return (name, kebab, value, fallback, bound, separator) => {
+		const incoming = instance?.vnode.props;
+		if (!bound && (incoming === null || incoming === void 0 || !Object.hasOwn(incoming, name) && !Object.hasOwn(incoming, kebab))) return fallback;
+		if (value === null || value === void 0) return void 0;
+		return Array.isArray(value) && separator !== void 0 ? value.join(separator) : typeof value === "object" ? JSON.stringify(value) : String(value);
+	};
+}
+var KeyedFailure = /* @__PURE__ */ defineComponent({
+	props: { error: {
+		type: null,
+		required: true
+	} },
+	setup(props) {
+		return () => {
+			throw props.error;
+		};
+	}
+});
+/** A keyed list that produces a duplicate key keeps its last rows and reports the error in the browser. */
+var KeyedBoundary = /* @__PURE__ */ defineComponent({ setup(_props, { slots }) {
+	let last = [];
+	return () => {
+		try {
+			last = slots.default?.() ?? [];
+			return last;
+		} catch (error) {
+			if (!(error instanceof Error) || error.diagnostic?.code !== "HR004") throw error;
+			if (typeof window === "undefined") throw error;
+			return [...last, h(KeyedFailure, { error })];
+		}
+	};
+} });
+var warned = /* @__PURE__ */ new Set();
+/** An authored value's check: false warns once per authored location. */
+function warnUnless(accepted, location, message) {
+	if (!accepted && !warned.has(location)) {
+		warned.add(location);
+		console.warn(message);
+	}
+	return accepted;
+}
+function text(value) {
+	if (Array.isArray(value)) return value.map(text).join(" ");
+	return value === null || value === void 0 || typeof value === "object" ? "" : String(value);
+}
+function attribute(value) {
+	if (value === null || value === void 0 || value === false || typeof value === "object" && !Array.isArray(value)) return void 0;
+	return value === true ? "" : text(value);
+}
+function list(value) {
+	return Array.isArray(value) ? value : [];
+}
+function number(value) {
+	return typeof value === "number" && !Number.isNaN(value) ? value : void 0;
+}
+function concat(...values) {
+	if (values.some((value) => value === Symbol.for("html-next.invalid-result"))) return Symbol.for("html-next.invalid-result");
+	if (values.some((value) => value === void 0)) return void 0;
+	if (values.length === 0 || values.some((value) => typeof value === "object" && value !== null)) return Symbol.for("html-next.invalid-result");
+	return values.map((value) => value === null ? "" : String(value)).join("");
+}
+function math(fn, kinds, values) {
+	if (values.includes(Symbol.for("html-next.invalid-result"))) return Symbol.for("html-next.invalid-result");
+	if (values.some((value) => value === void 0 || value === null)) return void 0;
+	if ((fn === "abs" || fn === "negate") && values.length !== 1 || fn === "round" && (values.length < 1 || values.length > 2) || (fn === "min" || fn === "max") && values.length === 0 || fn === "clamp" && values.length !== 3) return Symbol.for("html-next.invalid-result");
+	const kind = kinds[0];
+	const dimensional = kind === "length" || kind === "percentage" || kind === "duration";
+	if (!dimensional && kind !== "number") return Symbol.for("html-next.invalid-result");
+	let unit;
+	const numbers = [];
+	for (let index = 0; index < values.length; index++) {
+		if (kinds[index] !== kind) return Symbol.for("html-next.invalid-result");
+		const value = values[index];
+		if (!dimensional) {
+			if (typeof value !== "number" || !Number.isFinite(value)) return Symbol.for("html-next.invalid-result");
+			numbers.push(value);
+			continue;
+		}
+		if (typeof value !== "string") return Symbol.for("html-next.invalid-result");
+		const match = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(vmin|vmax|rem|px|em|vw|vh|ch|ex|cm|mm|in|pt|pc|q|ms|s|%)$/.exec(value);
+		if (match === null || unit !== void 0 && match[2] !== unit) return Symbol.for("html-next.invalid-result");
+		unit = match[2];
+		if ((unit === "%" ? "percentage" : unit === "ms" || unit === "s" ? "duration" : "length") !== kind) return Symbol.for("html-next.invalid-result");
+		const number = Number(match[1]);
+		if (!Number.isFinite(number)) return Symbol.for("html-next.invalid-result");
+		numbers.push(number);
+	}
+	let result;
+	switch (fn) {
+		case "abs":
+			result = Math.abs(numbers[0]);
+			break;
+		case "negate":
+			result = -numbers[0];
+			break;
+		case "round": {
+			const step = Math.abs(numbers[1] ?? 1);
+			if (step === 0) return Symbol.for("html-next.invalid-result");
+			result = Math.round(numbers[0] / step) * step;
+			break;
+		}
+		case "min":
+			result = Math.min(...numbers);
+			break;
+		case "max":
+			result = Math.max(...numbers);
+			break;
+		case "clamp":
+			result = Math.max(numbers[0], Math.min(numbers[1], numbers[2]));
+			break;
+		default: return Symbol.for("html-next.invalid-result");
+	}
+	return !Number.isFinite(result) ? Symbol.for("html-next.invalid-result") : unit === void 0 ? result : String(result) + unit;
+}
+function uniqueKeys(items, keyOf) {
+	const seen = /* @__PURE__ */ new Set();
+	for (let index = 0; index < items.length; index += 1) {
+		const key = keyOf(items[index], index, {
+			index,
+			first: index === 0,
+			last: index === items.length - 1,
+			count: items.length
+		});
+		if (seen.has(key)) {
+			const message = `A keyed list produced duplicate key \`${text(key)}\`.`;
+			throw Object.assign(/* @__PURE__ */ new Error(`HR004: ${message}`), {
+				name: "HtmlDiagnosticError",
+				diagnostic: Object.freeze({
+					code: "HR004",
+					message
+				})
+			});
+		}
+		seen.add(key);
+	}
+	return items;
+}
+/**
+* Digits after the point in `value`'s shortest round-trip text, as `Number#toString` writes it:
+* 2 for 1.25, 7 for 1e-7, and 0 for an integer, 1e21, NaN or Infinity. Writing that text made an
+* addition about ten times slower (200 ns against 20 ns), so up to 22 places, where 10^places is
+* exact, the fewest places at which `value` survives rounding stand in for it. That count is never
+* below the text's, and differs only for a value of more than 15 significant digits, which
+* `decimalResult` leaves as a double either way.
+*/
+function decimalPlaces(value) {
+	if (Number.isInteger(value)) return 0;
+	for (let places = 1; places <= 22; places += 1) if (Math.round(value * 10 ** places) / 10 ** places === value) return places;
+	const [digits, exponent] = String(value).split("e");
+	const point = digits.indexOf(".");
+	return Math.max(0, (point < 0 ? 0 : digits.length - point - 1) - Number(exponent ?? 0));
+}
+/**
+* The double nearest the exact decimal result: `a` and `b` become integers at `left` and `right`
+* places, `combine` joins them, and the integer is read back at `places`. Every step is exact while
+* the operands and `result` stay below 10^15 at `places`, the 15 significant digits a double always
+* holds; past that (or for a non-finite value, or with no places) the double `result` stands.
+* Dividing by 10^places is exact only up to 10^22, so past 22 places a nonzero integer is read back
+* by parsing its decimal text, which rounds exactly too. A zero divides, keeping its sign.
+*/
+function decimalResult(result, a, b, left, right, places, combine) {
+	if (!(places > 0 && Math.max(Math.abs(a), Math.abs(b), Math.abs(result)) * 10 ** places < 0x38d7ea4c68000)) return result;
+	const integer = combine(Math.round(a * 10 ** left), Math.round(b * 10 ** right));
+	return places > 22 && integer !== 0 ? Number(`${integer}e-${places}`) : integer / 10 ** places;
+}
+/** `a - b` at the larger operand's decimal places: `decimalSubtract(0.3, 0.1)` is 0.2. */
+function decimalSubtract(a, b) {
+	const places = Math.max(decimalPlaces(a), decimalPlaces(b));
+	return decimalResult(a - b, a, b, places, places, places, (x, y) => x - y);
+}
+/** `a * b` at the sum of the operands' decimal places: `decimalMultiply(0.1, 0.2)` is 0.02. */
+function decimalMultiply(a, b) {
+	const left = decimalPlaces(a);
+	const right = decimalPlaces(b);
+	return decimalResult(a * b, a, b, left, right, left + right, (x, y) => x * y);
+}
+function createFormatValue() {
+	const cache = /* @__PURE__ */ new Map();
+	function formatterFor(name, locale, options) {
+		const constructor = Reflect.get(Intl, name);
+		if (name === "DateTimeFormat" && options.timeZone === void 0) return new constructor(locale, options);
+		const entries = [];
+		for (const key of Object.keys(options).sort()) {
+			const value = options[key];
+			if (value === void 0) continue;
+			if (value !== null && typeof value !== "string" && typeof value !== "boolean" && typeof value !== "number" || typeof value === "number" && !Number.isFinite(value)) return new constructor(locale, options);
+			entries.push([
+				key,
+				typeof value,
+				Object.is(value, -0) ? "-0" : value
+			]);
+		}
+		const language = locale === void 0 && typeof navigator !== "undefined" ? navigator.language : void 0;
+		const key = JSON.stringify([
+			name,
+			locale,
+			language,
+			entries
+		]);
+		if (key.length > 4096) return new constructor(locale, options);
+		const cached = cache.get(key);
+		if (cached !== void 0 && cached.constructor === constructor) return cached.value;
+		const value = new constructor(locale, options);
+		if (cache.size >= 128 && !cache.has(key)) cache.delete(cache.keys().next().value);
+		cache.set(key, {
+			constructor,
+			value
+		});
+		return value;
+	}
+	/**
+	* The native Intl adapter. Self-contained so converters emit this same implementation only when
+	* authored expressions use formatting, without importing the live parser or interpreter.
+	* undefined is absence; the shared invalid-result symbol tells each target to retain its output.
+	*/
+	return function formatValue(value, inputType, operation, ...args) {
+		const invalid = Symbol.for("html-next.invalid-result");
+		if (value === invalid || args.includes(invalid)) return invalid;
+		if (value === void 0 || value === null || args.some((arg) => arg === void 0)) return;
+		const end = operation === "formatRange" ? args.shift() : void 0;
+		if (operation === "formatRange" && (end === null || end === void 0)) return;
+		const format = typeof args[0] === "string" ? args.shift() : Reflect.get({
+			number: "number",
+			integer: "number",
+			percentage: "percent",
+			date: "date",
+			time: "time",
+			datetime: "dateTime",
+			"datetime-local": "dateTime",
+			duration: "duration",
+			list: "list"
+		}, inputType ?? "");
+		const options = args.length > 0 ? args.shift() : {};
+		const locale = args.shift();
+		if (args.length > 0 || !format || options === null || typeof options !== "object" || Array.isArray(options) || locale !== void 0 && typeof locale !== "string") return invalid;
+		try {
+			const durationFields = [
+				"years",
+				"months",
+				"weeks",
+				"days",
+				"hours",
+				"minutes",
+				"seconds",
+				"milliseconds",
+				"microseconds",
+				"nanoseconds"
+			];
+			const settings = { ...options };
+			let formatter;
+			let input = value;
+			let last = end;
+			let zoneFree = false;
+			if ([
+				"number",
+				"currency",
+				"percent",
+				"unit"
+			].includes(format)) {
+				if (format !== "number") {
+					if (settings.style !== void 0 && settings.style !== format) return invalid;
+					settings.style = format;
+				}
+				const quantity = (candidate) => {
+					if (inputType === "percentage" && typeof candidate === "string" && /^-?(?:\d+(?:\.\d+)?|\.\d+)%$/.test(candidate)) return Number(candidate.slice(0, -1)) / 100;
+					return candidate;
+				};
+				input = quantity(input);
+				last = quantity(last);
+				if (typeof input !== "number" || !Number.isFinite(input) || operation === "formatRange" && (typeof last !== "number" || !Number.isFinite(last))) return invalid;
+				formatter = formatterFor("NumberFormat", locale, settings);
+			} else if ([
+				"date",
+				"time",
+				"dateTime"
+			].includes(format)) {
+				const civil = inputType === "date" || inputType === "time" || inputType === "datetime-local" || typeof input === "string" && !/(?:Z|[+-]\d\d:\d\d)$/.test(input);
+				zoneFree = civil;
+				if (civil && (settings.timeZone !== void 0 || settings.timeZoneName !== void 0)) return invalid;
+				if (format === "date" && (settings.timeStyle !== void 0 || [
+					"hour",
+					"minute",
+					"second",
+					"dayPeriod",
+					"fractionalSecondDigits"
+				].some((key) => settings[key] !== void 0)) || format === "time" && (settings.dateStyle !== void 0 || [
+					"year",
+					"month",
+					"day",
+					"weekday",
+					"era"
+				].some((key) => settings[key] !== void 0))) return invalid;
+				if (settings.dateStyle === void 0 && settings.timeStyle === void 0 && ![
+					"year",
+					"month",
+					"day",
+					"weekday",
+					"era",
+					"hour",
+					"minute",
+					"second",
+					"dayPeriod",
+					"fractionalSecondDigits"
+				].some((key) => settings[key] !== void 0)) {
+					if (format !== "time") settings.dateStyle = "medium";
+					if (format !== "date") settings.timeStyle = "medium";
+				}
+				if (civil) settings.timeZone = "UTC";
+				const asDate = (candidate) => {
+					if (typeof candidate === "number" && Number.isFinite(candidate)) return new Date(candidate);
+					if (typeof candidate !== "string") return;
+					let written = candidate.replace(" ", "T");
+					if (/^\d\d:\d\d(?::\d\d(?:\.\d{1,3})?)?$/.test(written)) {
+						if (format !== "time") return;
+						written = "1970-01-01T" + written + "Z";
+					} else if (/^\d{4,}-\d\d-\d\d$/.test(written)) {
+						if (format !== "date") return;
+						written += "T00:00:00Z";
+					} else if (/^\d{4,}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d{1,3})?)?$/.test(written)) written += "Z";
+					else if (!/^\d{4,}-\d\d-\d\dT\d\d:\d\d(?::\d\d(?:\.\d{1,3})?)?(?:Z|[+-]\d\d:\d\d)$/.test(written)) return;
+					const date = new Date(written.replace(/^(\d{5,})-/, (_match, year) => "+" + year.padStart(6, "0") + "-"));
+					if (!Number.isFinite(date.getTime())) return;
+					const match = /^(\d{4,})-(\d\d)-(\d\d)T(\d\d):(\d\d)(?::(\d\d))?/.exec(written);
+					if (!match) return;
+					const probe = /* @__PURE__ */ new Date(0);
+					probe.setUTCFullYear(Number(match[1]), Number(match[2]) - 1, Number(match[3]));
+					if (Number(match[1]) === 0 || probe.getUTCMonth() !== Number(match[2]) - 1 || probe.getUTCDate() !== Number(match[3]) || Number(match[4]) > 23 || Number(match[5]) > 59 || Number(match[6] ?? 0) > 59) return;
+					return date;
+				};
+				input = asDate(input);
+				last = operation === "formatRange" ? asDate(last) : void 0;
+				if (!input || operation === "formatRange" && !last) return invalid;
+				formatter = formatterFor("DateTimeFormat", locale, settings);
+			} else {
+				if (operation === "formatRange") return invalid;
+				if (format === "relativeTime") {
+					if (typeof input !== "number" || !Number.isFinite(input) || typeof settings.unit !== "string") return invalid;
+					const unit = settings.unit;
+					delete settings.unit;
+					formatter = formatterFor("RelativeTimeFormat", locale, settings);
+					return operation === "formatParts" ? formatter.formatToParts(input, unit) : formatter.format(input, unit);
+				}
+				if (format === "list") {
+					if (!Array.isArray(input) || input.some((item) => typeof item !== "string")) return invalid;
+					formatter = formatterFor("ListFormat", locale, settings);
+				} else if (format === "duration") {
+					if (inputType === "duration" && typeof input === "string") {
+						const match = /^(-?(?:\d+(?:\.\d+)?|\.\d+))(ms|s)$/.exec(input);
+						if (!match) return invalid;
+						const milliseconds = Number(match[1]) * (match[2] === "s" ? 1e3 : 1);
+						if (!Number.isFinite(milliseconds)) return invalid;
+						input = {
+							hours: Math.trunc(milliseconds / 36e5),
+							minutes: Math.trunc(milliseconds % 36e5 / 6e4),
+							seconds: Math.trunc(milliseconds % 6e4 / 1e3),
+							milliseconds: Math.trunc(milliseconds % 1e3),
+							microseconds: Math.trunc((milliseconds - Math.trunc(milliseconds)) * 1e3),
+							nanoseconds: Math.round((milliseconds * 1e3 - Math.trunc(milliseconds * 1e3)) * 1e3)
+						};
+					}
+					if (input === null || typeof input !== "object" || Array.isArray(input) || Object.keys(input).some((key) => !durationFields.includes(key))) return invalid;
+					if (!Reflect.get(Intl, "DurationFormat")) return invalid;
+					formatter = formatterFor("DurationFormat", locale, settings);
+				} else if (format === "displayName") {
+					if (typeof input !== "string" || operation === "formatParts") return invalid;
+					return formatterFor("DisplayNames", locale, settings).of(input);
+				} else if (format === "plural") {
+					if (typeof input !== "number" || !Number.isFinite(input) || operation === "formatParts") return invalid;
+					const forms = settings.forms;
+					if (!forms || typeof forms !== "object" || Array.isArray(forms) || typeof forms.other !== "string" || Object.entries(forms).some(([key, entry]) => ![
+						"zero",
+						"one",
+						"two",
+						"few",
+						"many",
+						"other"
+					].includes(key) || typeof entry !== "string")) return invalid;
+					delete settings.forms;
+					const message = forms[formatterFor("PluralRules", locale, settings).select(input)] ?? forms.other;
+					const numberOptions = { ...settings };
+					delete numberOptions.type;
+					delete numberOptions.forms;
+					const number = formatterFor("NumberFormat", locale, numberOptions).format(input);
+					return message.replace(/#/g, () => number);
+				}
+			}
+			if (!zoneFree && operation !== "formatParts") return operation === "formatRange" ? formatter.formatRange(input, last) : formatter.format(input);
+			const parts = operation === "formatRange" ? formatter.formatRangeToParts(input, last) : formatter.formatToParts(input);
+			if (zoneFree && operation !== "formatParts" && !parts.some((part) => part.type === "timeZoneName")) return operation === "formatRange" ? formatter.formatRange(input, last) : formatter.format(input);
+			const visible = zoneFree ? parts.filter((part, index) => part.type !== "timeZoneName" && !(part.type === "literal" && /^[\s(),]*$/.test(part.value) && (parts[index - 1]?.type === "timeZoneName" || parts[index + 1]?.type === "timeZoneName"))) : parts;
+			return operation === "formatParts" ? visible : visible.map((part) => part.value).join("");
+		} catch {
+			return invalid;
+		}
+	};
+}
+var formatValue = /* @__PURE__ */ createFormatValue();
+//#endregion
 //#region \0plugin-vue:export-helper
 var _plugin_vue_export_helper_default = (sfc, props) => {
 	const target = sfc.__vccOpts || sfc;
@@ -5,4 +908,4 @@ var _plugin_vue_export_helper_default = (sfc, props) => {
 	return target;
 };
 //#endregion
-export { _plugin_vue_export_helper_default as t };
+export { useComponentHost as _, concat as a, decimalMultiply as c, list as d, math as f, uniqueKeys as g, preserveRootFocus as h, checkHydratedRoot as i, decimalSubtract as l, number as m, KeyedBoundary as n, createDispatch as o, nativeAttrs as p, attribute as r, cycleCheckedComputed as s, _plugin_vue_export_helper_default as t, formatValue as u, useReflectedProp as v, warnUnless as y };