@kubb/react-fabric 0.2.3 → 0.2.4

package/dist/plugins-9oisj5ko.cjs

@@ -0,0 +1,640 @@
+const require_chunk = require('./chunk-CUT6urMc.cjs');
+let react = require("react");
+react = require_chunk.__toESM(react);
+let react_jsx_runtime = require("react/jsx-runtime");
+react_jsx_runtime = require_chunk.__toESM(react_jsx_runtime);
+let __kubb_fabric_core_plugins = require("@kubb/fabric-core/plugins");
+__kubb_fabric_core_plugins = require_chunk.__toESM(__kubb_fabric_core_plugins);
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let react_reconciler_constants = require("react-reconciler/constants");
+react_reconciler_constants = require_chunk.__toESM(react_reconciler_constants);
+let signal_exit = require("signal-exit");
+signal_exit = require_chunk.__toESM(signal_exit);
+let react_reconciler = require("react-reconciler");
+react_reconciler = require_chunk.__toESM(react_reconciler);
+let __kubb_fabric_core_parsers_typescript = require("@kubb/fabric-core/parsers/typescript");
+__kubb_fabric_core_parsers_typescript = require_chunk.__toESM(__kubb_fabric_core_parsers_typescript);
+
+//#region \0@oxc-project+runtime@0.95.0/helpers/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o$1) {
+		return typeof o$1;
+	} : function(o$1) {
+		return o$1 && "function" == typeof Symbol && o$1.constructor === Symbol && o$1 !== Symbol.prototype ? "symbol" : typeof o$1;
+	}, _typeof(o);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/toPrimitive.js
+function toPrimitive(t, r) {
+	if ("object" != _typeof(t) || !t) return t;
+	var e = t[Symbol.toPrimitive];
+	if (void 0 !== e) {
+		var i = e.call(t, r || "default");
+		if ("object" != _typeof(i)) return i;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return ("string" === r ? String : Number)(t);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/defineProperty.js
+function _defineProperty(e, r, t) {
+	return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+		value: t,
+		enumerable: !0,
+		configurable: !0,
+		writable: !0
+	}) : e[r] = t, e;
+}
+
+//#endregion
+//#region src/components/Root.tsx
+var ErrorBoundary = class extends react.Component {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "state", { hasError: false });
+	}
+	static getDerivedStateFromError(_error) {
+		return { hasError: true };
+	}
+	componentDidCatch(error) {
+		if (error) this.props.onError(error);
+	}
+	render() {
+		if (this.state.hasError) return null;
+		return this.props.children;
+	}
+};
+_defineProperty(ErrorBoundary, "displayName", "KubbErrorBoundary");
+const RootContext = (0, react.createContext)({ exit: () => {} });
+function Root({ onError, onExit: onExit$1, children }) {
+	try {
+		return /* @__PURE__ */ (0, react_jsx_runtime.jsx)(ErrorBoundary, {
+			onError: (error) => {
+				onError(error);
+			},
+			children: /* @__PURE__ */ (0, react_jsx_runtime.jsx)(RootContext.Provider, {
+				value: { exit: onExit$1 },
+				children
+			})
+		});
+	} catch (_e) {
+		return null;
+	}
+}
+Root.Context = RootContext;
+Root.displayName = "KubbRoot";
+
+//#endregion
+//#region src/dom.ts
+const createNode = (nodeName) => {
+	return {
+		nodeName,
+		attributes: {},
+		childNodes: [],
+		parentNode: void 0
+	};
+};
+const appendChildNode = (node, childNode) => {
+	if (childNode.parentNode) removeChildNode(childNode.parentNode, childNode);
+	if (node.nodeName !== "#text") {
+		childNode.parentNode = node;
+		node.childNodes.push(childNode);
+	}
+};
+const insertBeforeNode = (node, newChildNode, beforeChildNode) => {
+	if (newChildNode.parentNode) removeChildNode(newChildNode.parentNode, newChildNode);
+	newChildNode.parentNode = node;
+	const index = node.childNodes.indexOf(beforeChildNode);
+	if (index >= 0) {
+		node.childNodes.splice(index, 0, newChildNode);
+		return;
+	}
+	node.childNodes.push(newChildNode);
+};
+const removeChildNode = (node, removeNode) => {
+	removeNode.parentNode = void 0;
+	const index = node.childNodes.indexOf(removeNode);
+	if (index >= 0) node.childNodes.splice(index, 1);
+};
+const setAttribute = (node, key, value) => {
+	node.attributes[key] = value;
+};
+const createTextNode = (text) => {
+	const node = {
+		nodeName: "#text",
+		nodeValue: text,
+		parentNode: void 0
+	};
+	setTextNodeValue(node, text);
+	return node;
+};
+const setTextNodeValue = (node, text) => {
+	if (typeof text !== "string") text = String(text);
+	node.nodeValue = text;
+};
+const nodeNames = [
+	"kubb-export",
+	"kubb-file",
+	"kubb-source",
+	"kubb-import",
+	"kubb-text"
+];
+
+//#endregion
+//#region src/Renderer.ts
+let currentUpdatePriority = react_reconciler_constants.NoEventPriority;
+/**
+* @link https://www.npmjs.com/package/react-devtools-inline
+* @link https://github.com/nitin42/Making-a-custom-React-renderer/blob/master/part-one.md
+* @link https://github.com/facebook/react/tree/main/packages/react-reconciler#practical-examples
+* @link https://github.com/vadimdemedes/ink
+* @link https://github.com/pixijs/pixi-react/tree/main/packages
+* @link https://github.com/diegomura/react-pdf/blob/master/packages/reconciler/src/reconciler-31.ts
+*/
+const Renderer = (0, react_reconciler.default)({
+	getRootHostContext: () => ({
+		type: "kubb-root",
+		isFile: false,
+		isSource: false
+	}),
+	prepareForCommit: () => {
+		return null;
+	},
+	preparePortalMount: () => null,
+	clearContainer: () => false,
+	resetAfterCommit(rootNode) {
+		if (typeof rootNode.onRender === "function") rootNode.onRender();
+	},
+	getChildHostContext(parentHostContext, type) {
+		return {
+			isInsideText: type === "kubb-text",
+			isFile: type === "kubb-file" || parentHostContext.isFile,
+			isSource: type === "kubb-source" || parentHostContext.isSource,
+			type
+		};
+	},
+	shouldSetTextContent: () => false,
+	createInstance(originalType, newProps, _root) {
+		const node = createNode(originalType);
+		for (const [key, value] of Object.entries(newProps)) {
+			if (key === "children") continue;
+			setAttribute(node, key, value);
+		}
+		return node;
+	},
+	createTextInstance(text, _root, hostContext) {
+		if (hostContext.isFile && !hostContext.isSource) throw new Error(`[react] '${text}' should be part of <File.Source> component when using the <File/> component`);
+		return createTextNode(text);
+	},
+	resetTextContent() {},
+	hideTextInstance(node) {
+		setTextNodeValue(node, "");
+	},
+	unhideTextInstance(node, text) {
+		setTextNodeValue(node, text);
+	},
+	getPublicInstance: (instance) => instance,
+	appendInitialChild: appendChildNode,
+	appendChild: appendChildNode,
+	insertBefore: insertBeforeNode,
+	finalizeInitialChildren(_node, _type, _props, _rootNode$1) {
+		return false;
+	},
+	supportsMutation: true,
+	isPrimaryRenderer: true,
+	supportsPersistence: false,
+	supportsHydration: false,
+	scheduleTimeout: setTimeout,
+	cancelTimeout: clearTimeout,
+	noTimeout: -1,
+	beforeActiveInstanceBlur() {},
+	afterActiveInstanceBlur() {},
+	detachDeletedInstance() {},
+	getInstanceFromNode: () => null,
+	prepareScopeUpdate() {},
+	getInstanceFromScope: () => null,
+	appendChildToContainer: appendChildNode,
+	insertInContainerBefore: insertBeforeNode,
+	removeChildFromContainer(node, removeNode) {
+		removeChildNode(node, removeNode);
+	},
+	commitMount() {},
+	commitUpdate(node, _payload, _type, _oldProps, newProps) {
+		const { props } = newProps;
+		if (props) for (const [key, value] of Object.entries(props)) setAttribute(node, key, value);
+	},
+	commitTextUpdate(node, _oldText, newText) {
+		setTextNodeValue(node, newText);
+	},
+	removeChild(node, removeNode) {
+		removeChildNode(node, removeNode);
+	},
+	setCurrentUpdatePriority: (newPriority) => {
+		currentUpdatePriority = newPriority;
+	},
+	getCurrentUpdatePriority: () => currentUpdatePriority,
+	resolveUpdatePriority() {
+		if (currentUpdatePriority !== react_reconciler_constants.NoEventPriority) return currentUpdatePriority;
+		return react_reconciler_constants.DefaultEventPriority;
+	},
+	maySuspendCommit() {
+		return false;
+	},
+	NotPendingTransition: void 0,
+	HostTransitionContext: (0, react.createContext)(null),
+	resetFormInstance() {},
+	requestPostPaintCallback() {},
+	shouldAttemptEagerTransition() {
+		return false;
+	},
+	trackSchedulerEvent() {},
+	resolveEventType() {
+		return null;
+	},
+	resolveEventTimeStamp() {
+		return -1.1;
+	},
+	preloadInstance() {
+		return true;
+	},
+	startSuspendingCommit() {},
+	suspendInstance() {},
+	waitForCommitToBeReady() {
+		return null;
+	}
+});
+
+//#endregion
+//#region src/utils/squashTextNodes.ts
+function squashTextNodes(node) {
+	let text = "";
+	for (const childNode of node.childNodes) {
+		if (!childNode) continue;
+		let nodeText = "";
+		const getPrintText = (text$1) => {
+			if (childNode.nodeName === "kubb-import") {
+				const attributes = childNode.attributes;
+				return (0, __kubb_fabric_core_parsers_typescript.print)([(0, __kubb_fabric_core_parsers_typescript.createImport)({
+					name: attributes.name,
+					path: attributes.path,
+					root: attributes.root,
+					isTypeOnly: attributes.isTypeOnly
+				})]);
+			}
+			if (childNode.nodeName === "kubb-export") {
+				const attributes = childNode.attributes;
+				if (attributes.path) return (0, __kubb_fabric_core_parsers_typescript.print)([(0, __kubb_fabric_core_parsers_typescript.createExport)({
+					name: attributes.name,
+					path: attributes.path,
+					isTypeOnly: attributes.isTypeOnly,
+					asAlias: attributes.asAlias
+				})]);
+			}
+			if (childNode.nodeName === "kubb-source") return text$1;
+			return text$1;
+		};
+		if (childNode.nodeName === "#text") nodeText = childNode.nodeValue;
+		else {
+			if ([
+				"kubb-text",
+				"kubb-file",
+				"kubb-source"
+			].includes(childNode.nodeName)) nodeText = squashTextNodes(childNode);
+			nodeText = getPrintText(nodeText);
+			if (childNode.nodeName === "br") nodeText = "\n";
+			if (![...nodeNames, "br"].includes(childNode.nodeName)) {
+				const attributes = Object.entries(childNode.attributes).reduce((acc, [key, value]) => {
+					if (typeof value === "string") return `${acc} ${key}="${value}"`;
+					return `${acc} ${key}={${value}}`;
+				}, "");
+				nodeText = `<${childNode.nodeName}${attributes}>${squashTextNodes(childNode)}</${childNode.nodeName}>`;
+			}
+		}
+		text += nodeText;
+	}
+	return text;
+}
+
+//#endregion
+//#region src/utils/squashExportNodes.ts
+function squashExportNodes(node) {
+	let exports$1 = /* @__PURE__ */ new Set();
+	node.childNodes.filter(Boolean).forEach((childNode) => {
+		if (childNode.nodeName !== "#text" && nodeNames.includes(childNode.nodeName)) exports$1 = new Set([...exports$1, ...squashExportNodes(childNode)]);
+		if (childNode.nodeName === "kubb-export") {
+			const attributes = childNode.attributes;
+			exports$1.add(attributes);
+		}
+	});
+	return exports$1;
+}
+
+//#endregion
+//#region src/utils/squashImportNodes.ts
+function squashImportNodes(node) {
+	let imports = /* @__PURE__ */ new Set();
+	node.childNodes.filter(Boolean).forEach((childNode) => {
+		if (childNode.nodeName !== "#text" && nodeNames.includes(childNode.nodeName)) imports = new Set([...imports, ...squashImportNodes(childNode)]);
+		if (childNode.nodeName === "kubb-import") {
+			const attributes = childNode.attributes;
+			imports.add(attributes);
+		}
+	});
+	return imports;
+}
+
+//#endregion
+//#region src/utils/squashSourceNodes.ts
+function squashSourceNodes(node, ignores) {
+	let sources = /* @__PURE__ */ new Set();
+	for (const childNode of node.childNodes) {
+		if (!childNode) continue;
+		if (childNode.nodeName !== "#text" && ignores.includes(childNode.nodeName)) continue;
+		if (childNode.nodeName === "kubb-source") {
+			const attributes = childNode.attributes;
+			const value = squashTextNodes(childNode);
+			sources.add({
+				...attributes,
+				value: value.trim().replace(/^\s+|\s+$/g, "")
+			});
+			continue;
+		}
+		if (childNode.nodeName !== "#text" && nodeNames.includes(childNode.nodeName)) sources = new Set([...sources, ...squashSourceNodes(childNode, ignores)]);
+	}
+	return sources;
+}
+
+//#endregion
+//#region src/utils/processFiles.ts
+function processFiles(node, fileManager) {
+	for (let index = 0; index < node.childNodes.length; index++) {
+		const childNode = node.childNodes[index];
+		if (!childNode) continue;
+		if (childNode.nodeName !== "#text" && childNode.nodeName !== "kubb-file" && nodeNames.includes(childNode.nodeName)) processFiles(childNode, fileManager);
+		if (childNode.nodeName === "kubb-file") {
+			const attributes = childNode.attributes;
+			if (attributes.baseName && attributes.path) {
+				const sources = squashSourceNodes(childNode, ["kubb-export", "kubb-import"]);
+				const file = {
+					baseName: attributes.baseName,
+					path: attributes.path,
+					sources: [...sources],
+					exports: [...squashExportNodes(childNode)],
+					imports: [...squashImportNodes(childNode)],
+					meta: attributes.meta || {},
+					footer: attributes.footer,
+					banner: attributes.banner
+				};
+				fileManager.add(file);
+			}
+		}
+	}
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/checkPrivateRedeclaration.js
+function _checkPrivateRedeclaration(e, t) {
+	if (t.has(e)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/classPrivateMethodInitSpec.js
+function _classPrivateMethodInitSpec(e, a) {
+	_checkPrivateRedeclaration(e, a), a.add(e);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/classPrivateFieldInitSpec.js
+function _classPrivateFieldInitSpec(e, t, a) {
+	_checkPrivateRedeclaration(e, t), t.set(e, a);
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/assertClassBrand.js
+function _assertClassBrand(e, t, n) {
+	if ("function" == typeof e ? e === t : e.has(t)) return arguments.length < 3 ? t : n;
+	throw new TypeError("Private element is not present on this object");
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/classPrivateFieldGet2.js
+function _classPrivateFieldGet2(s, a) {
+	return s.get(_assertClassBrand(s, a));
+}
+
+//#endregion
+//#region \0@oxc-project+runtime@0.95.0/helpers/classPrivateFieldSet2.js
+function _classPrivateFieldSet2(s, a, r) {
+	return s.set(_assertClassBrand(s, a), r), r;
+}
+
+//#endregion
+//#region src/Runtime.tsx
+var _options = /* @__PURE__ */ new WeakMap();
+var _isUnmounted = /* @__PURE__ */ new WeakMap();
+var _container = /* @__PURE__ */ new WeakMap();
+var _rootNode = /* @__PURE__ */ new WeakMap();
+var _Runtime_brand = /* @__PURE__ */ new WeakSet();
+var Runtime = class {
+	constructor(options) {
+		_classPrivateMethodInitSpec(this, _Runtime_brand);
+		_classPrivateFieldInitSpec(this, _options, void 0);
+		_classPrivateFieldInitSpec(this, _isUnmounted, void 0);
+		_defineProperty(this, "exitPromise", void 0);
+		_classPrivateFieldInitSpec(this, _container, void 0);
+		_classPrivateFieldInitSpec(this, _rootNode, void 0);
+		_defineProperty(this, "resolveExitPromise", () => {});
+		_defineProperty(this, "rejectExitPromise", () => {});
+		_defineProperty(this, "unsubscribeExit", () => {});
+		_defineProperty(this, "onRender", async () => {
+			var _classPrivateFieldGet2$1, _classPrivateFieldGet3, _classPrivateFieldGet4, _classPrivateFieldGet5;
+			if (_classPrivateFieldGet2(_isUnmounted, this)) return;
+			this.fileManager.clear();
+			processFiles(_classPrivateFieldGet2(_rootNode, this), this.fileManager);
+			if (!((_classPrivateFieldGet2$1 = _classPrivateFieldGet2(_options, this)) === null || _classPrivateFieldGet2$1 === void 0 ? void 0 : _classPrivateFieldGet2$1.debug) && !((_classPrivateFieldGet3 = _classPrivateFieldGet2(_options, this)) === null || _classPrivateFieldGet3 === void 0 ? void 0 : _classPrivateFieldGet3.stdout)) return;
+			const output = await _assertClassBrand(_Runtime_brand, this, _getOutput).call(this, _classPrivateFieldGet2(_rootNode, this));
+			if ((_classPrivateFieldGet4 = _classPrivateFieldGet2(_options, this)) === null || _classPrivateFieldGet4 === void 0 ? void 0 : _classPrivateFieldGet4.debug) {
+				console.log("Rendering: \n");
+				console.log(output);
+			}
+			if (((_classPrivateFieldGet5 = _classPrivateFieldGet2(_options, this)) === null || _classPrivateFieldGet5 === void 0 ? void 0 : _classPrivateFieldGet5.stdout) && node_process.default.env.NODE_ENV !== "test") {
+				_classPrivateFieldGet2(_options, this).stdout.clearLine(0);
+				_classPrivateFieldGet2(_options, this).stdout.cursorTo(0);
+				_classPrivateFieldGet2(_options, this).stdout.write(output);
+			}
+		});
+		_classPrivateFieldSet2(_options, this, options);
+		_classPrivateFieldSet2(_rootNode, this, createNode("kubb-root"));
+		_classPrivateFieldGet2(_rootNode, this).onRender = this.onRender;
+		_classPrivateFieldGet2(_rootNode, this).onImmediateRender = this.onRender;
+		_classPrivateFieldSet2(_isUnmounted, this, false);
+		this.unmount.bind(this);
+		const originalError = console.error;
+		console.error = (data) => {
+			const message = typeof data === "string" ? data : data === null || data === void 0 ? void 0 : data.message;
+			if (message === null || message === void 0 ? void 0 : message.match(/Encountered two children with the same key/gi)) return;
+			if (message === null || message === void 0 ? void 0 : message.match(/React will try to recreat/gi)) return;
+			if (message === null || message === void 0 ? void 0 : message.match(/Each child in a list should have a unique/gi)) return;
+			if (message === null || message === void 0 ? void 0 : message.match(/The above error occurred in the <KubbErrorBoundary/gi)) return;
+			if (message === null || message === void 0 ? void 0 : message.match(/A React Element from an older version of React was render/gi)) return;
+			originalError(data);
+		};
+		const logRecoverableError = typeof reportError === "function" ? reportError : console.error;
+		const rootTag = react_reconciler_constants.ConcurrentRoot;
+		const hydrationCallbacks = null;
+		const isStrictMode = false;
+		const concurrentUpdatesByDefaultOverride = false;
+		const identifierPrefix = "id";
+		const onUncaughtError = logRecoverableError;
+		const onCaughtError = logRecoverableError;
+		const onRecoverableError = logRecoverableError;
+		_classPrivateFieldSet2(_container, this, Renderer.createContainer(_classPrivateFieldGet2(_rootNode, this), rootTag, hydrationCallbacks, isStrictMode, concurrentUpdatesByDefaultOverride, identifierPrefix, onUncaughtError, onCaughtError, onRecoverableError, null));
+		this.unsubscribeExit = (0, signal_exit.onExit)((code) => {
+			this.unmount(code);
+		}, { alwaysLast: false }).bind(this);
+		Renderer.injectIntoDevTools({
+			bundleType: 1,
+			version: "19.1.0",
+			rendererPackageName: "kubb"
+		});
+	}
+	get fileManager() {
+		return _classPrivateFieldGet2(_options, this).fileManager;
+	}
+	onError(error) {
+		if (node_process.default.env.NODE_ENV === "test") console.warn(error);
+		throw error;
+	}
+	onExit(error) {
+		this.unmount(error);
+	}
+	render(node) {
+		const element = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Root, {
+			onExit: this.onExit.bind(this),
+			onError: this.onError.bind(this),
+			children: node
+		});
+		Renderer.updateContainerSync(element, _classPrivateFieldGet2(_container, this), null, null);
+		Renderer.flushSyncWork();
+	}
+	async renderToString(node) {
+		const element = /* @__PURE__ */ (0, react_jsx_runtime.jsx)(Root, {
+			onExit: this.onExit.bind(this),
+			onError: this.onError.bind(this),
+			children: node
+		});
+		Renderer.updateContainerSync(element, _classPrivateFieldGet2(_container, this), null, null);
+		Renderer.flushSyncWork();
+		this.fileManager.clear();
+		return _assertClassBrand(_Runtime_brand, this, _getOutput).call(this, _classPrivateFieldGet2(_rootNode, this));
+	}
+	unmount(error) {
+		var _classPrivateFieldGet6;
+		if (_classPrivateFieldGet2(_isUnmounted, this)) return;
+		if ((_classPrivateFieldGet6 = _classPrivateFieldGet2(_options, this)) === null || _classPrivateFieldGet6 === void 0 ? void 0 : _classPrivateFieldGet6.debug) console.log("Unmount", error);
+		this.onRender();
+		this.unsubscribeExit();
+		_classPrivateFieldSet2(_isUnmounted, this, true);
+		Renderer.updateContainerSync(null, _classPrivateFieldGet2(_container, this), null, null);
+		if (error instanceof Error) {
+			this.rejectExitPromise(error);
+			return;
+		}
+		this.resolveExitPromise();
+	}
+	async waitUntilExit() {
+		if (!this.exitPromise) this.exitPromise = new Promise((resolve, reject) => {
+			this.resolveExitPromise = resolve;
+			this.rejectExitPromise = reject;
+		});
+		return this.exitPromise;
+	}
+};
+async function _getOutput(node) {
+	const text = squashTextNodes(node);
+	const files = this.fileManager.files;
+	return files.length ? [...files].flatMap((file) => [...file.sources].map((item) => item.value)).filter(Boolean).join("\n\n") : text;
+}
+
+//#endregion
+//#region src/plugins/reactPlugin.ts
+const reactPlugin = (0, __kubb_fabric_core_plugins.createPlugin)({
+	name: "react",
+	install() {},
+	inject(app, options = {}) {
+		const runtime = new Runtime({
+			fileManager: app.context.fileManager,
+			...options
+		});
+		return {
+			async render(App) {
+				runtime.render((0, react.createElement)(App));
+				await app.context.events.emit("start");
+			},
+			async renderToString(App) {
+				await app.context.events.emit("start");
+				return runtime.renderToString((0, react.createElement)(App));
+			},
+			async waitUntilExit() {
+				await runtime.waitUntilExit();
+				await app.context.events.emit("end");
+			}
+		};
+	}
+});
+
+//#endregion
+Object.defineProperty(exports, 'Root', {
+  enumerable: true,
+  get: function () {
+    return Root;
+  }
+});
+Object.defineProperty(exports, 'RootContext', {
+  enumerable: true,
+  get: function () {
+    return RootContext;
+  }
+});
+Object.defineProperty(exports, 'Runtime', {
+  enumerable: true,
+  get: function () {
+    return Runtime;
+  }
+});
+Object.defineProperty(exports, '_classPrivateFieldGet2', {
+  enumerable: true,
+  get: function () {
+    return _classPrivateFieldGet2;
+  }
+});
+Object.defineProperty(exports, '_classPrivateFieldInitSpec', {
+  enumerable: true,
+  get: function () {
+    return _classPrivateFieldInitSpec;
+  }
+});
+Object.defineProperty(exports, '_classPrivateFieldSet2', {
+  enumerable: true,
+  get: function () {
+    return _classPrivateFieldSet2;
+  }
+});
+Object.defineProperty(exports, 'reactPlugin', {
+  enumerable: true,
+  get: function () {
+    return reactPlugin;
+  }
+});
+//# sourceMappingURL=plugins-9oisj5ko.cjs.map