@variousjs/various 5.2.1 → 6.0.0

package/dist/standalone.mjs

@@ -0,0 +1,1402 @@
+import e, { Component, useCallback, useEffect, useLayoutEffect, useRef, useState } from "react";
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/typeof.js
+function _typeof(o) {
+	"@babel/helpers - typeof";
+	return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
+		return typeof o;
+	} : function(o) {
+		return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+	}, _typeof(o);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/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.142.0/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+	var i = toPrimitive(t, "string");
+	return "symbol" == _typeof(i) ? i : i + "";
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/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 \0@oxc-project+runtime@0.142.0/helpers/esm/objectSpread2.js
+function ownKeys(e, r) {
+	var t = Object.keys(e);
+	if (Object.getOwnPropertySymbols) {
+		var o = Object.getOwnPropertySymbols(e);
+		r && (o = o.filter(function(r) {
+			return Object.getOwnPropertyDescriptor(e, r).enumerable;
+		})), t.push.apply(t, o);
+	}
+	return t;
+}
+function _objectSpread2(e) {
+	for (var r = 1; r < arguments.length; r++) {
+		var t = null != arguments[r] ? arguments[r] : {};
+		r % 2 ? ownKeys(Object(t), !0).forEach(function(r) {
+			_defineProperty(e, r, t[r]);
+		}) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r) {
+			Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r));
+		});
+	}
+	return e;
+}
+//#endregion
+//#region node_modules/nycticorax/dist/esm/index.js
+var o = {
+	17(t) {
+		t.exports = function t(e, r) {
+			if (e === r) return !0;
+			if (e && r && "object" == typeof e && "object" == typeof r) {
+				if (e.constructor !== r.constructor) return !1;
+				var s, o, n;
+				if (Array.isArray(e)) {
+					if ((s = e.length) != r.length) return !1;
+					for (o = s; 0 !== o--;) if (!t(e[o], r[o])) return !1;
+					return !0;
+				}
+				if (e.constructor === RegExp) return e.source === r.source && e.flags === r.flags;
+				if (e.valueOf !== Object.prototype.valueOf) return e.valueOf() === r.valueOf();
+				if (e.toString !== Object.prototype.toString) return e.toString() === r.toString();
+				if ((s = (n = Object.keys(e)).length) !== Object.keys(r).length) return !1;
+				for (o = s; 0 !== o--;) if (!Object.prototype.hasOwnProperty.call(r, n[o])) return !1;
+				for (o = s; 0 !== o--;) {
+					var i = n[o];
+					if (!t(e[i], r[i])) return !1;
+				}
+				return !0;
+			}
+			return e != e && r != r;
+		};
+	},
+	232(t, e, r) {
+		r.d(e, { A: () => u });
+		var s = r(705), o = r(17), n = r.n(o);
+		function i(t, e = /* @__PURE__ */ new WeakMap()) {
+			if ("object" != typeof t || null === t) return t;
+			if (e.has(t)) return e.get(t);
+			const r = Array.isArray(t) ? [] : {};
+			e.set(t, r);
+			const s = Reflect.ownKeys(t);
+			for (const o of s) r[o] = i(t[o], e);
+			return r;
+		}
+		class u {
+			constructor() {
+				var t;
+				(0, s.A)(this, "state", void 0), (0, s.A)(this, "listeners", void 0), (0, s.A)(this, "emits", void 0), (0, s.A)(this, "timer", void 0), (0, s.A)(this, "onStateChange", void 0), (0, s.A)(this, "getStore", void 0), (0, s.A)(this, "createStore", (t) => {
+					this.listeners = Reflect.ownKeys(t).reduce((e, r) => {
+						const s = r;
+						return this.state[s] = t[s], _objectSpread2(_objectSpread2({}, e), {}, { [r]: [] });
+					}, {});
+				}), (0, s.A)(this, "subscribe", (t) => {
+					const e = {};
+					return Reflect.ownKeys(t).forEach((r) => {
+						const s = r;
+						this.listeners[s] || (this.listeners[s] = []), this.listeners[s].push(t[s]), e[s] = t[s];
+					}), () => {
+						Reflect.ownKeys(e).forEach((t) => {
+							const r = t;
+							this.listeners[r] = this.listeners[r].filter((t) => t !== e[r]);
+						});
+					};
+				}), (0, s.A)(this, "emit", (t, e) => {
+					this.emits = _objectSpread2(_objectSpread2({}, this.emits), t), e ? this.trigger() : (clearTimeout(this.timer), this.timer = setTimeout(this.trigger));
+				}), (0, s.A)(this, "dispatch", (t, ...e) => t({
+					getStore: this.getStore,
+					emit: (t) => this.emit(t, !0)
+				}, ...e)), (0, s.A)(this, "trigger", () => {
+					const t = this.emits, e = [], r = Reflect.ownKeys(t);
+					for (let s = 0; s < r.length; s += 1) {
+						const o = r[s];
+						if (n()(this.state[o], t[o])) continue;
+						const u = t[o], c = this.state[o];
+						this.state[o] = i(t[o]), e.push({
+							key: o,
+							newValue: u,
+							oldValue: c
+						});
+					}
+					const s = {};
+					e.forEach((t) => {
+						s[t.key] = [t.newValue, t.oldValue], this.listeners[t.key] && this.listeners[t.key].forEach((e) => e(t.newValue, t.oldValue));
+					}), e.length && this.onStateChange(s), this.emits = {}, this.timer = void 0;
+				}), this.state = {}, this.listeners = {}, this.emits = {}, this.timer = void 0, this.onStateChange = () => null, this.getStore = (t = this.state, function(e) {
+					return e ? i(t[e]) : t;
+				});
+			}
+			set onChange(t) {
+				this.onStateChange = t;
+			}
+		}
+	},
+	705(t, e, r) {
+		function s(t) {
+			return s = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(t) {
+				return typeof t;
+			} : function(t) {
+				return t && "function" == typeof Symbol && t.constructor === Symbol && t !== Symbol.prototype ? "symbol" : typeof t;
+			}, s(t);
+		}
+		function o(t, e, r) {
+			return (e = function(t) {
+				var e = function(t) {
+					if ("object" != s(t) || !t) return t;
+					var e = t[Symbol.toPrimitive];
+					if (void 0 !== e) {
+						var r = e.call(t, "string");
+						if ("object" != s(r)) return r;
+						throw new TypeError("@@toPrimitive must return a primitive value.");
+					}
+					return String(t);
+				}(t);
+				return "symbol" == s(e) ? e : e + "";
+			}(e)) in t ? Object.defineProperty(t, e, {
+				value: r,
+				enumerable: !0,
+				configurable: !0,
+				writable: !0
+			}) : t[e] = r, t;
+		}
+		r.d(e, { A: () => o });
+	}
+};
+var n = {};
+function i(t) {
+	var e = n[t];
+	if (void 0 !== e) return e.exports;
+	var r = n[t] = { exports: {} };
+	return o[t](r, r.exports, i), r.exports;
+}
+i.n = (t) => {
+	var e = t && t.__esModule ? () => t.default : () => t;
+	return i.d(e, { a: e }), e;
+}, i.d = (t, e) => {
+	for (var r in e) i.o(e, r) && !i.o(t, r) && Object.defineProperty(t, r, {
+		enumerable: !0,
+		get: e[r]
+	});
+}, i.o = (t, e) => Object.prototype.hasOwnProperty.call(t, e);
+var u = i(705);
+var c = i(232);
+var a = [
+	"name",
+	"prototype",
+	"length",
+	"getDerivedStateFromProps",
+	"getDerivedStateFromError"
+];
+var f = class extends c.A {
+	constructor(...o) {
+		super(...o), (0, u.A)(this, "connect", function(r) {
+			const { getStore: s, subscribe: o } = r;
+			return function(...r) {
+				return function(n) {
+					class i extends Component {
+						constructor(t) {
+							super(t), (0, u.A)(this, "unsubscribe", void 0), (0, u.A)(this, "state", { props: s() }), this.unsubscribe = o(r.reduce((t, e) => _objectSpread2(_objectSpread2({}, t), {}, { [e]: () => {
+								this.setState({ props: s() });
+							} }), {}));
+						}
+						componentWillUnmount() {
+							this.unsubscribe();
+						}
+						render() {
+							const { props: t } = this.state, r = _objectSpread2(_objectSpread2({}, t), this.props);
+							return e.createElement(n, r);
+						}
+					}
+					return Reflect.ownKeys(n).forEach((t) => {
+						const e = String(t);
+						if (!a.includes(e)) {
+							const e = Object.getOwnPropertyDescriptor(n, t);
+							e && Object.defineProperty(i, t, e);
+						}
+					}), i;
+				};
+			};
+		}(this)), (0, u.A)(this, "useStore", function(t) {
+			const { getStore: e, subscribe: o } = t;
+			return function(...t) {
+				const [n, i] = useState(e());
+				return useLayoutEffect(() => o(t.reduce((t, r) => _objectSpread2(_objectSpread2({}, t), {}, { [r]: () => {
+					i((t) => _objectSpread2(_objectSpread2({}, t), {}, { [r]: e()[r] }));
+				} }), {}))), n;
+			};
+		}(this));
+	}
+};
+//#endregion
+//#region src/core/store.ts
+var { createStore, getStore, connect, emit, subscribe, dispatch, useStore } = new f();
+function getUserStore() {
+	const globalStore = getStore();
+	const keys = Object.keys(globalStore);
+	const store = {};
+	keys.forEach((key) => {
+		store[key] = globalStore[key];
+	});
+	return store;
+}
+//#endregion
+//#region src/core/default-component.tsx
+var Fallback = (props) => {
+	const className = getClassNameWithModule(props.$self.module, "various-component-fallback");
+	return /* @__PURE__ */ e.createElement("div", { className }, "Loading");
+};
+var ErrorFallback = ({ $error, $reload, $self }) => {
+	const className = getClassNameWithModule($self.module, "various-component-error_fallback");
+	return /* @__PURE__ */ e.createElement("div", { className }, /* @__PURE__ */ e.createElement("h3", null, $error.type), /* @__PURE__ */ e.createElement("p", null, $error.message), /* @__PURE__ */ e.createElement("button", {
+		type: "button",
+		onClick: $reload
+	}, "Reload"));
+};
+//#endregion
+//#region src/core/connector.ts
+var Connector = class {
+	constructor() {
+		_defineProperty(this, "fallbackComponent", void 0);
+		_defineProperty(this, "errorFallbackComponent", void 0);
+		_defineProperty(this, "storeActions", void 0);
+		_defineProperty(this, "componentActions", void 0);
+		_defineProperty(this, "i18nConfigs", void 0);
+		_defineProperty(this, "globalI18nConfig", void 0);
+		_defineProperty(this, "middlewares", void 0);
+		this.fallbackComponent = Fallback;
+		this.errorFallbackComponent = ErrorFallback;
+		this.storeActions = {};
+		this.componentActions = {};
+		this.i18nConfigs = {};
+		this.middlewares = {};
+	}
+	setMiddlewares(m) {
+		this.middlewares = m;
+	}
+	getMiddlewares() {
+		return this.middlewares;
+	}
+	setI18nConfig(module, config) {
+		this.i18nConfigs[module] = _objectSpread2(_objectSpread2({}, this.i18nConfigs[module]), config);
+	}
+	getI18nConfig(module) {
+		return this.i18nConfigs[module];
+	}
+	setGlobalI18nConfig(config) {
+		this.globalI18nConfig = _objectSpread2(_objectSpread2({}, this.globalI18nConfig), config);
+	}
+	getGlobalI18nConfig() {
+		return this.globalI18nConfig;
+	}
+	setComponentActions(module, actions) {
+		this.componentActions[module] = actions;
+	}
+	deleteComponentActions(module) {
+		delete this.componentActions[module];
+	}
+	getComponentActions(module) {
+		return this.componentActions[module];
+	}
+	setStoreActions(actions) {
+		this.storeActions = actions;
+	}
+	getStoreActions() {
+		return this.storeActions;
+	}
+	setFallbackComponent(fallbackComponent) {
+		this.fallbackComponent = fallbackComponent;
+	}
+	getFallbackComponent() {
+		return this.fallbackComponent;
+	}
+	setErrorFallbackComponent(errorFallbackComponent) {
+		this.errorFallbackComponent = errorFallbackComponent;
+	}
+	getErrorFallbackComponent() {
+		return this.errorFallbackComponent;
+	}
+};
+var connector_default = new Connector();
+//#endregion
+//#region src/core/logger.ts
+var logger = (args) => {
+	var _middlewares$onLog;
+	const middlewares = connector_default.getMiddlewares();
+	if ((middlewares === null || middlewares === void 0 || (_middlewares$onLog = middlewares.onLog) === null || _middlewares$onLog === void 0 ? void 0 : _middlewares$onLog.call(middlewares, args)) === false) return;
+	const color = {
+		info: "blue",
+		warn: "orange",
+		error: "red"
+	}[args.level];
+	const params = [`%c ${args.module} `, `background:${color};border:1px solid ${color};padding:1px;border-radius:2px 0 0 2px;color: #fff;`];
+	if (args.type) {
+		params[0] = `${params[0]}%c ${args.type} %c`;
+		params.push(`border:1px solid ${color};padding:1px;border-radius:0 2px 2px 0;color:${color};`, "background:transparent");
+	}
+	if (args.level !== "info") params[0] = ` ${params[0]}`;
+	window.console[args.level](...params, args.message);
+};
+var createLogger = (module) => ({
+	info(message, type) {
+		logger({
+			module,
+			level: "info",
+			type,
+			message
+		});
+	},
+	warn(message, type) {
+		logger({
+			module,
+			level: "warn",
+			type,
+			message
+		});
+	},
+	error(message, type) {
+		var _middlewares$onError;
+		const middlewares = connector_default.getMiddlewares();
+		const error = message instanceof VariousError ? message : new VariousError({
+			module,
+			type: type || "unknow",
+			originalError: message instanceof Error ? message : new Error(message)
+		});
+		middlewares === null || middlewares === void 0 || (_middlewares$onError = middlewares.onError) === null || _middlewares$onError === void 0 || _middlewares$onError.call(middlewares, error);
+		logger({
+			module,
+			level: "error",
+			type,
+			message
+		});
+	}
+});
+//#endregion
+//#region src/core/config.ts
+var MOUNTED_COMPONENTS_KEY = Symbol("MOUNTED_COMPONENTS");
+var MESSAGE_KEY = Symbol("MESSAGE");
+var CONFIG_KEY = Symbol("CONFIG");
+var DEPENDENCIES_KEY = Symbol("DEPENDENCIES");
+var LOCALE_KEY = Symbol("LOCALE");
+var STANDALONE_CONFIG_READY = Symbol("STANDALONE_CONFIG_READY");
+var I18NActions = /* @__PURE__ */ function(I18NActions) {
+	I18NActions["SetLocale"] = "setLocale";
+	I18NActions["GetLocale"] = "getLocale";
+	I18NActions["UpdateI18nConfig"] = "updateI18nConfig";
+	return I18NActions;
+}({});
+var VUE_FUNCTION_OPTIONS = [
+	"beforeCreate",
+	"created",
+	"beforeMount",
+	"mounted",
+	"beforeUpdate",
+	"updated",
+	"beforeUnmount",
+	"unmounted",
+	"errorCaptured",
+	"renderTracked",
+	"renderTriggered",
+	"activated",
+	"deactivated",
+	"setup",
+	"data",
+	"render"
+];
+//#endregion
+//#region src/core/message.ts
+var createPostMessage = (module) => async ({ event, payload }) => {
+	const middlewares = connector_default.getMiddlewares();
+	const logger = createLogger(module);
+	let next = {
+		trigger: module,
+		event,
+		payload
+	};
+	if (middlewares === null || middlewares === void 0 ? void 0 : middlewares.onMessage) {
+		const check = await middlewares.onMessage(next);
+		if (check === false) {
+			logger.warn("blocked by middleware", "POST_MESSAGE");
+			return;
+		}
+		if (check !== true) next = _objectSpread2(_objectSpread2({}, next), check);
+	}
+	emit({ [MESSAGE_KEY]: {
+		timestamp: +/* @__PURE__ */ new Date(),
+		event: next.event,
+		trigger: module,
+		payload: next.payload
+	} });
+};
+var createOnMessage = (module, onMessage) => subscribe({ [MESSAGE_KEY](v) {
+	const { trigger, payload, event } = v;
+	if (module !== trigger) onMessage({
+		event,
+		payload,
+		trigger
+	});
+} });
+//#endregion
+//#region src/core/i18n.ts
+function createI18nConfig(method, module, callback) {
+	if (!method) return;
+	const i18nConfig = method();
+	if (!isPromiseLike(i18nConfig)) {
+		if (module) connector_default.setI18nConfig(module, i18nConfig);
+		else connector_default.setGlobalI18nConfig(i18nConfig);
+		return;
+	}
+	if (module) connector_default.setI18nConfig(module, {
+		loading: true,
+		resources: {}
+	});
+	else connector_default.setGlobalI18nConfig({
+		loading: true,
+		resources: {}
+	});
+	i18nConfig.then((res) => {
+		if (module) {
+			connector_default.setI18nConfig(module, _objectSpread2(_objectSpread2({}, res), {}, { loading: false }));
+			callback === null || callback === void 0 || callback();
+			return;
+		}
+		const locale = getStore(LOCALE_KEY);
+		emit({ [LOCALE_KEY]: void 0 }, true);
+		emit({ [LOCALE_KEY]: locale }, true);
+		connector_default.setGlobalI18nConfig(_objectSpread2(_objectSpread2({}, res), {}, { loading: false }));
+	}).catch((e) => {
+		onError(new VariousError({
+			module: module || "app",
+			type: "I18N",
+			originalError: e
+		}));
+	});
+}
+function createI18n(module, updater) {
+	const ctx = (key, params, defaultString) => {
+		const i18nConfig = connector_default.getI18nConfig(module) || connector_default.getGlobalI18nConfig();
+		let defaultText = defaultString;
+		if (defaultText === void 0) defaultText = typeof params === "string" ? params : key;
+		if (!i18nConfig) {
+			onError(new VariousError({
+				module,
+				type: "I18N",
+				originalError: /* @__PURE__ */ new Error("config not exist")
+			}));
+			return defaultText;
+		}
+		if (i18nConfig.loading) return defaultText;
+		const { resources } = i18nConfig;
+		const locale = getStore(LOCALE_KEY);
+		const resource = resources === null || resources === void 0 ? void 0 : resources[locale];
+		if (!resource) {
+			onError(new VariousError({
+				module,
+				type: "I18N",
+				originalError: /* @__PURE__ */ new Error(`locale resource \`${locale}\` not exist`)
+			}));
+			return defaultText;
+		}
+		if (!resource[key]) {
+			onError(new VariousError({
+				module,
+				type: "I18N",
+				originalError: /* @__PURE__ */ new Error(`locale key \`${key}\` not exist`)
+			}));
+			return defaultText;
+		}
+		const text = resource[key];
+		if (!params || typeof params === "string" || Object.prototype.toString.call(params) !== "[object Object]") return text;
+		const args = Object.keys(params);
+		if (!args.length) return text;
+		return args.reduce((next, arg) => {
+			const regex = new RegExp(`{\\s*${arg}\\s*}`, "g");
+			return next.replace(regex, params[arg].toString());
+		}, text);
+	};
+	ctx.update = (config) => {
+		const next = _objectSpread2(_objectSpread2({}, connector_default.getI18nConfig(module)), config);
+		connector_default.setI18nConfig(module, next);
+		updater();
+	};
+	return ctx;
+}
+//#endregion
+//#region \0vite/preload-helper.js
+var scriptRel = "modulepreload";
+var assetsURL = function(dep) {
+	return "/" + dep;
+};
+var seen = {};
+var __vitePreload = function preload(baseModule, deps, importerUrl) {
+	let promise = Promise.resolve();
+	if (deps && deps.length > 0) {
+		const links = document.getElementsByTagName("link");
+		const cspNonceMeta = document.querySelector("meta[property=csp-nonce]");
+		const cspNonce = (cspNonceMeta === null || cspNonceMeta === void 0 ? void 0 : cspNonceMeta.nonce) || (cspNonceMeta === null || cspNonceMeta === void 0 ? void 0 : cspNonceMeta.getAttribute("nonce"));
+		function allSettled(promises) {
+			return Promise.all(promises.map((p) => Promise.resolve(p).then((value) => ({
+				status: "fulfilled",
+				value
+			}), (reason) => ({
+				status: "rejected",
+				reason
+			}))));
+		}
+		function importMetaResolve(specifier) {
+			if (import.meta.resolve) return import.meta.resolve(specifier);
+			return new URL(
+				specifier,
+				/** #__KEEP__ */
+				import.meta.url
+			).href;
+		}
+		promise = allSettled(deps.map((dep) => {
+			dep = assetsURL(dep, importerUrl);
+			dep = importMetaResolve(dep);
+			if (dep in seen) return;
+			seen[dep] = true;
+			const isCss = dep.endsWith(".css");
+			for (let i = links.length - 1; i >= 0; i--) {
+				const link = links[i];
+				if (link.href === dep && (!isCss || link.rel === "stylesheet")) return;
+			}
+			const link = document.createElement("link");
+			link.rel = isCss ? "stylesheet" : scriptRel;
+			if (!isCss) link.as = "script";
+			link.crossOrigin = "";
+			link.href = dep;
+			if (cspNonce) link.setAttribute("nonce", cspNonce);
+			document.head.appendChild(link);
+			if (isCss) return new Promise((res, rej) => {
+				link.addEventListener("load", res);
+				link.addEventListener("error", () => rej(/* @__PURE__ */ new Error(`Unable to preload CSS for ${dep}`)));
+			});
+		}));
+	}
+	function handlePreloadError(err) {
+		const e = new Event("vite:preloadError", { cancelable: true });
+		e.payload = err;
+		window.dispatchEvent(e);
+		if (!e.defaultPrevented) throw err;
+	}
+	return promise.then((res) => {
+		for (const item of res || []) {
+			if (item.status !== "rejected") continue;
+			handlePreloadError(item.reason);
+		}
+		return baseModule().catch(handlePreloadError);
+	});
+};
+//#endregion
+//#region src/core/system.ts
+function getRegistry() {
+	if (!window.__various) window.__various = {
+		modules: /* @__PURE__ */ new Map(),
+		urls: /* @__PURE__ */ new Map(),
+		loaded: /* @__PURE__ */ new Map()
+	};
+	return window.__various;
+}
+var { modules: moduleRegistry, urls: moduleUrls, loaded: loadedModules } = getRegistry();
+function resolveUrl(url) {
+	if (url.startsWith("http") || url.startsWith("/") || url.startsWith("blob:")) return url;
+	return new URL(url, document.baseURI).href;
+}
+function setModuleUrl(name, url) {
+	moduleUrls.set(name, url);
+}
+function getModuleUrl(name) {
+	return moduleUrls.get(name);
+}
+function getAllModuleUrls() {
+	const result = {};
+	moduleUrls.forEach((url, name) => {
+		result[name] = url;
+	});
+	return result;
+}
+function getInjectedModuleNames() {
+	const result = [];
+	moduleRegistry.forEach((_, name) => {
+		if (!moduleUrls.has(name)) result.push(name);
+	});
+	return result;
+}
+async function importModule(name) {
+	const url = moduleUrls.get(name);
+	if (url) {
+		const absoluteUrl = resolveUrl(url);
+		if (loadedModules.has(absoluteUrl)) return loadedModules.get(absoluteUrl);
+		const mod = await __vitePreload(() => import(
+			/* @vite-ignore */
+			absoluteUrl
+), []);
+		loadedModules.set(absoluteUrl, mod);
+		return mod;
+	}
+	if (moduleRegistry.has(name)) return moduleRegistry.get(name);
+	throw new Error(`module "${name}" not defined`);
+}
+function isModuleDefined(name) {
+	if (moduleRegistry.has(name)) return true;
+	const url = moduleUrls.get(name);
+	if (url && loadedModules.has(resolveUrl(url))) return true;
+	return false;
+}
+function isModuleSpecified$1(name) {
+	return moduleUrls.has(name) || isModuleDefined(name);
+}
+function deleteModule(name) {
+	moduleRegistry.delete(name);
+	const url = moduleUrls.get(name);
+	if (url) loadedModules.delete(resolveUrl(url));
+}
+function setModule(name, mod) {
+	if (mod && typeof mod === "object" && !("default" in mod)) moduleRegistry.set(name, _objectSpread2({ default: mod }, mod));
+	else moduleRegistry.set(name, mod);
+}
+function createModuleBlobUrl(name) {
+	const mod = moduleRegistry.get(name);
+	if (!mod) return null;
+	const realMod = typeof mod === "object" && "default" in mod ? mod : { default: mod };
+	const keys = Object.keys(realMod).filter((k) => k !== "default" && /^[a-zA-Z_$][a-zA-Z0-9_$]*$/.test(k));
+	const lines = [
+		`const m = window.__various.modules.get(${JSON.stringify(name)});`,
+		"export default m.default || m;",
+		...keys.map((k) => `export const ${k} = m[${JSON.stringify(k)}];`)
+	];
+	const blob = new Blob([lines.join("\n")], { type: "application/javascript" });
+	return URL.createObjectURL(blob);
+}
+//#endregion
+//#region src/core/helper.ts
+var getUrlHash = (url) => `${url}?${+/* @__PURE__ */ new Date()}`;
+var getModuleInfo = (module) => {
+	const [name, entry] = module.split(".");
+	return {
+		name,
+		entry
+	};
+};
+var isModuleLoaded = (module) => {
+	const { name } = getModuleInfo(module);
+	return isModuleDefined(name);
+};
+var isModuleSpecified = (module) => {
+	const { name } = getModuleInfo(module);
+	return isModuleSpecified$1(name);
+};
+var getMountedComponents = () => getStore(MOUNTED_COMPONENTS_KEY);
+var resetDependencyConfig = (module, url) => {
+	const { name } = getModuleInfo(module);
+	const dependencies = getStore(DEPENDENCIES_KEY);
+	if (url && isModuleDefined(name)) return;
+	if (!dependencies[name] && url) {
+		setModuleUrl(name, url);
+		return;
+	}
+	let moduleUrl = getUrlHash(dependencies[name]);
+	if (url) moduleUrl = getUrlHash(url);
+	deleteModule(name);
+	setModuleUrl(name, moduleUrl);
+};
+var onError = (e) => {
+	const { module, type } = e;
+	createLogger(module).error(e, type);
+};
+var VariousError = class extends Error {
+	constructor(data) {
+		super(data.originalError.message);
+		_defineProperty(this, "type", void 0);
+		_defineProperty(this, "originalError", void 0);
+		_defineProperty(this, "module", void 0);
+		this.type = data.type;
+		this.originalError = data.originalError;
+		this.module = data.module;
+	}
+};
+function checkReactComponent(component, module) {
+	return new Promise((reslove, reject) => {
+		var _component$prototype;
+		if (component.$$typeof || ((_component$prototype = component.prototype) === null || _component$prototype === void 0 ? void 0 : _component$prototype.isReactComponent) || typeof component === "function") {
+			reslove();
+			return;
+		}
+		reject(new VariousError({
+			module,
+			originalError: /* @__PURE__ */ new Error("not a valid React component"),
+			type: "INVALID_COMPONENT"
+		}));
+	});
+}
+function isPromiseLike(value) {
+	return value != null && typeof value.then === "function";
+}
+function checkVueComponent(component, module) {
+	const versionRegex = new RegExp(`^3\\.`);
+	return new Promise((resolve, reject) => {
+		importModule("vue").then((Vue) => {
+			const vueObj = Vue.default || Vue;
+			if (!versionRegex.test(vueObj.version)) {
+				reject(/* @__PURE__ */ new Error(`Vue 3+ required, detected an incompatible version`));
+				return;
+			}
+			if (typeof (component === null || component === void 0 ? void 0 : component.render) === "function" || typeof (component === null || component === void 0 ? void 0 : component.setup) === "function") {
+				resolve();
+				return;
+			}
+			reject(new VariousError({
+				module,
+				originalError: /* @__PURE__ */ new Error("not a valid Vue component"),
+				type: "INVALID_COMPONENT"
+			}));
+		}).catch(reject);
+	});
+}
+function parseComponentActions(params) {
+	const { componentNode, module, type, i18nUpdate } = params;
+	const actions = {};
+	let onMessageAction;
+	let i18nAction;
+	Object.getOwnPropertyNames(componentNode).forEach((method) => {
+		if (typeof componentNode[method] !== "function") return;
+		if (method === "$onMessage") {
+			onMessageAction = componentNode[method];
+			return;
+		}
+		if (method === "$i18n") {
+			i18nAction = componentNode[method];
+			return;
+		}
+		if (type === "vue3" && VUE_FUNCTION_OPTIONS.includes(method)) return;
+		actions[method] = componentNode[method];
+	});
+	if (i18nAction) createI18nConfig(i18nAction, module, i18nUpdate);
+	connector_default.setComponentActions(module, actions);
+	if (onMessageAction) return createOnMessage(module, onMessageAction);
+	return () => null;
+}
+function updateMountedComponent(module) {
+	const mountedComponents = getMountedComponents();
+	if (!mountedComponents.includes(module)) mountedComponents.push(module);
+	emit({ [MOUNTED_COMPONENTS_KEY]: mountedComponents }, true);
+}
+function updateUnMountComponent(module) {
+	let mountedComponents = getMountedComponents();
+	mountedComponents = mountedComponents.filter((item) => item !== module);
+	emit({ [MOUNTED_COMPONENTS_KEY]: mountedComponents }, true);
+	connector_default.deleteComponentActions(module);
+}
+function getSelfInfo(params) {
+	const { module, url } = params;
+	const dependencies = getStore(DEPENDENCIES_KEY);
+	const { name } = getModuleInfo(module);
+	return {
+		module,
+		url: url || dependencies[name] || getModuleUrl(name) || ""
+	};
+}
+function getClassNameWithModule(module, prefix) {
+	const { name, entry } = getModuleInfo(module);
+	return `${prefix} ${[name, entry].filter(Boolean).join("-")}`;
+}
+//#endregion
+//#region src/core/dispatch.ts
+var createDispatch = (module) => async function(params) {
+	const middlewares = connector_default.getMiddlewares();
+	const logger = createLogger(module);
+	let { action, payload, target } = params;
+	if (middlewares === null || middlewares === void 0 ? void 0 : middlewares.onDispatch) {
+		const check = await middlewares.onDispatch({
+			target,
+			action,
+			payload,
+			trigger: module
+		});
+		if (check === false) {
+			logger.warn("blocked by middleware", "DISPATCH");
+			return Promise.resolve();
+		}
+		if (check !== true) {
+			target = check.target;
+			action = check.action;
+			payload = check.payload;
+		}
+	}
+	if (target === "app") {
+		const storeAction = connector_default.getStoreActions()[action];
+		if (action === I18NActions.SetLocale) {
+			emit({ [LOCALE_KEY]: payload }, true);
+			return payload;
+		}
+		if (action === I18NActions.GetLocale) return getStore(LOCALE_KEY);
+		if (action === I18NActions.UpdateI18nConfig) {
+			const locale = getStore(LOCALE_KEY);
+			connector_default.setGlobalI18nConfig(payload);
+			emit({ [LOCALE_KEY]: void 0 }, true);
+			emit({ [LOCALE_KEY]: locale }, true);
+			return locale;
+		}
+		if (!storeAction) {
+			const errorMessage = `action "${action}" is not present`;
+			const error = new VariousError({
+				module,
+				type: "DISPATCH",
+				originalError: new Error(errorMessage)
+			});
+			onError(error);
+			throw error;
+		}
+		return dispatch(storeAction, payload, module);
+	}
+	const componentActions = connector_default.getComponentActions(target);
+	if (!componentActions) {
+		const error = new VariousError({
+			module,
+			type: "DISPATCH",
+			originalError: /* @__PURE__ */ new Error("component is not ready")
+		});
+		onError(error);
+		throw error;
+	}
+	const componentAction = componentActions[action];
+	if (!componentAction) {
+		const errorMessage = `action "${action}" is not present`;
+		const error = new VariousError({
+			module,
+			type: "DISPATCH",
+			originalError: new Error(errorMessage)
+		});
+		onError(error);
+		throw error;
+	}
+	return Promise.resolve(componentAction({
+		payload,
+		trigger: module
+	}));
+};
+//#endregion
+//#region src/core/create-module.ts
+var createModule = (config, logError = true) => {
+	const dependencies = getStore(DEPENDENCIES_KEY);
+	const middlewares = connector_default.getMiddlewares();
+	const { url, module } = config;
+	const { name, entry } = getModuleInfo(module);
+	const loadStart = +/* @__PURE__ */ new Date();
+	const logOnError = (e) => {
+		if (logError) onError(e);
+	};
+	if (url) resetDependencyConfig(module, url);
+	return new Promise((resolve, reject) => {
+		if (!url && !dependencies[name] && !isModuleSpecified(module)) {
+			const error = new VariousError({
+				module,
+				type: "NOT_DEFINED",
+				originalError: /* @__PURE__ */ new Error(`module "${name}" not defined`)
+			});
+			logOnError(error);
+			reject(error);
+			return;
+		}
+		importModule(name).then((C) => {
+			var _middlewares$onLoad;
+			const loadEnd = +/* @__PURE__ */ new Date();
+			middlewares === null || middlewares === void 0 || (_middlewares$onLoad = middlewares.onLoad) === null || _middlewares$onLoad === void 0 || _middlewares$onLoad.call(middlewares, {
+				module,
+				loadStart,
+				loadEnd,
+				beenLoaded: isModuleLoaded(module)
+			});
+			if (!C || typeof C === "object" && Object.keys(C).length === 0) {
+				const error = new VariousError({
+					module,
+					type: "INVALID_MODULE",
+					originalError: /* @__PURE__ */ new Error(`module "${name}" invalid`)
+				});
+				resetDependencyConfig(module);
+				logOnError(error);
+				reject(error);
+				return;
+			}
+			const defaultModule = "default" in C ? C.default : C;
+			const actualModule = !entry ? defaultModule : C[entry];
+			if (actualModule === void 0 && entry) {
+				const error = new VariousError({
+					module,
+					type: "SUBMODULE_NOT_DEFINED",
+					originalError: /* @__PURE__ */ new Error(`submodule "${entry}" not defined`)
+				});
+				resetDependencyConfig(module);
+				logOnError(error);
+				reject(error);
+				return;
+			}
+			resolve(actualModule);
+		}).catch((e) => {
+			resetDependencyConfig(module, url);
+			let errorType = "LOADING_ERROR";
+			if (!url && e.message && !e.message.includes(name)) errorType = "SUBMODULE_LOADING_ERROR";
+			const error = new VariousError({
+				module: name,
+				type: errorType,
+				originalError: e
+			});
+			logOnError(error);
+			reject(error);
+		});
+	});
+};
+//#endregion
+//#region src/core/react-component.tsx
+function reactComponent(config) {
+	const { module, url, watchKeys, onMounted } = config;
+	const storeKeys = watchKeys || Object.keys(getStore());
+	class R extends Component {
+		constructor(..._args) {
+			var _this;
+			super(..._args);
+			_this = this;
+			_defineProperty(this, "state", {
+				componentReady: false,
+				isError: false
+			});
+			_defineProperty(this, "error", void 0);
+			_defineProperty(this, "ComponentNode", void 0);
+			_defineProperty(this, "isUnMounted", void 0);
+			_defineProperty(this, "unSubscribeMessage", () => null);
+			_defineProperty(this, "mountComponent", async () => {
+				try {
+					const componentNode = await createModule({
+						module,
+						url
+					}, false);
+					if (_this.isUnMounted) return;
+					await checkReactComponent(componentNode, module);
+					componentNode.displayName = module;
+					updateMountedComponent(module);
+					_this.unSubscribeMessage = parseComponentActions({
+						componentNode,
+						module,
+						i18nUpdate: () => _this.forceUpdate()
+					});
+					_this.ComponentNode = componentNode;
+					_this.setState({ componentReady: true });
+					onMounted === null || onMounted === void 0 || onMounted();
+				} catch (e) {
+					if (_this.isUnMounted) return;
+					_this.error = e;
+					_this.setState({
+						componentReady: true,
+						isError: true
+					});
+				}
+			});
+			_defineProperty(this, "$postMessage", createPostMessage(module));
+			_defineProperty(this, "$dispatch", createDispatch(module));
+			_defineProperty(this, "$t", createI18n(module, () => this.forceUpdate()));
+			_defineProperty(this, "$logger", createLogger(module));
+			_defineProperty(this, "$self", getSelfInfo({
+				module,
+				url
+			}));
+		}
+		componentDidMount() {
+			this.isUnMounted = false;
+			this.mountComponent();
+		}
+		componentWillUnmount() {
+			this.error = void 0;
+			this.ComponentNode = null;
+			this.isUnMounted = true;
+			this.unSubscribeMessage();
+			updateUnMountComponent(module);
+		}
+		render() {
+			const Fallback = connector_default.getFallbackComponent();
+			const { $silent, $componentProps, $ref } = this.props;
+			const { componentReady, isError } = this.state;
+			const store = getUserStore();
+			const locale = getStore(LOCALE_KEY);
+			const ComponentNode = this.ComponentNode;
+			if (isError) throw this.error;
+			if (!componentReady) {
+				if ($silent || isModuleLoaded(module)) return null;
+				return /* @__PURE__ */ e.createElement(Fallback, {
+					$self: this.$self,
+					$store: store,
+					$locale: locale
+				});
+			}
+			return /* @__PURE__ */ e.createElement(ComponentNode, _objectSpread2(_objectSpread2({}, $componentProps), {}, {
+				$self: this.$self,
+				$dispatch: this.$dispatch,
+				$store: store,
+				$postMessage: this.$postMessage,
+				$t: this.$t,
+				$logger: this.$logger,
+				ref: $ref,
+				$locale: locale
+			}));
+		}
+	}
+	_defineProperty(R, "displayName", "various-react-component");
+	const Connected = connect(...storeKeys, LOCALE_KEY)(R);
+	Connected.displayName = "various-connector";
+	return Connected;
+}
+//#endregion
+//#region src/core/vue-component.tsx
+function vueComponent(config) {
+	const { module, url, watchKeys, onMounted } = config;
+	const storeKeys = watchKeys || Object.keys(getStore());
+	const V = (props) => {
+		const store = useStore(...storeKeys, LOCALE_KEY);
+		const locale = store[LOCALE_KEY];
+		const vueRef = useRef();
+		const vmRef = useRef();
+		const isVueMounted = useRef(false);
+		const errorRef = useRef();
+		const isUnMountedRef = useRef(false);
+		const ComponentNodeRef = useRef();
+		const selfRef = useRef(getSelfInfo({
+			module,
+			url
+		}));
+		const containerDivRef = useRef(null);
+		const propsReactiveRef = useRef();
+		const storeReactiveRef = useRef();
+		const localeReactiveRef = useRef();
+		const unMountVue = useRef();
+		const unSubscribeMessageRef = useRef();
+		const updateVueComponentRef = useRef();
+		const [componentReady, setComponentReady] = useState(false);
+		const [isError, setIsError] = useState(false);
+		const Fallback = connector_default.getFallbackComponent();
+		const { $silent, $componentProps } = props;
+		const mountVue = useCallback(() => {
+			const $logger = createLogger(module);
+			const $dispatch = createDispatch(module);
+			const $postMessage = createPostMessage(module);
+			const $t = createI18n(module, () => {
+				var _updateVueComponentRe;
+				(_updateVueComponentRe = updateVueComponentRef.current) === null || _updateVueComponentRe === void 0 || _updateVueComponentRe.call(updateVueComponentRef);
+			});
+			propsReactiveRef.current = vueRef.current.ref(_objectSpread2({}, $componentProps));
+			storeReactiveRef.current = vueRef.current.ref(_objectSpread2({}, store));
+			localeReactiveRef.current = vueRef.current.ref(locale);
+			const vueApp = vueRef.current.createApp({
+				setup() {
+					const renderKey = vueRef.current.ref(0);
+					updateVueComponentRef.current = () => {
+						renderKey.value += 1;
+					};
+					return { key: renderKey };
+				},
+				errorCaptured(e) {
+					var _error$message;
+					const error = e;
+					errorRef.current = ((_error$message = error.message) === null || _error$message === void 0 ? void 0 : _error$message.includes("https://react")) ? new VariousError({
+						originalError: /* @__PURE__ */ new Error("not a valid Vue component"),
+						module,
+						type: "INVALID_COMPONENT"
+					}) : error;
+					setIsError(true);
+				},
+				render() {
+					return vueRef.current.h(ComponentNodeRef.current, _objectSpread2(_objectSpread2({}, propsReactiveRef.current.value), {}, {
+						various: {
+							$dispatch,
+							$logger,
+							$postMessage,
+							$t,
+							$store: storeReactiveRef.current.value,
+							$self: selfRef.current,
+							$locale: localeReactiveRef.current.value
+						},
+						key: this.key
+					}));
+				}
+			});
+			if (!vmRef.current) vmRef.current = vueApp.mount(containerDivRef.current);
+			isVueMounted.current = true;
+			unMountVue.current = () => vueApp.unmount();
+		}, [
+			$componentProps,
+			store,
+			locale
+		]);
+		const mountComponent = useCallback(async () => {
+			try {
+				const vue = await createModule({ module: "vue" });
+				vueRef.current = vue;
+				const componentNode = await createModule({
+					module,
+					url
+				}, false);
+				if (isUnMountedRef.current) return;
+				await checkVueComponent(componentNode, module);
+				updateMountedComponent(module);
+				unSubscribeMessageRef.current = parseComponentActions({
+					componentNode,
+					module,
+					type: "vue3",
+					i18nUpdate() {
+						var _updateVueComponentRe2;
+						(_updateVueComponentRe2 = updateVueComponentRef.current) === null || _updateVueComponentRe2 === void 0 || _updateVueComponentRe2.call(updateVueComponentRef);
+					}
+				});
+				ComponentNodeRef.current = componentNode;
+				setTimeout(mountVue);
+				setComponentReady(true);
+				onMounted === null || onMounted === void 0 || onMounted();
+			} catch (e) {
+				if (isUnMountedRef.current) return;
+				errorRef.current = e;
+				setComponentReady(true);
+				setIsError(true);
+			}
+		}, [mountVue]);
+		useEffect(() => {
+			isUnMountedRef.current = false;
+			return () => {
+				var _unMountVue$current, _unSubscribeMessageRe;
+				errorRef.current = void 0;
+				ComponentNodeRef.current = void 0;
+				isUnMountedRef.current = true;
+				updateUnMountComponent(module);
+				(_unMountVue$current = unMountVue.current) === null || _unMountVue$current === void 0 || _unMountVue$current.call(unMountVue);
+				(_unSubscribeMessageRe = unSubscribeMessageRef.current) === null || _unSubscribeMessageRe === void 0 || _unSubscribeMessageRe.call(unSubscribeMessageRef);
+				isVueMounted.current = false;
+			};
+		}, []);
+		useEffect(() => {
+			if (isVueMounted.current) return;
+			mountComponent();
+		}, [mountComponent]);
+		useEffect(() => {
+			if (propsReactiveRef.current) propsReactiveRef.current.value = _objectSpread2({}, $componentProps);
+		}, [$componentProps]);
+		useEffect(() => {
+			if (storeReactiveRef.current) storeReactiveRef.current.value = _objectSpread2({}, store);
+		}, [store]);
+		useEffect(() => {
+			if (localeReactiveRef.current) localeReactiveRef.current.value = locale;
+		}, [locale]);
+		if (isError) throw errorRef.current;
+		return /* @__PURE__ */ e.createElement(e.Fragment, null, !componentReady && !$silent && !isModuleLoaded(module) ? /* @__PURE__ */ e.createElement(Fallback, {
+			$self: selfRef.current,
+			$store: store,
+			$locale: locale
+		}) : null, /* @__PURE__ */ e.createElement("div", {
+			className: getClassNameWithModule(module, "various-vue-component"),
+			ref: containerDivRef
+		}));
+	};
+	V.displayName = module;
+	const VueComponent = (props) => /* @__PURE__ */ e.createElement(V, props);
+	VueComponent.displayName = "various-vue-component";
+	return VueComponent;
+}
+//#endregion
+//#region src/core/error-boundary.tsx
+var ErrorBoundary = class extends Component {
+	constructor(..._args) {
+		super(..._args);
+		_defineProperty(this, "state", { hasError: false });
+		_defineProperty(this, "error", void 0);
+		_defineProperty(this, "$self", getSelfInfo(this.props));
+		_defineProperty(this, "reload", () => {
+			this.error = void 0;
+			this.setState({ hasError: false });
+		});
+	}
+	componentDidCatch(e) {
+		const { module } = this.props;
+		const error = e instanceof VariousError ? e : new VariousError({
+			module,
+			type: module === "app" ? "APP_ERROR" : "SCRIPT_ERROR",
+			originalError: e
+		});
+		this.setState({ hasError: true });
+		this.error = error;
+		onError(error);
+		resetDependencyConfig(module);
+		updateUnMountComponent(module);
+	}
+	render() {
+		const ErrorFallbackNode = connector_default.getErrorFallbackComponent();
+		const store = getUserStore();
+		const locale = getStore(LOCALE_KEY);
+		if (this.state.hasError) return /* @__PURE__ */ e.createElement(ErrorFallbackNode, {
+			$self: this.$self,
+			$reload: this.reload,
+			$store: store,
+			$error: this.error,
+			$locale: locale
+		});
+		return this.props.children;
+	}
+};
+_defineProperty(ErrorBoundary, "displayName", "various-error-boundary");
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectWithoutPropertiesLoose.js
+function _objectWithoutPropertiesLoose(r, e) {
+	if (null == r) return {};
+	var t = {};
+	for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+		if (e.includes(n)) continue;
+		t[n] = r[n];
+	}
+	return t;
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.142.0/helpers/esm/objectWithoutProperties.js
+function _objectWithoutProperties(e, t) {
+	if (null == e) return {};
+	var o, r, i = _objectWithoutPropertiesLoose(e, t);
+	if (Object.getOwnPropertySymbols) {
+		var s = Object.getOwnPropertySymbols(e);
+		for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+	}
+	return i;
+}
+//#endregion
+//#region src/core/create-component.tsx
+var _excluded = ["$silent", "$ref"];
+var createComponent = (config, storeKeys) => {
+	const { module, url, type = "react" } = config;
+	const C = (type === "vue3" ? vueComponent : reactComponent)({
+		module,
+		url,
+		watchKeys: storeKeys
+	});
+	const component = (props) => {
+		const _ref = props || {}, { $silent, $ref } = _ref;
+		const nextProps = {
+			$componentProps: _objectWithoutProperties(_ref, _excluded),
+			$silent,
+			$ref
+		};
+		return /* @__PURE__ */ e.createElement(ErrorBoundary, {
+			module,
+			url
+		}, /* @__PURE__ */ e.createElement(C, nextProps));
+	};
+	component.displayName = "various-creator";
+	return component;
+};
+//#endregion
+//#region src/standalone/helper.ts
+var defineAsync = (name, dep) => {
+	if (typeof dep === "string") return importModule(name).then((mod) => {
+		setModule(name, mod.default || mod);
+	});
+	return Promise.resolve();
+};
+var importMapCreated = false;
+function ensureImportMap(defines) {
+	if (importMapCreated) return;
+	const imports = {};
+	Object.entries(getAllModuleUrls()).forEach(([name, url]) => {
+		imports[name] = url;
+	});
+	defines.forEach(({ key, value }) => {
+		if (typeof value !== "string") {
+			const blobUrl = createModuleBlobUrl(key);
+			if (blobUrl) imports[key] = blobUrl;
+		}
+	});
+	getInjectedModuleNames().forEach((name) => {
+		if (!imports[name]) {
+			const blobUrl = createModuleBlobUrl(name);
+			if (blobUrl) imports[name] = blobUrl;
+		}
+	});
+	if (Object.keys(imports).length === 0) return;
+	const script = document.createElement("script");
+	script.type = "importmap";
+	script.textContent = JSON.stringify({ imports });
+	document.head.appendChild(script);
+	importMapCreated = true;
+}
+function defineModules(deps) {
+	const defines = [];
+	Object.entries(deps).forEach(([key, value]) => {
+		if (isModuleSpecified(key) || value === void 0) return;
+		if (typeof value === "string") setModuleUrl(key, value);
+		else setModule(key, value);
+		defines.push({
+			key,
+			value
+		});
+	});
+	ensureImportMap(defines);
+	return Promise.all(defines.map((item) => defineAsync(item.key, item.value)));
+}
+//#endregion
+//#region src/standalone/index.tsx
+createStore({
+	[MOUNTED_COMPONENTS_KEY]: [],
+	[MESSAGE_KEY]: null,
+	[CONFIG_KEY]: {},
+	[DEPENDENCIES_KEY]: {},
+	[STANDALONE_CONFIG_READY]: void 0,
+	[LOCALE_KEY]: "en"
+});
+setModule("react", e);
+var Standalone = (props) => {
+	const { dependencies, url, module, type, $componentProps, $ref, storeKeys } = props;
+	const store = useStore(STANDALONE_CONFIG_READY);
+	const [componentReady, setComponentReady] = useState(false);
+	const componentNode = useRef();
+	useEffect(() => {
+		defineModules(dependencies || {}).then(() => {
+			componentNode.current = createComponent({
+				module,
+				url,
+				type
+			}, storeKeys);
+			setComponentReady(true);
+		});
+	}, [
+		url,
+		module,
+		dependencies,
+		type,
+		storeKeys
+	]);
+	if (!componentReady || store[STANDALONE_CONFIG_READY] === false) {
+		const FallBack = connector_default.getFallbackComponent();
+		return /* @__PURE__ */ e.createElement(FallBack, {
+			$self: {
+				module,
+				url: url || ""
+			},
+			$store: getUserStore(),
+			$locale: store[LOCALE_KEY]
+		});
+	}
+	const C = componentNode.current;
+	return /* @__PURE__ */ e.createElement(C, _objectSpread2(_objectSpread2({}, $componentProps), {}, { ref: $ref }));
+};
+Standalone.displayName = "various-standalone";
+//#endregion
+
+//# sourceMappingURL=standalone.mjs.map