@svgrid/enterprise 2.3.2 → 2.5.0

package/src/studio/node_modules/.vite/vitest/be65d27ae088a0e03fd8e1331d90b01649464cb6/deps___vitest__/legacy-client-DeSQgSFm.js

@@ -0,0 +1,697 @@
+import { $ as get_next_sibling, J as create_element, K as clear_text_content, Lt as flushSync, Mn as hydration_failed, Q as get_first_child, Tn as set_hydrating, X as create_text, Xn as LEGACY_PROPS, Y as create_fragment, Yn as IS_XHTML, _ as component_root, _n as hydrate_next, ar as define_property, bn as hydrating, cn as pop, dt as mutable_source, er as STATE_SYMBOL, et as init_operations, in as component_context, jt as boundary, ln as push, n as active_effect, nr as TEXT_CACHE, nt as merge_text_nodes, o as get, pt as set, q as create_comment, rr as array_from, rt as set_attribute, tt as is_firefox, vn as hydrate_node, wn as set_hydrate_node } from "./utils-BbWyXNk1.js";
+import { t as async_mode_flag } from "./flags-X7D4vfrZ.js";
+import { c as NAMESPACE_SVG, i as HYDRATION_ERROR, s as NAMESPACE_MATHML } from "./constants-B9vgIdCd.js";
+import { d as is_passive_event } from "./utils-DI_fC7vt.js";
+import { d as lifecycle_double_unmount, g as state_proxy_unmount, u as hydration_mismatch } from "./warnings-CUbSPnyP.js";
+import { s as handle_event_propagation, t as all_registered_events, u as root_event_handles } from "./events-Bo11SfVK.js";
+//#region ../../../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.67.0/node_modules/svelte/src/internal/client/dom/reconciler.js
+var policy = globalThis?.window?.trustedTypes && /* @__PURE__ */ globalThis.window.trustedTypes.createPolicy("svelte-trusted-html", { 
+/** @param {string} html */
+createHTML: (html) => {
+	return html;
+} });
+/** @param {string} html */
+function create_trusted_html(html) {
+	return policy?.createHTML(html) ?? html;
+}
+/**
+* @param {string} html
+*/
+function create_fragment_from_html(html) {
+	var elem = create_element("template");
+	elem.innerHTML = create_trusted_html(html.replaceAll("<!>", "<!---->"));
+	return elem.content;
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.67.0/node_modules/svelte/src/internal/client/dom/template.js
+/** @import { Effect, EffectNodes, TemplateNode } from '#client' */
+/** @import { TemplateStructure } from './types' */
+var TEMPLATE_TAG = IS_XHTML ? "template" : "TEMPLATE";
+var SCRIPT_TAG = IS_XHTML ? "script" : "SCRIPT";
+/**
+* @param {TemplateNode} start
+* @param {TemplateNode | null} end
+*/
+function assign_nodes(start, end) {
+	var effect = active_effect;
+	if (effect.nodes === null) effect.nodes = {
+		start,
+		end,
+		a: null,
+		t: null
+	};
+}
+/**
+* @param {string} content
+* @param {number} flags
+* @returns {() => Node | Node[]}
+*/
+/*#__NO_SIDE_EFFECTS__*/
+function from_html(content, flags) {
+	var is_fragment = (flags & 1) !== 0;
+	var use_import_node = (flags & 2) !== 0;
+	/** @type {Node} */
+	var node;
+	/**
+	* Whether or not the first item is a text/element node. If not, we need to
+	* create an additional comment node to act as `effect.nodes.start`
+	*/
+	var has_start = !content.startsWith("<!>");
+	return () => {
+		if (hydrating) {
+			assign_nodes(hydrate_node, null);
+			return hydrate_node;
+		}
+		if (node === void 0) {
+			node = create_fragment_from_html(has_start ? content : "<!>" + content);
+			if (!is_fragment) node = /* @__PURE__ */ get_first_child(node);
+		}
+		var clone = use_import_node || is_firefox ? document.importNode(node, true) : node.cloneNode(true);
+		if (is_fragment) {
+			var start = /* @__PURE__ */ get_first_child(clone);
+			var end = clone.lastChild;
+			assign_nodes(start, end);
+		} else assign_nodes(clone, clone);
+		return clone;
+	};
+}
+/**
+* @param {string} content
+* @param {number} flags
+* @param {'svg' | 'math'} ns
+* @returns {() => Node | Node[]}
+*/
+/*#__NO_SIDE_EFFECTS__*/
+function from_namespace(content, flags, ns = "svg") {
+	/**
+	* Whether or not the first item is a text/element node. If not, we need to
+	* create an additional comment node to act as `effect.nodes.start`
+	*/
+	var has_start = !content.startsWith("<!>");
+	var is_fragment = (flags & 1) !== 0;
+	var wrapped = `<${ns}>${has_start ? content : "<!>" + content}</${ns}>`;
+	/** @type {Element | DocumentFragment} */
+	var node;
+	return () => {
+		if (hydrating) {
+			assign_nodes(hydrate_node, null);
+			return hydrate_node;
+		}
+		if (!node) {
+			var fragment = create_fragment_from_html(wrapped);
+			var root = /* @__PURE__ */ get_first_child(fragment);
+			if (is_fragment) {
+				node = document.createDocumentFragment();
+				while (/* @__PURE__ */ get_first_child(root)) node.appendChild(/* @__PURE__ */ get_first_child(root));
+			} else node = /* @__PURE__ */ get_first_child(root);
+		}
+		var clone = node.cloneNode(true);
+		if (is_fragment) {
+			var start = /* @__PURE__ */ get_first_child(clone);
+			var end = clone.lastChild;
+			assign_nodes(start, end);
+		} else assign_nodes(clone, clone);
+		return clone;
+	};
+}
+/**
+* @param {string} content
+* @param {number} flags
+*/
+/*#__NO_SIDE_EFFECTS__*/
+function from_svg(content, flags) {
+	return /* @__PURE__ */ from_namespace(content, flags, "svg");
+}
+/**
+* @param {string} content
+* @param {number} flags
+*/
+/*#__NO_SIDE_EFFECTS__*/
+function from_mathml(content, flags) {
+	return /* @__PURE__ */ from_namespace(content, flags, "math");
+}
+/**
+* @param {TemplateStructure[]} structure
+* @param {typeof NAMESPACE_SVG | typeof NAMESPACE_MATHML | undefined} [ns]
+*/
+function fragment_from_tree(structure, ns) {
+	var fragment = create_fragment();
+	for (var item of structure) {
+		if (typeof item === "string") {
+			fragment.append(create_text(item));
+			continue;
+		}
+		if (item === void 0 || item[0][0] === "/") {
+			fragment.append(create_comment(item ? item[0].slice(3) : ""));
+			continue;
+		}
+		const [name, attributes, ...children] = item;
+		const namespace = name === "svg" ? NAMESPACE_SVG : name === "math" ? NAMESPACE_MATHML : ns;
+		var element = create_element(name, namespace, attributes?.is);
+		for (var key in attributes) set_attribute(element, key, attributes[key]);
+		if (children.length > 0) (element.nodeName === TEMPLATE_TAG ? element.content : element).append(fragment_from_tree(children, element.nodeName === "foreignObject" ? void 0 : namespace));
+		fragment.append(element);
+	}
+	return fragment;
+}
+/**
+* @param {TemplateStructure[]} structure
+* @param {number} flags
+* @returns {() => Node | Node[]}
+*/
+/*#__NO_SIDE_EFFECTS__*/
+function from_tree(structure, flags) {
+	var is_fragment = (flags & 1) !== 0;
+	var use_import_node = (flags & 2) !== 0;
+	/** @type {Node} */
+	var node;
+	return () => {
+		if (hydrating) {
+			assign_nodes(hydrate_node, null);
+			return hydrate_node;
+		}
+		if (node === void 0) {
+			node = fragment_from_tree(structure, (flags & 4) !== 0 ? NAMESPACE_SVG : (flags & 8) !== 0 ? NAMESPACE_MATHML : void 0);
+			if (!is_fragment) node = /* @__PURE__ */ get_first_child(node);
+		}
+		var clone = use_import_node || is_firefox ? document.importNode(node, true) : node.cloneNode(true);
+		if (is_fragment) {
+			var start = /* @__PURE__ */ get_first_child(clone);
+			var end = clone.lastChild;
+			assign_nodes(start, end);
+		} else assign_nodes(clone, clone);
+		return clone;
+	};
+}
+/**
+* @param {() => Element | DocumentFragment} fn
+*/
+function with_script(fn) {
+	return () => run_scripts(fn());
+}
+/**
+* Creating a document fragment from HTML that contains script tags will not execute
+* the scripts. We need to replace the script tags with new ones so that they are executed.
+* @param {Element | DocumentFragment} node
+* @returns {Node | Node[]}
+*/
+function run_scripts(node) {
+	if (hydrating) return node;
+	const is_fragment = node.nodeType === 11;
+	const scripts = node.nodeName === SCRIPT_TAG ? [node] : node.querySelectorAll("script");
+	const effect = active_effect;
+	for (const script of scripts) {
+		const clone = create_element("script");
+		for (var attribute of script.attributes) clone.setAttribute(attribute.name, attribute.value);
+		clone.textContent = script.textContent;
+		if (is_fragment ? node.firstChild === script : node === script) effect.nodes.start = clone;
+		if (is_fragment ? node.lastChild === script : node === script) effect.nodes.end = clone;
+		script.replaceWith(clone);
+	}
+	return node;
+}
+/**
+* Don't mark this as side-effect-free, hydration needs to walk all nodes
+* @param {any} value
+*/
+function text(value = "") {
+	if (!hydrating) {
+		var t = create_text(value + "");
+		assign_nodes(t, t);
+		return t;
+	}
+	var node = hydrate_node;
+	if (node.nodeType !== 3) {
+		node.before(node = create_text());
+		set_hydrate_node(node);
+	} else merge_text_nodes(node);
+	assign_nodes(node, node);
+	return node;
+}
+/**
+* @returns {TemplateNode | DocumentFragment}
+*/
+function comment() {
+	if (hydrating) {
+		assign_nodes(hydrate_node, null);
+		return hydrate_node;
+	}
+	var frag = document.createDocumentFragment();
+	var start = document.createComment("");
+	var anchor = create_text();
+	frag.append(start, anchor);
+	assign_nodes(start, anchor);
+	return frag;
+}
+/**
+* Assign the created (or in hydration mode, traversed) dom elements to the current block
+* and insert the elements into the dom (in client mode).
+* @param {Text | Comment | Element} anchor
+* @param {DocumentFragment | Element} dom
+*/
+function append(anchor, dom) {
+	if (hydrating) {
+		var effect = active_effect;
+		if ((effect.f & 32768) === 0 || effect.nodes.end === null) effect.nodes.end = hydrate_node;
+		hydrate_next();
+		return;
+	}
+	if (anchor === null) return;
+	anchor.before(dom);
+}
+/**
+* Create (or hydrate) an unique UID for the component instance.
+*/
+function props_id() {
+	if (hydrating && hydrate_node && hydrate_node.nodeType === 8 && hydrate_node.textContent?.startsWith(`$`)) {
+		const id = hydrate_node.textContent.substring(1);
+		hydrate_next();
+		return id;
+	}
+	(window.__svelte ??= {}).uid ??= 1;
+	return `c${window.__svelte.uid++}`;
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.67.0/node_modules/svelte/src/internal/client/render.js
+/** @import { ComponentContext, Effect, EffectNodes, TemplateNode } from '#client' */
+/** @import { Component, ComponentType, SvelteComponent, MountOptions } from '../../index.js' */
+/**
+* This is normally true — block effects should run their intro transitions —
+* but is false during hydration (unless `options.intro` is `true`) and
+* when creating the children of a `<svelte:element>` that just changed tag
+*/
+var should_intro = true;
+/** @param {boolean} value */
+function set_should_intro(value) {
+	should_intro = value;
+}
+/**
+* @param {Element} text
+* @param {string} value
+* @returns {void}
+*/
+function set_text(text, value) {
+	var str = value == null ? "" : typeof value === "object" ? `${value}` : value;
+	if (str !== (text[TEXT_CACHE] ??= text.nodeValue)) {
+		/** @type {any} */ text[TEXT_CACHE] = str;
+		text.nodeValue = `${str}`;
+	}
+}
+/**
+* Mounts a component to the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component.
+* Transitions will play during the initial render unless the `intro` option is set to `false`.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
+* @param {MountOptions<Props>} options
+* @returns {Exports}
+*/
+function mount(component, options) {
+	return _mount(component, options);
+}
+/**
+* Hydrates a component on the given target and returns the exports and potentially the props (if compiled with `accessors: true`) of the component
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<Props>> | Component<Props, Exports, any>} component
+* @param {{} extends Props ? {
+* 		target: Document | Element | ShadowRoot;
+* 		props?: Props;
+* 		events?: Record<string, (e: any) => any>;
+*  	context?: Map<any, any>;
+* 		intro?: boolean;
+* 		recover?: boolean;
+*		transformError?: (error: unknown) => unknown;
+* 	} : {
+* 		target: Document | Element | ShadowRoot;
+* 		props: Props;
+* 		events?: Record<string, (e: any) => any>;
+*  	context?: Map<any, any>;
+* 		intro?: boolean;
+* 		recover?: boolean;
+*		transformError?: (error: unknown) => unknown;
+* 	}} options
+* @returns {Exports}
+*/
+function hydrate(component, options) {
+	init_operations();
+	options.intro = options.intro ?? false;
+	const target = options.target;
+	const was_hydrating = hydrating;
+	const previous_hydrate_node = hydrate_node;
+	try {
+		var anchor = /* @__PURE__ */ get_first_child(target);
+		while (anchor && (anchor.nodeType !== 8 || anchor.data !== "[")) anchor = /* @__PURE__ */ get_next_sibling(anchor);
+		if (!anchor) throw HYDRATION_ERROR;
+		set_hydrating(true);
+		set_hydrate_node(anchor);
+		const instance = _mount(component, {
+			...options,
+			anchor
+		});
+		set_hydrating(false);
+		return instance;
+	} catch (error) {
+		if (error instanceof Error && error.message.split("\n").some((line) => line.startsWith("https://svelte.dev/e/"))) throw error;
+		if (error !== HYDRATION_ERROR) console.warn("Failed to hydrate: ", error);
+		if (options.recover === false) hydration_failed();
+		init_operations();
+		clear_text_content(target);
+		set_hydrating(false);
+		return mount(component, options);
+	} finally {
+		set_hydrating(was_hydrating);
+		set_hydrate_node(previous_hydrate_node);
+	}
+}
+/** @type {Map<EventTarget, Map<string, number>>} */
+var listeners = /* @__PURE__ */ new Map();
+/**
+* @template {Record<string, any>} Exports
+* @param {ComponentType<SvelteComponent<any>> | Component<any>} Component
+* @param {MountOptions} options
+* @returns {Exports}
+*/
+function _mount(Component, { target, anchor, props = {}, events, context, intro = true, transformError }) {
+	init_operations();
+	/** @type {Exports} */
+	var component = void 0;
+	var unmount = component_root(() => {
+		var anchor_node = anchor ?? target.appendChild(create_text());
+		boundary(anchor_node, { pending: () => {} }, (anchor_node) => {
+			push({});
+			var ctx = component_context;
+			if (context) ctx.c = context;
+			if (events)
+ /** @type {any} */ props.$$events = events;
+			if (hydrating) assign_nodes(anchor_node, null);
+			should_intro = intro;
+			component = Component(anchor_node, props) || {};
+			should_intro = true;
+			if (hydrating) {
+				/** @type {Effect & { nodes: EffectNodes }} */ active_effect.nodes.end = hydrate_node;
+				if (hydrate_node === null || hydrate_node.nodeType !== 8 || hydrate_node.data !== "]") {
+					hydration_mismatch();
+					throw HYDRATION_ERROR;
+				}
+			}
+			pop();
+		}, transformError);
+		/** @type {Set<string>} */
+		var registered_events = /* @__PURE__ */ new Set();
+		/** @param {Array<string>} events */
+		var event_handle = (events) => {
+			for (var i = 0; i < events.length; i++) {
+				var event_name = events[i];
+				if (registered_events.has(event_name)) continue;
+				registered_events.add(event_name);
+				var passive = is_passive_event(event_name);
+				for (const node of [target, document]) {
+					var counts = listeners.get(node);
+					if (counts === void 0) {
+						counts = /* @__PURE__ */ new Map();
+						listeners.set(node, counts);
+					}
+					var count = counts.get(event_name);
+					if (count === void 0) {
+						node.addEventListener(event_name, handle_event_propagation, { passive });
+						counts.set(event_name, 1);
+					} else counts.set(event_name, count + 1);
+				}
+			}
+		};
+		event_handle(array_from(all_registered_events));
+		root_event_handles.add(event_handle);
+		return () => {
+			for (var event_name of registered_events) for (const node of [target, document]) {
+				var counts = listeners.get(node);
+				var count = counts.get(event_name);
+				if (--count == 0) {
+					node.removeEventListener(event_name, handle_event_propagation);
+					counts.delete(event_name);
+					if (counts.size === 0) listeners.delete(node);
+				} else counts.set(event_name, count);
+			}
+			root_event_handles.delete(event_handle);
+			if (anchor_node !== anchor) anchor_node.parentNode?.removeChild(anchor_node);
+		};
+	});
+	mounted_components.set(component, unmount);
+	return component;
+}
+/**
+* References of the components that were mounted or hydrated.
+* Uses a `WeakMap` to avoid memory leaks.
+*/
+var mounted_components = /* @__PURE__ */ new WeakMap();
+/**
+* Unmounts a component that was previously mounted using `mount` or `hydrate`.
+*
+* Since 5.13.0, if `options.outro` is `true`, [transitions](https://svelte.dev/docs/svelte/transition) will play before the component is removed from the DOM.
+*
+* Returns a `Promise` that resolves after transitions have completed if `options.outro` is true, or immediately otherwise (prior to 5.13.0, returns `void`).
+*
+* ```js
+* import { mount, unmount } from 'svelte';
+* import App from './App.svelte';
+*
+* const app = mount(App, { target: document.body });
+*
+* // later...
+* unmount(app, { outro: true });
+* ```
+* @param {Record<string, any>} component
+* @param {{ outro?: boolean }} [options]
+* @returns {Promise<void>}
+*/
+function unmount(component, options) {
+	const fn = mounted_components.get(component);
+	if (fn) {
+		mounted_components.delete(component);
+		return fn(options);
+	}
+	if (STATE_SYMBOL in component) state_proxy_unmount();
+	else lifecycle_double_unmount();
+	return Promise.resolve();
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.67.0/node_modules/svelte/src/internal/client/dom/legacy/event-modifiers.js
+/**
+* Substitute for the `trusted` event modifier
+* @deprecated
+* @param {(event: Event, ...args: Array<unknown>) => void} fn
+* @returns {(event: Event, ...args: unknown[]) => void}
+*/
+function trusted(fn) {
+	return function(...args) {
+		if (args[0].isTrusted) fn?.apply(this, args);
+	};
+}
+/**
+* Substitute for the `self` event modifier
+* @deprecated
+* @param {(event: Event, ...args: Array<unknown>) => void} fn
+* @returns {(event: Event, ...args: unknown[]) => void}
+*/
+function self(fn) {
+	return function(...args) {
+		if (args[0].target === this) fn?.apply(this, args);
+	};
+}
+/**
+* Substitute for the `stopPropagation` event modifier
+* @deprecated
+* @param {(event: Event, ...args: Array<unknown>) => void} fn
+* @returns {(event: Event, ...args: unknown[]) => void}
+*/
+function stopPropagation(fn) {
+	return function(...args) {
+		args[0].stopPropagation();
+		return fn?.apply(this, args);
+	};
+}
+/**
+* Substitute for the `once` event modifier
+* @deprecated
+* @param {(event: Event, ...args: Array<unknown>) => void} fn
+* @returns {(event: Event, ...args: unknown[]) => void}
+*/
+function once(fn) {
+	var ran = false;
+	return function(...args) {
+		if (ran) return;
+		ran = true;
+		return fn?.apply(this, args);
+	};
+}
+/**
+* Substitute for the `stopImmediatePropagation` event modifier
+* @deprecated
+* @param {(event: Event, ...args: Array<unknown>) => void} fn
+* @returns {(event: Event, ...args: unknown[]) => void}
+*/
+function stopImmediatePropagation(fn) {
+	return function(...args) {
+		args[0].stopImmediatePropagation();
+		return fn?.apply(this, args);
+	};
+}
+/**
+* Substitute for the `preventDefault` event modifier
+* @deprecated
+* @param {(event: Event, ...args: Array<unknown>) => void} fn
+* @returns {(event: Event, ...args: unknown[]) => void}
+*/
+function preventDefault(fn) {
+	return function(...args) {
+		args[0].preventDefault();
+		return fn?.apply(this, args);
+	};
+}
+//#endregion
+//#region ../../../../node_modules/.pnpm/svelte@5.55.9_@typescript-eslint+types@8.67.0/node_modules/svelte/src/legacy/legacy-client.js
+/** @import { ComponentConstructorOptions, ComponentType, SvelteComponent, Component } from 'svelte' */
+/**
+* Takes the same options as a Svelte 4 component and the component function and returns a Svelte 4 compatible component.
+*
+* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @template {Record<string, any>} Events
+* @template {Record<string, any>} Slots
+*
+* @param {ComponentConstructorOptions<Props> & {
+* 	component: ComponentType<SvelteComponent<Props, Events, Slots>> | Component<Props>;
+* }} options
+* @returns {SvelteComponent<Props, Events, Slots> & Exports}
+*/
+function createClassComponent(options) {
+	return new Svelte4Component(options);
+}
+/**
+* Takes the component function and returns a Svelte 4 compatible component constructor.
+*
+* @deprecated Use this only as a temporary solution to migrate your imperative component code to Svelte 5.
+*
+* @template {Record<string, any>} Props
+* @template {Record<string, any>} Exports
+* @template {Record<string, any>} Events
+* @template {Record<string, any>} Slots
+*
+* @param {SvelteComponent<Props, Events, Slots> | Component<Props>} component
+* @returns {ComponentType<SvelteComponent<Props, Events, Slots> & Exports>}
+*/
+function asClassComponent(component) {
+	return class extends Svelte4Component {
+		/** @param {any} options */
+		constructor(options) {
+			super({
+				component,
+				...options
+			});
+		}
+	};
+}
+/**
+* Support using the component as both a class and function during the transition period
+* @typedef  {{new (o: ComponentConstructorOptions): SvelteComponent;(...args: Parameters<Component<Record<string, any>>>): ReturnType<Component<Record<string, any>, Record<string, any>>>;}} LegacyComponentType
+*/
+var Svelte4Component = class {
+	/** @type {any} */
+	#events;
+	/** @type {Record<string, any>} */
+	#instance;
+	/**
+	* @param {ComponentConstructorOptions & {
+	*  component: any;
+	* }} options
+	*/
+	constructor(options) {
+		var sources = /* @__PURE__ */ new Map();
+		/**
+		* @param {string | symbol} key
+		* @param {unknown} value
+		*/
+		var add_source = (key, value) => {
+			var s = /* @__PURE__ */ mutable_source(value, false, false);
+			sources.set(key, s);
+			return s;
+		};
+		const props = new Proxy({
+			...options.props || {},
+			$$events: {}
+		}, {
+			get(target, prop) {
+				return get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+			},
+			has(target, prop) {
+				if (prop === LEGACY_PROPS) return true;
+				get(sources.get(prop) ?? add_source(prop, Reflect.get(target, prop)));
+				return Reflect.has(target, prop);
+			},
+			set(target, prop, value) {
+				set(sources.get(prop) ?? add_source(prop, value), value);
+				return Reflect.set(target, prop, value);
+			}
+		});
+		this.#instance = (options.hydrate ? hydrate : mount)(options.component, {
+			target: options.target,
+			anchor: options.anchor,
+			props,
+			context: options.context,
+			intro: options.intro ?? false,
+			recover: options.recover,
+			transformError: options.transformError
+		});
+		if (!async_mode_flag && (!options?.props?.$$host || options.sync === false)) flushSync();
+		this.#events = props.$$events;
+		for (const key of Object.keys(this.#instance)) {
+			if (key === "$set" || key === "$destroy" || key === "$on") continue;
+			define_property(this, key, {
+				get() {
+					return this.#instance[key];
+				},
+				/** @param {any} value */
+				set(value) {
+					this.#instance[key] = value;
+				},
+				enumerable: true
+			});
+		}
+		this.#instance.$set = (next) => {
+			Object.assign(props, next);
+		};
+		this.#instance.$destroy = () => {
+			unmount(this.#instance);
+		};
+	}
+	/** @param {Record<string, any>} props */
+	$set(props) {
+		this.#instance.$set(props);
+	}
+	/**
+	* @param {string} event
+	* @param {(...args: any[]) => any} callback
+	* @returns {any}
+	*/
+	$on(event, callback) {
+		this.#events[event] = this.#events[event] || [];
+		/** @param {any[]} args */
+		const cb = (...args) => callback.call(this, ...args);
+		this.#events[event].push(cb);
+		return () => {
+			this.#events[event] = this.#events[event].filter(
+				/** @param {any} fn */
+				(fn) => fn !== cb
+			);
+		};
+	}
+	$destroy() {
+		this.#instance.$destroy();
+	}
+};
+//#endregion
+export { create_trusted_html as S, from_svg as _, self as a, text as b, trusted as c, should_intro as d, append as f, from_mathml as g, from_html as h, preventDefault as i, set_should_intro as l, comment as m, createClassComponent as n, stopImmediatePropagation as o, assign_nodes as p, once as r, stopPropagation as s, asClassComponent as t, set_text as u, from_tree as v, with_script as x, props_id as y };