@kdesigner/core 0.0.0-alpha.1

package/dist/index.js

@@ -0,0 +1,2281 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.js";
+import { isArray, isBoolean, isInteger, isNumber, isObject, isPlainObject, isPromise, isString, parseUrlParams } from "@kdesigner/shared";
+import { match } from "path-to-regexp";
+import qs from "qs";
+import { ref, shallowRef, toRaw } from "vue";
+import { cloneDeep, omit } from "lodash-es";
+import LRUCache from "lru-cache";
+import axios from "axios";
+//#region src/adapter/link.ts
+function default_jumpTo(router, to) {
+	if (to.startsWith("open://")) {
+		openWindow(to.substring(7));
+		return;
+	}
+	if (to == "__forward") {
+		router.forward();
+		return;
+	}
+	if (to == "__back") {
+		router.back();
+		return;
+	}
+	function go(to, replace) {
+		if (replace) router.push(to);
+		else router.replace(to);
+	}
+	const replace = to.startsWith("replace://");
+	if (replace) to = to.substring(10);
+	if (isPageUrl(to)) {
+		const pos = to.indexOf("?");
+		const query = pos > 0 ? to.substring(pos + 1) : null;
+		const data = query ? parseUrlParams(query) : null;
+		go({
+			name: "jsonPage",
+			params: {
+				path: to,
+				data
+			}
+		}, replace);
+	} else go(to, replace);
+}
+function openWindow(url, opt) {
+	const { target = "__blank", noopener = true, noreferrer = true } = opt || {};
+	const feature = [];
+	if (noopener) feature.push("noopener=yes");
+	if (noreferrer) feature.push("noreferrer=yes");
+	window.open(url, target, feature.join(","));
+}
+function isPageUrl(url) {
+	const pos = url.indexOf("?");
+	if (pos > 0) url = url.substring(0, pos);
+	return url.endsWith(".page.json5") || url.endsWith(".page.yaml") || url.endsWith(".page.json");
+}
+function normalizeLink(to) {
+	if (to.startsWith("/api/")) return to;
+	to = to || "";
+	const location = window.location;
+	if (to && to[0] === "#") to = location.pathname + location.search + to;
+	else if (to && to[0] === "?") to = location.pathname + to;
+	const idx = to.indexOf("?");
+	const idx2 = to.indexOf("#");
+	let pathname = ~idx ? to.substring(0, idx) : ~idx2 ? to.substring(0, idx2) : to;
+	const search = ~idx ? to.substring(idx, ~idx2 ? idx2 : void 0) : "";
+	const hash = ~idx2 ? to.substring(idx2) : "";
+	if (!pathname) pathname = location.pathname;
+	else if (pathname[0] != "/" && !/^https?:\/\//.test(pathname)) {
+		const paths = location.pathname.split("/");
+		paths.pop();
+		let m;
+		while (m = /^\.\.?\//.exec(pathname)) {
+			if (m[0] === "../") paths.pop();
+			pathname = pathname.substring(m[0].length);
+		}
+		pathname = paths.concat(pathname).join("/");
+	}
+	return pathname + search + hash;
+}
+function default_updateLocation(to, replace) {
+	if (to === "goBack") return window.history.back();
+	if (replace && window.history.replaceState) {
+		window.history.replaceState("", document.title, to);
+		return;
+	}
+	location.href = normalizeLink(to);
+}
+function default_isCurrentUrl(to, ctx) {
+	const link = normalizeLink(to);
+	const location = window.location;
+	let pathname = link;
+	let search = "";
+	const idx = link.indexOf("?");
+	if (~idx) {
+		pathname = link.substring(0, idx);
+		search = link.substring(idx);
+	}
+	if (search) {
+		if (pathname !== location.pathname || !location.search) return false;
+		const query = qs.parse(search.substring(1));
+		const currentQuery = qs.parse(location.search.substring(1));
+		return Object.keys(query).every((key) => query[key] === currentQuery[key]);
+	} else if (pathname === location.pathname) return true;
+	else if (!~pathname.indexOf("http") && ~pathname.indexOf(":")) return match(link, {
+		decode: decodeURIComponent,
+		strict: ctx?.strict ?? true
+	})(location.pathname);
+	return false;
+}
+//#endregion
+//#region src/adapter/index.ts
+/**
+* nop-chaos对外部框架的依赖都集中在adapter对象中
+*/
+const adapter = {
+	globalVersion: "v3",
+	configUpgrade(_configName, _version, _prevVersion, _config) {},
+	/**
+	* 返回当前的locale
+	*/
+	useLocale() {
+		throw new Error("not-impl");
+	},
+	useI18n() {
+		throw new Error("not-impl");
+	},
+	usePinia() {
+		throw new Error("not-impl");
+	},
+	/**
+	* 返回指定的Store
+	*/
+	useStore(_name) {
+		throw new Error("not-impl");
+	},
+	useRouter() {
+		throw new Error("not-impl");
+	},
+	useSettings() {
+		return { apiUrl: "" };
+	},
+	/**
+	* 返回当前的认证token
+	*/
+	useAuthToken() {
+		throw new Error("not-impl");
+	},
+	setAuthToken(_token) {},
+	isUserInRole(_role) {
+		throw new Error("not-impl");
+	},
+	useTenantId() {
+		throw new Error("not-impl");
+	},
+	useAppId() {
+		return "nop-chaos";
+	},
+	/**
+	* 自动退出时执行的回调
+	*/
+	logout(_reason) {
+		throw new Error("not-impl");
+	},
+	/**
+	* 根据组件名加载Vue组件
+	*/
+	resolveVueComponent(_name) {
+		throw new Error("not-impl");
+	},
+	processRequest(request) {
+		return request;
+	},
+	processResponse(response) {
+		return response;
+	},
+	compileFunction(code, page) {
+		return new Function("page", "return " + code).call(null, page);
+	},
+	jumpTo(to, _action, _ctx) {
+		return default_jumpTo(adapter.useRouter(), to);
+	},
+	isCurrentUrl: default_isCurrentUrl,
+	updateLocation: default_updateLocation,
+	notify(_type, _msg, _conf) {
+		throw new Error("not-impl");
+	},
+	alert(_msg, _title) {
+		throw new Error("not-impl");
+	},
+	confirm(_msg, _title) {
+		throw new Error("not-impl");
+	},
+	dataMapping(_to, _from = {}, _ignoreFunction = false, _convertKeyToPath, _ignoreIfNotMatch = false) {
+		throw new Error("not-impl");
+	},
+	fetchDict(_dictName, _options) {
+		throw new Error("not-impl");
+	},
+	fetchPageAndTransform(_pageName, _options) {
+		throw new Error("not-impl");
+	},
+	getPage(_pageUrl) {
+		throw new Error("not-impl");
+	}
+};
+function registerAdapter(data) {
+	Object.assign(adapter, data);
+}
+function useAdapter() {
+	return adapter;
+}
+//#endregion
+//#region ../../node_modules/.pnpm/systemjs@6.15.1/node_modules/systemjs/dist/system.js
+/*!
+* SystemJS 6.15.1
+*/
+(function() {
+	function errMsg(errCode, msg) {
+		return (msg || "") + " (SystemJS Error#" + errCode + " https://github.com/systemjs/systemjs/blob/main/docs/errors.md#" + errCode + ")";
+	}
+	var hasSymbol = typeof Symbol !== "undefined";
+	var hasSelf = typeof self !== "undefined";
+	var hasDocument = typeof document !== "undefined";
+	var envGlobal = hasSelf ? self : global;
+	var baseUrl;
+	if (hasDocument) {
+		var baseEl = document.querySelector("base[href]");
+		if (baseEl) baseUrl = baseEl.href;
+	}
+	if (!baseUrl && typeof location !== "undefined") {
+		baseUrl = location.href.split("#")[0].split("?")[0];
+		var lastSepIndex = baseUrl.lastIndexOf("/");
+		if (lastSepIndex !== -1) baseUrl = baseUrl.slice(0, lastSepIndex + 1);
+	}
+	var backslashRegEx = /\\/g;
+	function resolveIfNotPlainOrUrl(relUrl, parentUrl) {
+		if (relUrl.indexOf("\\") !== -1) relUrl = relUrl.replace(backslashRegEx, "/");
+		if (relUrl[0] === "/" && relUrl[1] === "/") return parentUrl.slice(0, parentUrl.indexOf(":") + 1) + relUrl;
+		else if (relUrl[0] === "." && (relUrl[1] === "/" || relUrl[1] === "." && (relUrl[2] === "/" || relUrl.length === 2 && (relUrl += "/")) || relUrl.length === 1 && (relUrl += "/")) || relUrl[0] === "/") {
+			var parentProtocol = parentUrl.slice(0, parentUrl.indexOf(":") + 1);
+			var pathname;
+			if (parentUrl[parentProtocol.length + 1] === "/") if (parentProtocol !== "file:") {
+				pathname = parentUrl.slice(parentProtocol.length + 2);
+				pathname = pathname.slice(pathname.indexOf("/") + 1);
+			} else pathname = parentUrl.slice(8);
+			else pathname = parentUrl.slice(parentProtocol.length + (parentUrl[parentProtocol.length] === "/"));
+			if (relUrl[0] === "/") return parentUrl.slice(0, parentUrl.length - pathname.length - 1) + relUrl;
+			var segmented = pathname.slice(0, pathname.lastIndexOf("/") + 1) + relUrl;
+			var output = [];
+			var segmentIndex = -1;
+			for (var i = 0; i < segmented.length; i++) if (segmentIndex !== -1) {
+				if (segmented[i] === "/") {
+					output.push(segmented.slice(segmentIndex, i + 1));
+					segmentIndex = -1;
+				}
+			} else if (segmented[i] === ".") if (segmented[i + 1] === "." && (segmented[i + 2] === "/" || i + 2 === segmented.length)) {
+				output.pop();
+				i += 2;
+			} else if (segmented[i + 1] === "/" || i + 1 === segmented.length) i += 1;
+			else segmentIndex = i;
+			else segmentIndex = i;
+			if (segmentIndex !== -1) output.push(segmented.slice(segmentIndex));
+			return parentUrl.slice(0, parentUrl.length - pathname.length) + output.join("");
+		}
+	}
+	function resolveUrl(relUrl, parentUrl) {
+		return resolveIfNotPlainOrUrl(relUrl, parentUrl) || (relUrl.indexOf(":") !== -1 ? relUrl : resolveIfNotPlainOrUrl("./" + relUrl, parentUrl));
+	}
+	function resolveAndComposePackages(packages, outPackages, baseUrl, parentMap, parentUrl) {
+		for (var p in packages) {
+			var resolvedLhs = resolveIfNotPlainOrUrl(p, baseUrl) || p;
+			var rhs = packages[p];
+			if (typeof rhs !== "string") continue;
+			var mapped = resolveImportMap(parentMap, resolveIfNotPlainOrUrl(rhs, baseUrl) || rhs, parentUrl);
+			if (!mapped) targetWarning("W1", p, rhs, "bare specifier did not resolve");
+			else outPackages[resolvedLhs] = mapped;
+		}
+	}
+	function resolveAndComposeImportMap(json, baseUrl, outMap) {
+		if (json.imports) resolveAndComposePackages(json.imports, outMap.imports, baseUrl, outMap, null);
+		var u;
+		for (u in json.scopes || {}) {
+			var resolvedScope = resolveUrl(u, baseUrl);
+			resolveAndComposePackages(json.scopes[u], outMap.scopes[resolvedScope] || (outMap.scopes[resolvedScope] = {}), baseUrl, outMap, resolvedScope);
+		}
+		for (u in json.depcache || {}) outMap.depcache[resolveUrl(u, baseUrl)] = json.depcache[u];
+		for (u in json.integrity || {}) outMap.integrity[resolveUrl(u, baseUrl)] = json.integrity[u];
+	}
+	function getMatch(path, matchObj) {
+		if (matchObj[path]) return path;
+		var sepIndex = path.length;
+		do {
+			var segment = path.slice(0, sepIndex + 1);
+			if (segment in matchObj) return segment;
+		} while ((sepIndex = path.lastIndexOf("/", sepIndex - 1)) !== -1);
+	}
+	function applyPackages(id, packages) {
+		var pkgName = getMatch(id, packages);
+		if (pkgName) {
+			var pkg = packages[pkgName];
+			if (pkg === null) return;
+			if (id.length > pkgName.length && pkg[pkg.length - 1] !== "/") targetWarning("W2", pkgName, pkg, "should have a trailing '/'");
+			else return pkg + id.slice(pkgName.length);
+		}
+	}
+	function targetWarning(code, match, target, msg) {
+		console.warn(errMsg(code, "Package target " + msg + ", resolving target '" + target + "' for " + match));
+	}
+	function resolveImportMap(importMap, resolvedOrPlain, parentUrl) {
+		var scopes = importMap.scopes;
+		var scopeUrl = parentUrl && getMatch(parentUrl, scopes);
+		while (scopeUrl) {
+			var packageResolution = applyPackages(resolvedOrPlain, scopes[scopeUrl]);
+			if (packageResolution) return packageResolution;
+			scopeUrl = getMatch(scopeUrl.slice(0, scopeUrl.lastIndexOf("/")), scopes);
+		}
+		return applyPackages(resolvedOrPlain, importMap.imports) || resolvedOrPlain.indexOf(":") !== -1 && resolvedOrPlain;
+	}
+	var toStringTag$1 = hasSymbol && Symbol.toStringTag;
+	var REGISTRY = hasSymbol ? Symbol() : "@";
+	function SystemJS() {
+		this[REGISTRY] = {};
+	}
+	var systemJSPrototype = SystemJS.prototype;
+	systemJSPrototype.import = function(id, parentUrl, meta) {
+		var loader = this;
+		parentUrl && typeof parentUrl === "object" && (meta = parentUrl, parentUrl = void 0);
+		return Promise.resolve(loader.prepareImport()).then(function() {
+			return loader.resolve(id, parentUrl, meta);
+		}).then(function(id) {
+			var load = getOrCreateLoad(loader, id, void 0, meta);
+			return load.C || topLevelLoad(loader, load);
+		});
+	};
+	systemJSPrototype.createContext = function(parentId) {
+		var loader = this;
+		return {
+			url: parentId,
+			resolve: function(id, parentUrl) {
+				return Promise.resolve(loader.resolve(id, parentUrl || parentId));
+			}
+		};
+	};
+	systemJSPrototype.onload = function() {};
+	function loadToId(load) {
+		return load.id;
+	}
+	function triggerOnload(loader, load, err, isErrSource) {
+		loader.onload(err, load.id, load.d && load.d.map(loadToId), !!isErrSource);
+		if (err) throw err;
+	}
+	var lastRegister;
+	systemJSPrototype.register = function(deps, declare, metas) {
+		lastRegister = [
+			deps,
+			declare,
+			metas
+		];
+	};
+	systemJSPrototype.getRegister = function() {
+		var _lastRegister = lastRegister;
+		lastRegister = void 0;
+		return _lastRegister;
+	};
+	function getOrCreateLoad(loader, id, firstParentUrl, meta) {
+		var load = loader[REGISTRY][id];
+		if (load) return load;
+		var importerSetters = [];
+		var ns = Object.create(null);
+		if (toStringTag$1) Object.defineProperty(ns, toStringTag$1, { value: "Module" });
+		var instantiatePromise = Promise.resolve().then(function() {
+			return loader.instantiate(id, firstParentUrl, meta);
+		}).then(function(registration) {
+			if (!registration) throw Error(errMsg(2, "Module " + id + " did not instantiate"));
+			function _export(name, value) {
+				load.h = true;
+				var changed = false;
+				if (typeof name === "string") {
+					if (!(name in ns) || ns[name] !== value) {
+						ns[name] = value;
+						changed = true;
+					}
+				} else {
+					for (var p in name) {
+						var value = name[p];
+						if (!(p in ns) || ns[p] !== value) {
+							ns[p] = value;
+							changed = true;
+						}
+					}
+					if (name && name.__esModule) ns.__esModule = name.__esModule;
+				}
+				if (changed) for (var i = 0; i < importerSetters.length; i++) {
+					var setter = importerSetters[i];
+					if (setter) setter(ns);
+				}
+				return value;
+			}
+			var declared = registration[1](_export, registration[1].length === 2 ? {
+				import: function(importId, meta) {
+					return loader.import(importId, id, meta);
+				},
+				meta: loader.createContext(id)
+			} : void 0);
+			load.e = declared.execute || function() {};
+			return [
+				registration[0],
+				declared.setters || [],
+				registration[2] || []
+			];
+		}, function(err) {
+			load.e = null;
+			load.er = err;
+			triggerOnload(loader, load, err, true);
+			throw err;
+		});
+		var linkPromise = instantiatePromise.then(function(instantiation) {
+			return Promise.all(instantiation[0].map(function(dep, i) {
+				var setter = instantiation[1][i];
+				var meta = instantiation[2][i];
+				return Promise.resolve(loader.resolve(dep, id)).then(function(depId) {
+					var depLoad = getOrCreateLoad(loader, depId, id, meta);
+					return Promise.resolve(depLoad.I).then(function() {
+						if (setter) {
+							depLoad.i.push(setter);
+							if (depLoad.h || !depLoad.I) setter(depLoad.n);
+						}
+						return depLoad;
+					});
+				});
+			})).then(function(depLoads) {
+				load.d = depLoads;
+			});
+		});
+		return load = loader[REGISTRY][id] = {
+			id,
+			i: importerSetters,
+			n: ns,
+			m: meta,
+			I: instantiatePromise,
+			L: linkPromise,
+			h: false,
+			d: void 0,
+			e: void 0,
+			er: void 0,
+			E: void 0,
+			C: void 0,
+			p: void 0
+		};
+	}
+	function instantiateAll(loader, load, parent, loaded) {
+		if (!loaded[load.id]) {
+			loaded[load.id] = true;
+			return Promise.resolve(load.L).then(function() {
+				if (!load.p || load.p.e === null) load.p = parent;
+				return Promise.all(load.d.map(function(dep) {
+					return instantiateAll(loader, dep, parent, loaded);
+				}));
+			}).catch(function(err) {
+				if (load.er) throw err;
+				load.e = null;
+				triggerOnload(loader, load, err, false);
+				throw err;
+			});
+		}
+	}
+	function topLevelLoad(loader, load) {
+		return load.C = instantiateAll(loader, load, load, {}).then(function() {
+			return postOrderExec(loader, load, {});
+		}).then(function() {
+			return load.n;
+		});
+	}
+	var nullContext = Object.freeze(Object.create(null));
+	function postOrderExec(loader, load, seen) {
+		if (seen[load.id]) return;
+		seen[load.id] = true;
+		if (!load.e) {
+			if (load.er) throw load.er;
+			if (load.E) return load.E;
+			return;
+		}
+		var exec = load.e;
+		load.e = null;
+		var depLoadPromises;
+		load.d.forEach(function(depLoad) {
+			try {
+				var depLoadPromise = postOrderExec(loader, depLoad, seen);
+				if (depLoadPromise) (depLoadPromises = depLoadPromises || []).push(depLoadPromise);
+			} catch (err) {
+				load.er = err;
+				triggerOnload(loader, load, err, false);
+				throw err;
+			}
+		});
+		if (depLoadPromises) return Promise.all(depLoadPromises).then(doExec);
+		return doExec();
+		function doExec() {
+			try {
+				var execPromise = exec.call(nullContext);
+				if (execPromise) {
+					execPromise = execPromise.then(function() {
+						load.C = load.n;
+						load.E = null;
+						triggerOnload(loader, load, null, true);
+					}, function(err) {
+						load.er = err;
+						load.E = null;
+						triggerOnload(loader, load, err, true);
+						throw err;
+					});
+					return load.E = execPromise;
+				}
+				load.C = load.n;
+				load.L = load.I = void 0;
+			} catch (err) {
+				load.er = err;
+				throw err;
+			} finally {
+				triggerOnload(loader, load, load.er, true);
+			}
+		}
+	}
+	envGlobal.System = new SystemJS();
+	var importMapPromise = Promise.resolve();
+	var importMap = {
+		imports: {},
+		scopes: {},
+		depcache: {},
+		integrity: {}
+	};
+	var processFirst = hasDocument;
+	systemJSPrototype.prepareImport = function(doProcessScripts) {
+		if (processFirst || doProcessScripts) {
+			processScripts();
+			processFirst = false;
+		}
+		return importMapPromise;
+	};
+	systemJSPrototype.getImportMap = function() {
+		return JSON.parse(JSON.stringify(importMap));
+	};
+	if (hasDocument) {
+		processScripts();
+		window.addEventListener("DOMContentLoaded", processScripts);
+	}
+	systemJSPrototype.addImportMap = function(newMap, mapBase) {
+		resolveAndComposeImportMap(newMap, mapBase || baseUrl, importMap);
+	};
+	function processScripts() {
+		[].forEach.call(document.querySelectorAll("script"), function(script) {
+			if (script.sp) return;
+			if (script.type === "systemjs-module") {
+				script.sp = true;
+				if (!script.src) return;
+				System.import(script.src.slice(0, 7) === "import:" ? script.src.slice(7) : resolveUrl(script.src, baseUrl)).catch(function(e) {
+					if (e.message.indexOf("https://github.com/systemjs/systemjs/blob/main/docs/errors.md#3") > -1) {
+						var event = document.createEvent("Event");
+						event.initEvent("error", false, false);
+						script.dispatchEvent(event);
+					}
+					return Promise.reject(e);
+				});
+			} else if (script.type === "systemjs-importmap") {
+				script.sp = true;
+				var fetchPromise = script.src ? (System.fetch || fetch)(script.src, {
+					integrity: script.integrity,
+					priority: script.fetchPriority,
+					passThrough: true
+				}).then(function(res) {
+					if (!res.ok) throw Error("Invalid status code: " + res.status);
+					return res.text();
+				}).catch(function(err) {
+					err.message = errMsg("W4", "Error fetching systemjs-import map " + script.src) + "\n" + err.message;
+					console.warn(err);
+					if (typeof script.onerror === "function") script.onerror();
+					return "{}";
+				}) : script.innerHTML;
+				importMapPromise = importMapPromise.then(function() {
+					return fetchPromise;
+				}).then(function(text) {
+					extendImportMap(importMap, text, script.src || baseUrl);
+				});
+			}
+		});
+	}
+	function extendImportMap(importMap, newMapText, newMapUrl) {
+		var newMap = {};
+		try {
+			newMap = JSON.parse(newMapText);
+		} catch (err) {
+			console.warn(Error(errMsg("W5", "systemjs-importmap contains invalid JSON") + "\n\n" + newMapText + "\n"));
+		}
+		resolveAndComposeImportMap(newMap, newMapUrl, importMap);
+	}
+	if (hasDocument) {
+		window.addEventListener("error", function(evt) {
+			lastWindowErrorUrl = evt.filename;
+			lastWindowError = evt.error;
+		});
+		var baseOrigin = location.origin;
+	}
+	systemJSPrototype.createScript = function(url) {
+		var script = document.createElement("script");
+		script.async = true;
+		if (url.indexOf(baseOrigin + "/")) script.crossOrigin = "anonymous";
+		var integrity = importMap.integrity[url];
+		if (integrity) script.integrity = integrity;
+		script.src = url;
+		return script;
+	};
+	var lastAutoImportDeps, lastAutoImportTimeout;
+	var autoImportCandidates = {};
+	var systemRegister = systemJSPrototype.register;
+	systemJSPrototype.register = function(deps, declare) {
+		if (hasDocument && document.readyState === "loading" && typeof deps !== "string") {
+			var scripts = document.querySelectorAll("script[src]");
+			var lastScript = scripts[scripts.length - 1];
+			if (lastScript) {
+				lastScript.src;
+				lastAutoImportDeps = deps;
+				var loader = this;
+				lastAutoImportTimeout = setTimeout(function() {
+					autoImportCandidates[lastScript.src] = [deps, declare];
+					loader.import(lastScript.src);
+				});
+			}
+		} else lastAutoImportDeps = void 0;
+		return systemRegister.call(this, deps, declare);
+	};
+	var lastWindowErrorUrl, lastWindowError;
+	systemJSPrototype.instantiate = function(url, firstParentUrl) {
+		var autoImportRegistration = autoImportCandidates[url];
+		if (autoImportRegistration) {
+			delete autoImportCandidates[url];
+			return autoImportRegistration;
+		}
+		var loader = this;
+		return Promise.resolve(systemJSPrototype.createScript(url)).then(function(script) {
+			return new Promise(function(resolve, reject) {
+				script.addEventListener("error", function() {
+					reject(Error(errMsg(3, "Error loading " + url + (firstParentUrl ? " from " + firstParentUrl : ""))));
+				});
+				script.addEventListener("load", function() {
+					document.head.removeChild(script);
+					if (lastWindowErrorUrl === url) reject(lastWindowError);
+					else {
+						var register = loader.getRegister(url);
+						if (register && register[0] === lastAutoImportDeps) clearTimeout(lastAutoImportTimeout);
+						resolve(register);
+					}
+				});
+				document.head.appendChild(script);
+			});
+		});
+	};
+	systemJSPrototype.shouldFetch = function() {
+		return false;
+	};
+	if (typeof fetch !== "undefined") systemJSPrototype.fetch = fetch;
+	var instantiate = systemJSPrototype.instantiate;
+	var jsContentTypeRegEx = /^(text|application)\/(x-)?javascript(;|$)/;
+	systemJSPrototype.instantiate = function(url, parent, meta) {
+		var loader = this;
+		if (!this.shouldFetch(url, parent, meta)) return instantiate.apply(this, arguments);
+		return this.fetch(url, {
+			credentials: "same-origin",
+			integrity: importMap.integrity[url],
+			meta
+		}).then(function(res) {
+			if (!res.ok) throw Error(errMsg(7, res.status + " " + res.statusText + ", loading " + url + (parent ? " from " + parent : "")));
+			var contentType = res.headers.get("content-type");
+			if (!contentType || !jsContentTypeRegEx.test(contentType)) throw Error(errMsg(4, "Unknown Content-Type \"" + contentType + "\", loading " + url + (parent ? " from " + parent : "")));
+			return res.text().then(function(source) {
+				if (source.indexOf("//# sourceURL=") < 0) source += "\n//# sourceURL=" + url;
+				(0, eval)(source);
+				return loader.getRegister(url);
+			});
+		});
+	};
+	systemJSPrototype.resolve = function(id, parentUrl) {
+		parentUrl = parentUrl || baseUrl;
+		return resolveImportMap(importMap, resolveIfNotPlainOrUrl(id, parentUrl) || id, parentUrl) || throwUnresolved(id, parentUrl);
+	};
+	function throwUnresolved(id, parentUrl) {
+		throw Error(errMsg(8, "Unable to resolve bare specifier '" + id + (parentUrl ? "' from " + parentUrl : "'")));
+	}
+	var systemInstantiate = systemJSPrototype.instantiate;
+	systemJSPrototype.instantiate = function(url, firstParentUrl, meta) {
+		var preloads = importMap.depcache[url];
+		if (preloads) for (var i = 0; i < preloads.length; i++) getOrCreateLoad(this, this.resolve(preloads[i], url), url);
+		return systemInstantiate.call(this, url, firstParentUrl, meta);
+	};
+	if (hasSelf && typeof importScripts === "function") systemJSPrototype.instantiate = function(url) {
+		var loader = this;
+		return Promise.resolve().then(function() {
+			importScripts(url);
+			return loader.getRegister(url);
+		});
+	};
+	(function(global) {
+		var systemJSPrototype = global.System.constructor.prototype;
+		var firstGlobalProp, secondGlobalProp, lastGlobalProp;
+		function getGlobalProp(useFirstGlobalProp) {
+			var cnt = 0;
+			var foundLastProp, result;
+			for (var p in global) {
+				if (shouldSkipProperty(p)) continue;
+				if (cnt === 0 && p !== firstGlobalProp || cnt === 1 && p !== secondGlobalProp) return p;
+				if (foundLastProp) {
+					lastGlobalProp = p;
+					result = useFirstGlobalProp && result || p;
+				} else foundLastProp = p === lastGlobalProp;
+				cnt++;
+			}
+			return result;
+		}
+		function noteGlobalProps() {
+			firstGlobalProp = secondGlobalProp = void 0;
+			for (var p in global) {
+				if (shouldSkipProperty(p)) continue;
+				if (!firstGlobalProp) firstGlobalProp = p;
+				else if (!secondGlobalProp) secondGlobalProp = p;
+				lastGlobalProp = p;
+			}
+			return lastGlobalProp;
+		}
+		var impt = systemJSPrototype.import;
+		systemJSPrototype.import = function(id, parentUrl, meta) {
+			noteGlobalProps();
+			return impt.call(this, id, parentUrl, meta);
+		};
+		var emptyInstantiation = [[], function() {
+			return {};
+		}];
+		var getRegister = systemJSPrototype.getRegister;
+		systemJSPrototype.getRegister = function() {
+			var lastRegister = getRegister.call(this);
+			if (lastRegister) return lastRegister;
+			var globalProp = getGlobalProp(this.firstGlobalProp);
+			if (!globalProp) return emptyInstantiation;
+			var globalExport;
+			try {
+				globalExport = global[globalProp];
+			} catch (e) {
+				return emptyInstantiation;
+			}
+			return [[], function(_export) {
+				return { execute: function() {
+					_export(globalExport);
+					_export({
+						default: globalExport,
+						__useDefault: true
+					});
+				} };
+			}];
+		};
+		var isIE11 = typeof navigator !== "undefined" && navigator.userAgent.indexOf("Trident") !== -1;
+		function shouldSkipProperty(p) {
+			return !global.hasOwnProperty(p) || !isNaN(p) && p < global.length || isIE11 && global[p] && typeof window !== "undefined" && global[p].parent === window;
+		}
+	})(typeof self !== "undefined" ? self : global);
+	(function(global) {
+		var systemJSPrototype = global.System.constructor.prototype;
+		var moduleTypesRegEx = /^[^#?]+\.(css|html|json|wasm)([?#].*)?$/;
+		var _shouldFetch = systemJSPrototype.shouldFetch.bind(systemJSPrototype);
+		systemJSPrototype.shouldFetch = function(url) {
+			return _shouldFetch(url) || moduleTypesRegEx.test(url);
+		};
+		var jsonContentType = /^application\/json(;|$)/;
+		var cssContentType = /^text\/css(;|$)/;
+		var wasmContentType = /^application\/wasm(;|$)/;
+		var fetch = systemJSPrototype.fetch;
+		systemJSPrototype.fetch = function(url, options) {
+			return fetch(url, options).then(function(res) {
+				if (options.passThrough) return res;
+				if (!res.ok) return res;
+				var contentType = res.headers.get("content-type");
+				if (jsonContentType.test(contentType)) return res.json().then(function(json) {
+					return new Response(new Blob(["System.register([],function(e){return{execute:function(){e(\"default\"," + JSON.stringify(json) + ")}}})"], { type: "application/javascript" }));
+				});
+				if (cssContentType.test(contentType)) return res.text().then(function(source) {
+					source = source.replace(/url\(\s*(?:(["'])((?:\\.|[^\n\\"'])+)\1|((?:\\.|[^\s,"'()\\])+))\s*\)/g, function(match, quotes, relUrl1, relUrl2) {
+						return [
+							"url(",
+							quotes,
+							resolveUrl(relUrl1 || relUrl2, url),
+							quotes,
+							")"
+						].join("");
+					});
+					return new Response(new Blob(["System.register([],function(e){return{execute:function(){var s=new CSSStyleSheet();s.replaceSync(" + JSON.stringify(source) + ");e(\"default\",s)}}})"], { type: "application/javascript" }));
+				});
+				if (wasmContentType.test(contentType)) return (WebAssembly.compileStreaming ? WebAssembly.compileStreaming(res) : res.arrayBuffer().then(WebAssembly.compile)).then(function(module) {
+					if (!global.System.wasmModules) global.System.wasmModules = Object.create(null);
+					global.System.wasmModules[url] = module;
+					var deps = [];
+					var setterSources = [];
+					if (WebAssembly.Module.imports) WebAssembly.Module.imports(module).forEach(function(impt) {
+						var key = JSON.stringify(impt.module);
+						if (deps.indexOf(key) === -1) {
+							deps.push(key);
+							setterSources.push("function(m){i[" + key + "]=m}");
+						}
+					});
+					return new Response(new Blob(["System.register([" + deps.join(",") + "],function(e){var i={};return{setters:[" + setterSources.join(",") + "],execute:function(){return WebAssembly.instantiate(System.wasmModules[" + JSON.stringify(url) + "],i).then(function(m){e(m.exports)})}}})"], { type: "application/javascript" }));
+				});
+				return res;
+			});
+		};
+	})(typeof self !== "undefined" ? self : global);
+	var toStringTag = typeof Symbol !== "undefined" && Symbol.toStringTag;
+	systemJSPrototype.get = function(id) {
+		var load = this[REGISTRY][id];
+		if (load && load.e === null && !load.E) {
+			if (load.er) return null;
+			return load.n;
+		}
+	};
+	systemJSPrototype.set = function(id, module) {
+		try {
+			new URL(id);
+		} catch (err) {
+			console.warn(Error(errMsg("W3", "\"" + id + "\" is not a valid URL to set in the module registry")));
+		}
+		var ns;
+		if (toStringTag && module[toStringTag] === "Module") ns = module;
+		else {
+			ns = Object.assign(Object.create(null), module);
+			if (toStringTag) Object.defineProperty(ns, toStringTag, { value: "Module" });
+		}
+		var done = Promise.resolve(ns);
+		var load = this[REGISTRY][id] || (this[REGISTRY][id] = {
+			id,
+			i: [],
+			h: false,
+			d: [],
+			e: null,
+			er: void 0,
+			E: void 0
+		});
+		if (load.e || load.E) return false;
+		Object.assign(load, {
+			n: ns,
+			I: void 0,
+			L: void 0,
+			C: done
+		});
+		return ns;
+	};
+	systemJSPrototype.has = function(id) {
+		return !!this[REGISTRY][id];
+	};
+	systemJSPrototype.delete = function(id) {
+		var registry = this[REGISTRY];
+		var load = registry[id];
+		if (!load || load.p && load.p.e !== null || load.E) return false;
+		var importerSetters = load.i;
+		if (load.d) load.d.forEach(function(depLoad) {
+			var importerIndex = depLoad.i.indexOf(load);
+			if (importerIndex !== -1) depLoad.i.splice(importerIndex, 1);
+		});
+		delete registry[id];
+		return function() {
+			var load = registry[id];
+			if (!load || !importerSetters || load.e !== null || load.E) return false;
+			importerSetters.forEach(function(setter) {
+				load.i.push(setter);
+				setter(load.n);
+			});
+			importerSetters = null;
+		};
+	};
+	var iterator = typeof Symbol !== "undefined" && Symbol.iterator;
+	systemJSPrototype.entries = function() {
+		var loader = this, keys = Object.keys(loader[REGISTRY]);
+		var index = 0, ns, key;
+		var result = { next: function() {
+			while ((key = keys[index++]) !== void 0 && (ns = loader.get(key)) === void 0);
+			return {
+				done: key === void 0,
+				value: key !== void 0 && [key, ns]
+			};
+		} };
+		result[iterator] = function() {
+			return this;
+		};
+		return result;
+	};
+})();
+//#endregion
+//#region src/loader/module.ts
+const System$1 = (typeof self !== "undefined" ? self : global).System;
+/**
+* 动态加载js文件
+* @param path js文件路径
+* @returns
+*/
+function importModule(path) {
+	if (path.endsWith(".lib.js") && path.startsWith("/") && !path.startsWith("/p/")) path = "/p/SystemJsProvider__getJs?path=" + encodeURIComponent(path);
+	const url = System$1.resolve(path);
+	return System$1.import(
+		/* @vite-ignore*/
+		url
+	);
+}
+function deleteDynamicModules() {
+	for (const module of System$1.entries()) {
+		const moduleId = module[0];
+		if (moduleId.endsWith(".lib.js")) System$1.delete(moduleId);
+	}
+}
+function registerModule(name, lib) {
+	let libPath = name;
+	if (name.startsWith("./")) libPath = System$1.resolve(name);
+	else if (name.startsWith("@nop/")) libPath = System$1.resolve("./nop/" + name.substring(5) + ".js");
+	else {
+		libPath = System$1.resolve("./nop/" + name + ".js");
+		System$1.addImportMap({ imports: { [name]: libPath } });
+	}
+	System$1.set(libPath, lib);
+}
+function addSystemImportMap(imports) {
+	System$1.addImportMap({ imports });
+}
+//#endregion
+//#region src/shared/constants.ts
+var constants_exports = /* @__PURE__ */ __exportAll({
+	HEADER_ACCESS_TOKEN: () => HEADER_ACCESS_TOKEN,
+	HEADER_APP_ID: () => HEADER_APP_ID,
+	HEADER_TENANT_ID: () => HEADER_TENANT_ID,
+	HEADER_TIMESTAMP: () => HEADER_TIMESTAMP,
+	HEADER_VERSION: () => HEADER_VERSION
+});
+const HEADER_TENANT_ID = "x-tenant-id";
+const HEADER_ACCESS_TOKEN = "x-access-token";
+const HEADER_TIMESTAMP = "x-timestamp";
+const HEADER_APP_ID = "nop-app-id";
+const HEADER_VERSION = "x-version";
+//#endregion
+//#region src/shared/utils.ts
+function normalizeArray(parts, allowAboveRoot) {
+	const res = [];
+	for (let i = 0; i < parts.length; i++) {
+		const p2 = parts[i];
+		if (!p2 || p2 === ".") continue;
+		if (p2 === "..") {
+			if (res.length && res[res.length - 1] !== "..") res.pop();
+			else if (allowAboveRoot) res.push("..");
+		} else res.push(p2);
+	}
+	return res;
+}
+function absolutePath(path, basePath) {
+	if (path.indexOf(":") > 0) return path;
+	let resolvedPath = path;
+	if (basePath && !resolvedPath.startsWith("/")) resolvedPath = basePath + "/../" + path;
+	resolvedPath = normalizeArray(resolvedPath.split("/"), false).join("/");
+	return "/" + resolvedPath;
+}
+function format(msg, placeholderStart, placeholdeEnd, resolver) {
+	let pos = msg.indexOf(placeholderStart);
+	if (pos < 0) return msg;
+	let ret = msg.substring(0, pos);
+	do {
+		pos += placeholderStart.length;
+		let pos2 = msg.indexOf(placeholdeEnd, pos);
+		if (pos2 < 0) {
+			ret += msg.substring(pos);
+			break;
+		} else {
+			const value = resolver(msg.substring(pos, pos2).trim());
+			if (value != null) ret += String(value);
+			pos2 += placeholdeEnd.length;
+			pos = msg.indexOf(placeholderStart, pos2);
+			if (pos < 0) ret += msg.substring(pos2);
+			else ret += msg.substring(pos2, pos);
+		}
+	} while (pos > 0);
+	return ret;
+}
+/**
+* 从后台的TreeBean转换为前台Condition
+* @param node
+*/
+function treeToCondition(node) {
+	if (node.$type === "and" || node.$type == "or" || node.$type == "not") return {
+		condjunction: node.$type,
+		children: (node.$body || []).map(treeToCondition)
+	};
+	else return {
+		op: node.$type,
+		left: {
+			type: "field",
+			field: node.name
+		},
+		right: node.value
+	};
+}
+function conditionToTree(cond) {
+	if (cond.conjuction) return {
+		$type: cond.conjuction,
+		$body: (cond.children || []).map(conditionToTree)
+	};
+	else return {
+		$type: cond.op,
+		name: cond.left.field,
+		value: cond.right
+	};
+}
+function refHolder() {
+	const value = shallowRef();
+	return {
+		getRaw() {
+			return toRaw(value).value;
+		},
+		get() {
+			return value.value;
+		},
+		set(t) {
+			value.value = t;
+		}
+	};
+}
+//#endregion
+//#region src/shared/cache.ts
+function createAsyncCache(options) {
+	const cache = new LRUCache(options);
+	return {
+		get(key, loader) {
+			let promise = cache.get(key);
+			if (promise) return promise.then((v) => v && cloneDeep(v));
+			promise = loader(key);
+			cache.set(key, promise);
+			return promise.then((v) => v && cloneDeep(v)).catch((e) => {
+				cache.delete(key);
+				throw e;
+			});
+		},
+		delete(key) {
+			cache.delete(key);
+		},
+		clear() {
+			cache.clear();
+		}
+	};
+}
+//#endregion
+//#region src/shared/index.ts
+function splitPrefixUrl(url) {
+	if (url.startsWith("@")) {
+		const pos = url.indexOf(":");
+		if (pos < 0) return;
+		return [url.substring(1, pos), url.substring(pos + 1).trim()];
+	}
+	const pos = url.indexOf("://");
+	if (pos < 0) return;
+	return [url.substring(0, pos), url.substring(pos + 3)];
+}
+//#endregion
+//#region src/api/cache.ts
+const pageCache = createAsyncCache({ max: 50 });
+const dictCache = createAsyncCache({ max: 100 });
+function buildLocaleKey(name) {
+	const { useLocale } = useAdapter();
+	return useLocale() + "|" + name;
+}
+function clearLocalCache() {
+	pageCache.clear();
+	dictCache.clear();
+	deleteDynamicModules();
+}
+function clearPageCache() {
+	pageCache.clear();
+}
+function clearDictCache() {
+	dictCache.clear();
+}
+function deletePageCache(path) {
+	const key = buildLocaleKey(path);
+	pageCache.delete(key);
+}
+function withPageCache(path, fn) {
+	const key = buildLocaleKey(path);
+	return pageCache.get(key, fn);
+}
+function withDictCache(dictName, fn) {
+	const key = buildLocaleKey(dictName);
+	return dictCache.get(key, () => {
+		return fn().then((res) => {
+			if (!res.static) dictCache.delete(key);
+			return res;
+		});
+	});
+}
+//#endregion
+//#region src/graphql/gql.ts
+function handleGraphQL(config, graphqlUrl, options) {
+	const url = config.url;
+	const [type, path] = splitPrefixUrl(url) || [];
+	if (type == "query" || type == "mutation" || type == "subscription") {
+		normalizeData(config);
+		config.method = "post";
+		handleGraphQLUrl(type, path, config, graphqlUrl, options);
+		return true;
+	} else if (url.endsWith("/graphql") || url.indexOf("/graphql?") >= 0) {
+		normalizeData(config);
+		config.transformResponse = transformGraphQLResponse;
+		config.method = "post";
+		return true;
+	} else return false;
+}
+function transformGraphQLResponse(data) {
+	data = JSON.parse(data);
+	if (data.errors?.length > 0) {
+		data.status = parseInt(data.extensions?.["nop-status"] || -1);
+		data.msg = data.errors[0].message;
+	} else {
+		data.status = 0;
+		data.msg = data.extensions?.["nop-msg"];
+	}
+	return data;
+}
+function handleGraphQLUrl(opType, url, config, graphql, options) {
+	const pos = url.indexOf("?");
+	if (pos > 0) url = url.substring(0, pos);
+	const pos2 = url.indexOf("/");
+	const action = pos2 > 0 ? url.substring(0, pos2) : url;
+	let selection = pos2 > 0 ? url.substring(pos2 + 1) : void 0;
+	if (selection) {
+		selection = selection.replace(/%20/g, " ");
+		selection = selection.replace(/%0A/g, "\n");
+	}
+	if (!selection) selection = options["gql:selection"];
+	let stdAction = action;
+	const pos3 = action.lastIndexOf("_");
+	if (pos3 > 0) stdAction = action.substring(pos3 + 1);
+	let data = config.data || {};
+	if (stdAction === "findPage") {
+		if (data.op === "loadOptions") {
+			const values = toArray(data.value, options.delimiter);
+			data = { ["filter_" + options.valueField + "__in"]: values };
+			selection = "items{" + (options.valueField || "id") + "," + (options.labelField || "id") + "}";
+		}
+	}
+	let def = operationRegistry[stdAction];
+	if (!def) def = guessDefinition(config.data);
+	const args = [...def.arguments, ...guessExtArgDefinitions(config.data)];
+	let query = opType + " " + action;
+	if (args.length > 0) {
+		query += "(";
+		query += args.map((arg) => "$" + arg.name + ":" + arg.type).join(",");
+		query += ")";
+	}
+	query += "{\n";
+	query += action + "(";
+	if (args.length > 0) query += args.map((arg) => arg.name + ":$" + arg.name).join(",");
+	query += ")";
+	if (selection) {
+		query += "{\n";
+		query += selection;
+		query += "\n}";
+	}
+	query += "\n}";
+	const variables = {};
+	args.forEach((arg) => {
+		const builder = arg.builder || defaultArgBuilders[arg.type] || argValue;
+		variables[arg.name] = builder(data, arg, options);
+	});
+	config.transformResponse = [transformGraphQLResponse, (res) => {
+		if (res.data) res.data = res.data[action];
+		return res;
+	}];
+	config.method = "post";
+	config.url = graphql;
+	config.data = {
+		query,
+		variables
+	};
+}
+function toArray(value, delimiter) {
+	if (isString(value)) value = value.split(delimiter || ",");
+	return value;
+}
+function normalizeData(config) {
+	const { data, params } = splitData(config.params);
+	config.data = {
+		...filterData(config.data),
+		...data
+	};
+	config.params = params;
+}
+function filterData(data) {
+	if (!data) return {};
+	const ret = {};
+	for (const k in data) {
+		if (k.startsWith("__")) continue;
+		ret[k] = data[k];
+	}
+	return ret;
+}
+function splitData(data) {
+	if (!data) return {};
+	const body = {};
+	const params = {};
+	for (const k in data) {
+		if (k.startsWith("__")) continue;
+		if (k.charAt(0) == "@" || k.charAt(0) == "_") params[k] = data[k];
+		else body[k] = data[k];
+	}
+	return {
+		data: body,
+		params
+	};
+}
+function guessDefinition(data) {
+	const args = [];
+	if (data) for (const k in data) {
+		if (isSpecialVarName(k)) continue;
+		args.push({
+			name: k,
+			type: guessType(data[k])
+		});
+	}
+	return { arguments: args };
+}
+function guessExtArgDefinitions(data) {
+	const args = [];
+	if (data) {
+		for (const k in data) if (k.startsWith("v_")) args.push({
+			name: k,
+			type: guessType(data[k])
+		});
+	}
+	return args;
+}
+function isSpecialVarName(name) {
+	return name.startsWith("__") || name.startsWith("@") || name.startsWith("v_");
+}
+function guessType(value) {
+	if (isString(value)) return "String";
+	if (isNumber(value)) {
+		if (isInteger(value)) return "Int";
+		return "Float";
+	}
+	if (isBoolean(value)) return "Boolean";
+	if (isPlainObject(value)) return "Map";
+	if (isArray(value)) return "[String]";
+	return "String";
+}
+function registerOperation(name, op) {
+	operationRegistry[name] = op;
+}
+/**
+* 缺省注册了CRUD操作所对应的GraphQL类型
+*/
+const operationRegistry = {
+	get: { arguments: [{
+		name: "id",
+		type: "String",
+		builder: argString
+	}, {
+		name: "ignoreUnknown",
+		type: "Boolean",
+		builder: argBoolean
+	}] },
+	findPage: { arguments: [{
+		name: "query",
+		type: "QueryBeanInput",
+		builder: argQuery
+	}] },
+	findList: { arguments: [{
+		name: "query",
+		type: "QueryBeanInput",
+		builder: argQuery
+	}] },
+	findFirst: { arguments: [{
+		name: "query",
+		type: "QueryBeanInput",
+		builder: argQuery
+	}] },
+	update: { arguments: [{
+		name: "data",
+		type: "Map",
+		builder: argDataMap
+	}] },
+	save: { arguments: [{
+		name: "data",
+		type: "Map",
+		builder: argDataMap
+	}] },
+	saveOrUpdate: { arguments: [{
+		name: "data",
+		type: "Map",
+		builder: argDataMap
+	}] },
+	upsert: { arguments: [{
+		name: "data",
+		type: "Map",
+		builder: argDataMap
+	}] },
+	copyForNew: { arguments: [{
+		name: "data",
+		type: "Map",
+		builder: argDataMap
+	}] },
+	delete: { arguments: [{
+		name: "id",
+		type: "String",
+		builder: argString
+	}] },
+	batchGet: { arguments: [{
+		name: "ids",
+		type: "[String]",
+		builder: argStringList
+	}] },
+	batchDelete: { arguments: [{
+		name: "ids",
+		type: "[String]",
+		builder: argStringList
+	}] },
+	batchModify: { arguments: [{
+		name: "data",
+		type: "[Map]",
+		builder: argMapList
+	}, {
+		name: "delIds",
+		type: "[String]",
+		builder: argStringList
+	}] }
+};
+const defaultArgBuilders = {
+	String: argString,
+	Boolean: argBoolean,
+	Int: argInt,
+	Float: argFloat,
+	Map: argMap,
+	"[String]": argStringList,
+	"[Map]": argMapList,
+	QueryBeanInput: argQuery
+};
+function argString(data, arg) {
+	const v = data[arg.name];
+	if (v == null) return null;
+	return String(v);
+}
+function argBoolean(data, arg) {
+	const v = data[arg.name];
+	if (v == null) return null;
+	if (v == "false" || v == "n" || v == "0" || v == "N") return false;
+	return !!v;
+}
+function argInt(data, arg) {
+	const v = data[arg.name];
+	if (v == null) return null;
+	return parseInt(v, 10);
+}
+function argFloat(data, arg) {
+	const v = data[arg.name];
+	if (v == null) return null;
+	return parseFloat(v);
+}
+/**
+* 通过 filter_XX__ge=3来表达 <ge name="XX" value="3" />这种过滤条件
+*/
+function argQuery(data, _arg, options) {
+	const query = {};
+	query.limit = data.limit ?? data.pageSize ?? data.perPage ?? 0;
+	query.offset = data.offset ?? query.limit * ((data.page || 0) - 1);
+	query.orderBy = toOrderBy(data.orderBy ?? data.orderField, data.orderDir);
+	query.filter = toFilter(data);
+	query.cursor = data.cursor;
+	query.timeout = data.timeout;
+	return query;
+	function toOrderBy(v, orderDir) {
+		if (v == null) return;
+		if (isString(v)) {
+			if (v.length == 0) return;
+			if (v.endsWith("_label")) v = v.substring(0, v.length - 6);
+			return [{
+				name: v,
+				desc: orderDir == "desc"
+			}];
+		}
+		if (isArray(v)) return v;
+		return [v];
+	}
+	function toFilter(data) {
+		const filter = {
+			$type: "and",
+			$body: []
+		};
+		for (const k in data) if (k.startsWith("filter_")) {
+			let [name, op] = k.substring(7).split("__");
+			op = op || "eq";
+			let value = data[k];
+			if (value == null || value == "") continue;
+			if (value == "__empty") value = "";
+			else if (value == "__null") value = null;
+			let min = void 0;
+			let max = void 0;
+			if (op.startsWith("between") && value != null) {
+				const ary = toArray(value);
+				min = ary[0];
+				max = ary[1];
+				value = void 0;
+			}
+			filter.$body.push({
+				$type: op,
+				name,
+				value,
+				min,
+				max
+			});
+		}
+		if (options.filter) if (options.filter.$type == "and" || options.filter.$type == "_" || options.filter.$type == "filter") filter.$body = filter.$body.concat(options.filter.$body || []);
+		else filter.$body.push(options.filter);
+		if (filter.$body.length == 0) return;
+		return filter;
+	}
+}
+function argDataMap(data, _arg) {
+	if (data == null) return null;
+	const ret = {};
+	for (const k in data) {
+		if (isSpecialVarName(k)) continue;
+		ret[k] = data[k];
+	}
+	return ret;
+}
+function argMap(data, arg) {
+	return data[arg.name];
+}
+function argStringList(data, arg) {
+	const v = data[arg.name];
+	if (v == null) return null;
+	if (isString(v)) return v.split(",");
+	return v;
+}
+function argMapList(data, arg) {
+	return data[arg.name];
+}
+function argValue(data, arg) {
+	return data[arg.name];
+}
+//#endregion
+//#region src/ajax/attachmentAdpator.ts
+/**
+* 处理接口返回附件的情况，好几个地方用
+* @param response HTTP响应对象
+* @param __ 国际化翻译函数
+* @returns 处理后的响应对象或Promise
+*/
+function attachmentAdpator(response, __) {
+	if (response && response.headers && response.headers["content-disposition"]) {
+		const disposition = response.headers["content-disposition"];
+		let filename = "";
+		if (disposition && disposition.indexOf("attachment") !== -1) {
+			const matches = disposition.match(/filename[^;=\n]*=((['"]).*?\2|[^;\n]*)/);
+			if (matches && matches.length) filename = matches[1].replace("UTF-8''", "").replace(/['"]/g, "");
+			if (filename && filename.replace(/[^%]/g, "").length > 2) filename = decodeURIComponent(filename);
+			const contentType = response.headers["content-type"] || "application/octet-stream";
+			const blob = response.data instanceof Blob ? response.data : new Blob([response.data], { type: contentType });
+			const navigator = window.navigator;
+			if (typeof navigator.msSaveBlob !== "undefined") navigator.msSaveBlob(blob, filename);
+			else {
+				const URL = window.URL || window.webkitURL;
+				const downloadUrl = URL.createObjectURL(blob);
+				if (filename) {
+					const anchor = document.createElement("a");
+					if (typeof anchor.download === "undefined") window.location.href = downloadUrl;
+					else {
+						anchor.href = downloadUrl;
+						anchor.download = filename;
+						anchor.style.display = "none";
+						document.body.appendChild(anchor);
+						anchor.click();
+						document.body.removeChild(anchor);
+					}
+				} else window.location.href = downloadUrl;
+				setTimeout(() => {
+					URL.revokeObjectURL(downloadUrl);
+				}, 100);
+			}
+			return {
+				...response,
+				data: {
+					status: 0,
+					msg: __("sys.api.downloading")
+				}
+			};
+		}
+	} else if (response.data instanceof Blob) return new Promise((resolve, reject) => {
+		const reader = new FileReader();
+		reader.addEventListener("loadend", () => {
+			const text = reader.result;
+			try {
+				const parsedData = JSON.parse(text);
+				resolve({
+					...response,
+					data: { ...parsedData }
+				});
+			} catch (error) {
+				reject(/* @__PURE__ */ new Error(`解析响应数据失败: ${error instanceof Error ? error.message : String(error)}`));
+			}
+		});
+		reader.addEventListener("error", () => {
+			reject(/* @__PURE__ */ new Error("读取Blob数据失败"));
+		});
+		reader.readAsText(response.data);
+	});
+	return response;
+}
+//#endregion
+//#region src/ajax/ajax.ts
+const GRAPHQL_URL = "/graphql";
+const ajax = axios.create({});
+ajax.interceptors.response.use((res) => {
+	const token = res.headers[HEADER_ACCESS_TOKEN];
+	if (token) useAdapter().setAuthToken(token);
+	return res;
+});
+const isCancel = axios.isCancel;
+function createCancelToken(cancelExecutor) {
+	return new axios.CancelToken(cancelExecutor);
+}
+function fetcherOk(data) {
+	return {
+		status: 200,
+		headers: {},
+		data: {
+			status: 0,
+			msg: "",
+			data
+		}
+	};
+}
+function responseOk(data) {
+	return {
+		status: 0,
+		msg: "",
+		data
+	};
+}
+function ajaxRequest(options) {
+	const { notify, alert } = useAdapter();
+	return ajaxFetch(options).then((d) => {
+		const isUnauthorized = d.status == 401 || d.data?.status == 401;
+		if (!options.silent && !isUnauthorized) {
+			if (d.data?.msg) if (options.config?.useAlert) alert(d.data.msg);
+			else notify(d.data?.status == 0 ? "info" : "error", d.data.msg);
+		}
+		if (d.data?.status != 0) throw new Error(d.data?.msg || "ajax-fail:\ncode=" + d.data?.code + ",status=" + d.data?.status);
+		return d.data.data;
+	});
+}
+/**
+* 提供的对外接口符合amis框架的要求
+*/
+function ajaxFetch(options) {
+	options.config = options.config || {};
+	let url = options.url;
+	if (!url || typeof url !== "string") return Promise.resolve({
+		status: 500,
+		data: {
+			status: -1,
+			msg: "sys.api.errMsg500"
+		}
+	});
+	let query = options.query || {};
+	const pos = url.indexOf("?");
+	if (pos > 0) {
+		query = {
+			...query,
+			...parseUrlParams(url.substring(pos + 1))
+		};
+		url = url.substring(0, pos);
+	}
+	options.query = query;
+	const [type, path] = splitPrefixUrl(url) || [];
+	if (type == "action") {
+		const actionName = path;
+		const action = options._page?.getAction(actionName);
+		if (!action) return Promise.reject(/* @__PURE__ */ new Error("nop.err.unknown-action:" + actionName));
+		try {
+			const result = action(options);
+			return Promise.resolve(result).then((res) => {
+				if (res == null) return fetcherOk(res);
+				return res;
+			});
+		} catch (e) {
+			return Promise.reject(e);
+		}
+	} else if (type == "dict") return useAdapter().fetchDict(path, options);
+	else if (type == "page") return useAdapter().fetchPageAndTransform(path, options);
+	const globSetting = useAdapter().useSettings();
+	if (globSetting.apiUrl && options.config.useApiUrl !== false) url = `${globSetting.apiUrl}${url}`;
+	function normalizeData(data) {
+		if (!data) return data;
+		if (data instanceof FormData || data instanceof ArrayBuffer) return data;
+		return Object.assign({}, data);
+	}
+	const data = normalizeData(options.data);
+	const config = {
+		withCredentials: options.config.withCredentials ?? true,
+		url,
+		method: options.method || "post",
+		headers: options.headers || {},
+		data,
+		params: query,
+		responseType: options.responseType
+	};
+	if (options.config?.cancelExecutor) {
+		const controller = new AbortController();
+		options.config.cancelExecutor(() => {
+			controller.abort();
+		});
+		config.signal = controller.signal;
+	}
+	prepareHeaders(config, { withToken: options.config.withToken });
+	handleGraphQL(config, GRAPHQL_URL, options);
+	if (config.method?.toLowerCase() == "get") {
+		config.params = {
+			...config.data,
+			...query
+		};
+		config.data = null;
+	}
+	const { useI18n, processRequest, processResponse } = useAdapter();
+	return processResponse(ajax.request(processRequest(config)).then((res) => {
+		if (res.status == 200 && options.config?.rawResponse) res.data = responseOk(res.data);
+		return res;
+	}).catch((error) => {
+		if (axios.isCancel(error)) throw error;
+		const { t } = useI18n();
+		const { response } = error || {};
+		if (!response?.status) throw new Error(t("sys.api.apiRequestFailed"));
+		const err = error.toString();
+		let errMessage = normalizeErrMessage(response.status, "");
+		if (!errMessage && err?.includes("Network Error")) errMessage = t("sys.api.networkExceptionMsg");
+		if (response.data?.status == null) return {
+			status: response.status,
+			data: {
+				status: -1,
+				msg: errMessage
+			}
+		};
+		return response;
+	}).then((response) => {
+		if (options.responseType == "blob") {
+			if (response.status == 401) {
+				if (!isLogoutRequest(options)) doLogout("401");
+				return response;
+			}
+			const __ = useI18n().t;
+			return attachmentAdpator(response, __);
+		}
+		let data = response.data || {};
+		if (response.status == 401 || data.status == 401) {
+			if (!isLogoutRequest(options)) doLogout("401");
+		} else if (data.status == 0 || data.status == 200) {
+			if (options.responseKey) data = { [options.responseKey]: data.data };
+		}
+		response.data = data;
+		return response;
+	}));
+}
+function prepareHeaders(config, opts) {
+	const { useAuthToken, useTenantId, useLocale, useAppId, globalVersion } = useAdapter();
+	const token = useAuthToken();
+	let tenantid = useTenantId();
+	config.headers = config.headers || {};
+	config.headers["nop-locale"] = useLocale()?.replace("_", "-");
+	config.headers["x-requested-with"] = "XMLHttpRequest";
+	if (token && opts.withToken !== false) {
+		config.headers.Authorization = `Bearer ${token}`;
+		config.headers[HEADER_TIMESTAMP] = (/* @__PURE__ */ new Date()).getTime();
+		if (!tenantid) tenantid = "0";
+		config.headers[HEADER_TENANT_ID] = tenantid;
+		config.headers[HEADER_VERSION] = globalVersion;
+		const appId = useAppId();
+		if (appId) config.headers[HEADER_APP_ID] = appId;
+	}
+}
+function normalizeErrMessage(status, msg) {
+	const { t } = useAdapter().useI18n();
+	let errMessage = "";
+	switch (status) {
+		case 401:
+			errMessage = msg || t("sys.api.errMsg401");
+			break;
+		case 403:
+			errMessage = t("sys.api.errMsg403");
+			break;
+		case 404:
+			errMessage = t("sys.api.errMsg404");
+			break;
+		case 405:
+			errMessage = t("sys.api.errMsg405");
+			break;
+		case 408:
+			errMessage = t("sys.api.errMsg408");
+			break;
+		case 500:
+			errMessage = t("sys.api.errMsg500");
+			break;
+		case 501:
+			errMessage = t("sys.api.errMsg501");
+			break;
+		case 502:
+			errMessage = t("sys.api.errMsg502");
+			break;
+		case 503:
+			errMessage = t("sys.api.errMsg503");
+			break;
+		case 504:
+			errMessage = t("sys.api.errMsg504");
+			break;
+		case 505: errMessage = t("sys.api.errMsg505");
+	}
+	return errMessage;
+}
+/** 是否为退出登录请求（其 401 不应再触发 logout） */
+function isLogoutRequest(options) {
+	return typeof options.url === "string" && options.url.includes("LoginApi__logout");
+}
+/** 防止并发 401 / logout 回调再次发请求导致死循环 */
+let loggingOut = false;
+function doLogout(reason) {
+	if (loggingOut) return;
+	loggingOut = true;
+	try {
+		const { setAuthToken, logout } = useAdapter();
+		setAuthToken(void 0);
+		logout(reason);
+	} finally {
+		queueMicrotask(() => {
+			loggingOut = false;
+		});
+	}
+}
+//#endregion
+//#region src/debug/debug.ts
+const debug$1 = ref(false);
+const supportDebug$1 = ref(false);
+function toggleDebug() {
+	setDebug(!debug$1.value);
+}
+function setDebug(b) {
+	debug$1.value = b;
+}
+/**
+* 是否进入开发调试状态。调试状态下显示在线编辑器按钮，并设置amisDebug=1，启用AMIS内置的调试器。
+* 根据后台返回的SiteMap.supportDebug属性进行初始化
+*/
+function useDebug() {
+	return {
+		debug: debug$1,
+		supportDebug: supportDebug$1,
+		toggleDebug,
+		setDebug
+	};
+}
+//#endregion
+//#region src/api/page-api.ts
+const PageApis = {
+	DevTool__clearComponentCache,
+	PageProvider__getPage,
+	PageProvider__getPageSource,
+	PageProvider__rollbackPageSource,
+	PageProvider__savePageSource,
+	DictProvider__getDict
+};
+function DevTool__clearComponentCache() {
+	const { debug } = useDebug();
+	if (debug) return ajaxRequest({
+		method: "post",
+		url: "@mutation:DevTool__clearComponentCache"
+	});
+	return Promise.resolve({});
+}
+function PageProvider__getPage(path) {
+	if (import.meta.env.VITE_USE_MOCK) return ajaxRequest({
+		method: "get",
+		url: `/mock${path}`,
+		config: { rawResponse: true }
+	});
+	if (path.startsWith("/p/")) return withPageCache(path, () => {
+		return ajaxRequest({
+			method: "get",
+			url: path
+		});
+	});
+	return withPageCache(path, () => {
+		return ajaxRequest({
+			method: "post",
+			url: "@query:PageProvider__getPage",
+			data: { path }
+		});
+	});
+}
+function PageProvider__getPageSource(path, silent) {
+	return ajaxRequest({
+		method: "post",
+		url: "@query:PageProvider__getPageSource",
+		data: { path },
+		silent
+	}).then((page) => {
+		page.__baseUrl = path;
+		return page;
+	});
+}
+function PageProvider__rollbackPageSource(path, silent) {
+	return ajaxRequest({
+		method: "post",
+		url: "@mutation:PageProvider__rollbackPageSource",
+		data: { path },
+		silent
+	});
+}
+function PageProvider__savePageSource(path, data, silent) {
+	deletePageCache(path);
+	return ajaxRequest({
+		method: "post",
+		url: "@mutation:PageProvider__savePageSource",
+		data: {
+			path,
+			data: omit(data, "__baseUrl")
+		},
+		silent
+	});
+}
+function DictProvider__getDict(dictName, silent) {
+	return withDictCache(dictName, () => {
+		return ajaxRequest({
+			method: "post",
+			url: "@query:DictProvider__getDict/static,options{value,label}",
+			data: { dictName },
+			silent
+		});
+	});
+}
+//#endregion
+//#region src/api/user-api.ts
+const { supportDebug, debug } = useDebug();
+const UserApis = {
+	SiteMapApi__getSiteMap,
+	LoginApi__login,
+	LoginApi__getLoginUserInfo,
+	LoginApi__logout,
+	LoginApi__generateVerifyCode,
+	CommonApi__getGlobalData
+};
+/** @deprecated 此功能已废弃，将在后续版本中移除 */
+async function CommonApi__getGlobalData() {
+	return { ...await ajaxRequest({
+		url: "/r/GlobalConfigBizModel__findGlobalConfigList",
+		data: {}
+	}).catch(() => {
+		return {};
+	}) };
+}
+function SiteMapApi__getSiteMap() {
+	return ajaxRequest({
+		url: "/r/SiteMapApi__getSiteMap",
+		data: { siteId: "main" }
+	}).then((data) => {
+		supportDebug.value = data.supportDebug;
+		debug.value = data.supportDebug;
+		return data;
+	});
+}
+function LoginApi__login(req) {
+	return ajaxRequest({
+		url: `/r/LoginApi__login?@selection=token:accessToken`,
+		data: req,
+		silent: true
+	});
+}
+function LoginApi__getLoginUserInfo() {
+	const { useAuthToken } = useAdapter();
+	return ajaxRequest({
+		url: "@query:LoginApi__getLoginUserInfo/userId,username:userName,realname:nickName",
+		data: { accessToken: useAuthToken() }
+	});
+}
+function LoginApi__logout() {
+	const { useAuthToken } = useAdapter();
+	return ajaxRequest({
+		url: "@mutation:LoginApi__logout",
+		data: { accessToken: useAuthToken() },
+		silent: true
+	});
+}
+function LoginApi__generateVerifyCode(verifySecret) {
+	return ajaxRequest({
+		url: "/r/LoginApi__generateVerifyCode",
+		method: "get",
+		data: { verifySecret }
+	});
+}
+//#endregion
+//#region src/page/processor.ts
+/**
+* 查找所有具有typeProp指定的属性的节点，并调用processor进行处理，返回结果将会替换原节点。
+* 例如识别xui:roles属性，自动删除没有对应权限的节点
+*
+* @param json json对象
+* @param typeProp 类型字段名
+* @param processor 处理器
+* @returns 经过处理替换后得到的节点
+*/
+async function processXuiDirective(json, typeProp, processor) {
+	const futures = [];
+	const ret = _processXuiDirective(json, typeProp, processor, futures);
+	await Promise.all(futures);
+	return ret;
+}
+function _processXuiDirective(json, typeProp, processor, futures) {
+	if (!json) return json;
+	function processProps(json) {
+		for (const key in json) {
+			let v = json[key];
+			v = _processXuiDirective(v, typeProp, processor, futures);
+			if (v === void 0) delete json[key];
+			else if (v != json[key]) {
+				json[key] = v;
+				if (isPromise(v)) {
+					v.then((ret) => {
+						if (ret === void 0) delete json[key];
+						else json[key] = ret;
+					});
+					json[key] = v;
+					futures.push(v);
+				}
+			}
+		}
+		return json;
+	}
+	if (isArray(json)) for (let i = 0, n = json.length; i < n; i++) {
+		const child = _processXuiDirective(json[i], typeProp, processor, futures);
+		if (child === void 0) {
+			json.splice(i, 1);
+			i--;
+			n--;
+		} else if (child != json[i]) {
+			json[i] = child;
+			if (isPromise(child)) child.then((ret) => {
+				const idx = json.indexOf(child);
+				if (idx < 0) return;
+				if (ret == void 0) json.splice(idx, 1);
+				else json[idx] = ret;
+			});
+		}
+	}
+	else if (isObject(json)) {
+		const type = json[typeProp];
+		if (type) return processor(type, json, processProps);
+		processProps(json);
+	}
+	return json;
+}
+/**
+* 对json对象中的字符串值调用processor来处理
+* @param json 待处理的对象
+* @param processor 处理器
+* @returns
+*/
+function processXuiValue(json, processor) {
+	if (!json) return json;
+	function processProps(json) {
+		for (const key in json) {
+			let v = json[key];
+			if (isString(v)) {
+				v = processor(v, key, json);
+				if (v === void 0) delete json[key];
+				else if (v != json[key]) json[key] = v;
+			} else processXuiValue(v, processor);
+		}
+		return json;
+	}
+	if (isArray(json)) for (let i = 0, n = json.length; i < n; i++) {
+		const child = json[i];
+		if (isString(child)) {
+			const v = processor(child, i, json);
+			if (v === void 0) {
+				delete json[i];
+				i--;
+				n--;
+			} else if (v != json[i]) json[i] = v;
+		} else processXuiValue(child, processor);
+	}
+	else if (isObject(json)) processProps(json);
+	return json;
+}
+//#endregion
+//#region src/page/action.ts
+/**
+* 通过xui:import可以引入SystemJs格式的js模块，通过@action:xxx，@fn:(a,b)=>expr这种形式可以调用js模块中的函数
+*
+* 例如 {
+*    "xui:import": "a.lib"
+*    "page": {
+*       dialog: {
+*          "xui:import": "b.lib"
+*          api: "@action:a.f1"
+*       }
+*    }
+* }
+*
+* 上面的例子中@action:a.f1首先向上查找最近的xui:import引入的js库，如果没有找到，则继续向上查找直到顶层的节点。
+*
+* @action：xxx与 @fn:(a,b)=> expr的区别在于 @action:xxx对应函数名，@fn:(a,b)=>expr则是直接定义匿名函数实现
+*
+* @param json json schema
+*/
+async function bindActions(pageUrl, json, page) {
+	if (!json) return;
+	page.resetActions();
+	const promises = [];
+	const fnStack = [];
+	processXuiDirective(json, "xui:import", (modulePaths, obj, processProps) => {
+		const fnScope = {
+			standalone: obj["xui:standalone"],
+			libs: {}
+		};
+		fnStack.push(fnScope);
+		fetchModules(pageUrl, modulePaths, promises, fnScope);
+		processProps(obj);
+		return obj;
+	});
+	await Promise.all(promises);
+	let stackIndex = -1;
+	function process(json) {
+		if (!isPlainObject(json)) return;
+		const modulePaths = json["xui:import"];
+		if (modulePaths) stackIndex++;
+		for (const key in json) {
+			const v = json[key];
+			if (!v) continue;
+			if (isString(v)) json[key] = processValue(key, v);
+			else if (isArray(v)) for (let i = 0, n = v.length; i < n; i++) process(v[i]);
+			else process(v);
+		}
+		if (modulePaths) stackIndex--;
+	}
+	function processValue(_key, v) {
+		const [type, path] = splitPrefixUrl(v) || [];
+		if (!type) return v;
+		if ([
+			"query",
+			"mutation",
+			"graphql",
+			"dict",
+			"page"
+		].includes(type)) return type + "://" + path;
+		else if (type == "action") {
+			const fnName = path.split("-")[0];
+			const action = findAction(fnName, fnStack, stackIndex, page);
+			for (let i = 0; i < 1e3; i++) {
+				const actionName = i == 0 ? fnName : fnName + "-" + i;
+				const existed = page.getAction(actionName);
+				if (!existed) {
+					page.registerAction(actionName, action);
+					return "action://" + actionName;
+				} else if (existed == action) return "action://" + actionName;
+			}
+			throw new Error("nop.err.action-name-conflict:" + v);
+		} else if (type == "fn") return wrapFunc(buildFunction(path, page), v);
+		return v;
+	}
+	process(json);
+}
+function buildFunction(fn, page) {
+	return useAdapter().compileFunction(fn, page);
+}
+function fetchModules(pageUrl, modulePaths, promises, fnScope) {
+	if (isString(modulePaths)) modulePaths = modulePaths.split(",").reduce((m, p) => {
+		m[getPathName(p)] = p;
+		return m;
+	}, {});
+	for (const moduleName in modulePaths) {
+		const promise = importModule(absolutePath(modulePaths[moduleName], pageUrl)).then((mod) => {
+			fnScope.libs[moduleName] = mod;
+		});
+		promises.push(promise);
+	}
+}
+function getPathName(path) {
+	const pos = path.lastIndexOf("/");
+	if (pos >= 0) path = path.substring(pos + 1);
+	const pos2 = path.indexOf(".");
+	if (pos2 > 0) return path.substring(0, pos2);
+	return path;
+}
+function findAction(fnName, fnStack, stackIndex, page) {
+	const pos = fnName.indexOf(".");
+	if (pos < 0) {
+		const api = page.getAction(fnName);
+		if (!api) throw new Error("nop.err.unknown-action:" + fnName);
+		return api;
+	}
+	const libName = fnName.substring(0, pos);
+	const methodName = fnName.substring(pos + 1);
+	for (let i = stackIndex; i >= 0; i--) {
+		const fnScope = fnStack[i];
+		if (fnScope.standalone) break;
+		const lib = fnScope.libs[libName];
+		if (lib?.[methodName]) return lib[methodName];
+	}
+	throw new Error("nop.err.unknown-action:" + fnName);
+}
+/**
+* 将函数的JSON序列化结果固化为指定值
+*/
+function wrapFunc(fn, text) {
+	const ret = (...args) => fn(...args);
+	ret.toJSON = () => text;
+	return ret;
+}
+//#endregion
+//#region src/page/registry.ts
+const g_components = {};
+function registerXuiComponent(type, component) {
+	g_components[type] = component;
+}
+function unregisterXuiComponent(type) {
+	delete g_components[type];
+}
+function resolveXuiComponent(type, json) {
+	const comp = g_components[type];
+	if (!comp) throw new Error("nop.err.xui.unknown-component:" + type);
+	return comp(json);
+}
+//#endregion
+//#region src/page/transform.ts
+async function transformPageJson(pageUrl, json) {
+	json.__baseUrl = pageUrl;
+	json = await processXuiDirective(json, "xui:roles", filterByAuth);
+	json = await processXuiDirective(json, "xui:component", resolveXuiComponent);
+	return json;
+}
+function filterByAuth(roles, json) {
+	const { isUserInRole } = useAdapter();
+	if (!isUserInRole(roles)) return;
+	return json;
+}
+//#endregion
+//#region src/page/page.ts
+let g_nextIndex = 0;
+function createPage(options) {
+	let actions = { ...options.actions };
+	return {
+		id: "page_" + String(g_nextIndex++),
+		getAction(name) {
+			return actions[name];
+		},
+		registerAction(name, fn) {
+			actions[name] = fn;
+		},
+		resetActions() {
+			actions = { ...options.actions };
+		},
+		getComponent: options.getComponent,
+		getScopedStore: options.getScopedStore,
+		getState: options.getState,
+		setState: options.setState
+	};
+}
+//#endregion
+//#region src/scope.ts
+let s_page;
+function usePage() {
+	return s_page;
+}
+function providePage(page) {
+	s_page = page;
+}
+let s_scoped;
+function useScoped() {
+	return s_scoped;
+}
+function provideScoped(scoped) {
+	s_scoped = scoped;
+}
+let s_scopedStore;
+function useScopedStore() {
+	return s_scopedStore;
+}
+function provideScopedStore(store) {
+	s_scopedStore = store;
+}
+function clearScoped() {
+	s_page = void 0;
+	s_scoped = void 0;
+	s_scopedStore = void 0;
+}
+//#endregion
+//#region src/schema-type.ts
+const schemaProcessorTypes = {};
+function registerSchemaProcessorType(typeName, schemaProcessorType) {
+	schemaProcessorTypes[typeName] = schemaProcessorType;
+}
+function getSchemaProcessorType(typeName) {
+	return schemaProcessorTypes[typeName];
+}
+//#endregion
+//#region src/index.ts
+registerModule("@kdesigner/core", /* @__PURE__ */ __exportAll({
+	CONSTANTS: () => constants_exports,
+	PageApis: () => PageApis,
+	UserApis: () => UserApis,
+	absolutePath: () => absolutePath,
+	addSystemImportMap: () => addSystemImportMap,
+	ajax: () => ajax,
+	ajaxFetch: () => ajaxFetch,
+	ajaxRequest: () => ajaxRequest,
+	bindActions: () => bindActions,
+	clearDictCache: () => clearDictCache,
+	clearLocalCache: () => clearLocalCache,
+	clearPageCache: () => clearPageCache,
+	clearScoped: () => clearScoped,
+	conditionToTree: () => conditionToTree,
+	createAsyncCache: () => createAsyncCache,
+	createCancelToken: () => createCancelToken,
+	createPage: () => createPage,
+	default_isCurrentUrl: () => default_isCurrentUrl,
+	default_jumpTo: () => default_jumpTo,
+	default_updateLocation: () => default_updateLocation,
+	deleteDynamicModules: () => deleteDynamicModules,
+	deletePageCache: () => deletePageCache,
+	fetcherOk: () => fetcherOk,
+	format: () => format,
+	getSchemaProcessorType: () => getSchemaProcessorType,
+	handleGraphQL: () => handleGraphQL,
+	importModule: () => importModule,
+	isCancel: () => isCancel,
+	isPageUrl: () => isPageUrl,
+	openWindow: () => openWindow,
+	processXuiDirective: () => processXuiDirective,
+	processXuiValue: () => processXuiValue,
+	providePage: () => providePage,
+	provideScoped: () => provideScoped,
+	provideScopedStore: () => provideScopedStore,
+	refHolder: () => refHolder,
+	registerAdapter: () => registerAdapter,
+	registerModule: () => registerModule,
+	registerOperation: () => registerOperation,
+	registerSchemaProcessorType: () => registerSchemaProcessorType,
+	registerXuiComponent: () => registerXuiComponent,
+	resolveXuiComponent: () => resolveXuiComponent,
+	responseOk: () => responseOk,
+	splitPrefixUrl: () => splitPrefixUrl,
+	transformPageJson: () => transformPageJson,
+	treeToCondition: () => treeToCondition,
+	unregisterXuiComponent: () => unregisterXuiComponent,
+	useAdapter: () => useAdapter,
+	useDebug: () => useDebug,
+	usePage: () => usePage,
+	useScoped: () => useScoped,
+	useScopedStore: () => useScopedStore,
+	withDictCache: () => withDictCache,
+	withPageCache: () => withPageCache
+}));
+registerAdapter({
+	fetchDict(dictName, options) {
+		return PageApis.DictProvider__getDict(dictName, options.silent || false).then((res) => fetcherOk(res));
+	},
+	fetchPageAndTransform(pagePath, options) {
+		return PageApis.PageProvider__getPage(pagePath).then(async (pageData) => {
+			pageData = await transformPageJson(pagePath, pageData);
+			if (options._page) bindActions(pagePath, pageData, options._page);
+			return fetcherOk(pageData);
+		});
+	},
+	getPage(pageUrl) {
+		return PageApis.PageProvider__getPage(pageUrl);
+	}
+});
+//#endregion
+export { constants_exports as CONSTANTS, PageApis, UserApis, absolutePath, addSystemImportMap, ajax, ajaxFetch, ajaxRequest, bindActions, clearDictCache, clearLocalCache, clearPageCache, clearScoped, conditionToTree, createAsyncCache, createCancelToken, createPage, default_isCurrentUrl, default_jumpTo, default_updateLocation, deleteDynamicModules, deletePageCache, fetcherOk, format, getSchemaProcessorType, handleGraphQL, importModule, isCancel, isPageUrl, openWindow, processXuiDirective, processXuiValue, providePage, provideScoped, provideScopedStore, refHolder, registerAdapter, registerModule, registerOperation, registerSchemaProcessorType, registerXuiComponent, resolveXuiComponent, responseOk, splitPrefixUrl, transformPageJson, treeToCondition, unregisterXuiComponent, useAdapter, useDebug, usePage, useScoped, useScopedStore, withDictCache, withPageCache };
+
+//# sourceMappingURL=index.js.map